volcano.sh/volcano@v1.9.0/pkg/scheduler/api/resource_info_test.go (about)

     1  /*
     2  Copyright 2019 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package api
    18  
    19  import (
    20  	"math"
    21  	"reflect"
    22  	"sort"
    23  	"testing"
    24  
    25  	v1 "k8s.io/api/core/v1"
    26  	"k8s.io/apimachinery/pkg/api/resource"
    27  )
    28  
    29  func TestNewResource(t *testing.T) {
    30  	tests := []struct {
    31  		resourceList v1.ResourceList
    32  		expected     *Resource
    33  	}{
    34  		{
    35  			resourceList: map[v1.ResourceName]resource.Quantity{},
    36  			expected:     &Resource{},
    37  		},
    38  		{
    39  			resourceList: map[v1.ResourceName]resource.Quantity{
    40  				v1.ResourceCPU:                      *resource.NewScaledQuantity(4, -3),
    41  				v1.ResourceMemory:                   *resource.NewQuantity(2000, resource.BinarySI),
    42  				"scalar.test/" + "scalar1":          *resource.NewQuantity(1, resource.DecimalSI),
    43  				v1.ResourceHugePagesPrefix + "test": *resource.NewQuantity(2, resource.BinarySI),
    44  				v1.ResourceEphemeralStorage:         *resource.NewQuantity(3, resource.BinarySI),
    45  			},
    46  			expected: &Resource{
    47  				MilliCPU: 4,
    48  				Memory:   2000,
    49  				ScalarResources: map[v1.ResourceName]float64{
    50  					"scalar.test/scalar1":       1000,
    51  					"hugepages-test":            2000,
    52  					v1.ResourceEphemeralStorage: 3000},
    53  			},
    54  		},
    55  	}
    56  
    57  	for _, test := range tests {
    58  		r := NewResource(test.resourceList)
    59  		if !reflect.DeepEqual(test.expected, r) {
    60  			t.Errorf("expected: %#v, got: %#v", test.expected, r)
    61  		}
    62  	}
    63  }
    64  
    65  func TestResourceAddScalar(t *testing.T) {
    66  	tests := []struct {
    67  		resource       *Resource
    68  		scalarName     v1.ResourceName
    69  		scalarQuantity float64
    70  		expected       *Resource
    71  	}{
    72  		{
    73  			resource:       &Resource{},
    74  			scalarName:     "scalar1",
    75  			scalarQuantity: 100,
    76  			expected: &Resource{
    77  				ScalarResources: map[v1.ResourceName]float64{"scalar1": 100},
    78  			},
    79  		},
    80  		{
    81  			resource: &Resource{
    82  				MilliCPU:        4000,
    83  				Memory:          8000,
    84  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2},
    85  			},
    86  			scalarName:     "scalar2",
    87  			scalarQuantity: 200,
    88  			expected: &Resource{
    89  				MilliCPU:        4000,
    90  				Memory:          8000,
    91  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2, "scalar2": 200},
    92  			},
    93  		},
    94  	}
    95  
    96  	for _, test := range tests {
    97  		test.resource.AddScalar(test.scalarName, test.scalarQuantity)
    98  		if !reflect.DeepEqual(test.expected, test.resource) {
    99  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource)
   100  		}
   101  	}
   102  }
   103  
   104  func TestSetMaxResource(t *testing.T) {
   105  	tests := []struct {
   106  		resource1 *Resource
   107  		resource2 *Resource
   108  		expected  *Resource
   109  	}{
   110  		{
   111  			resource1: &Resource{},
   112  			resource2: &Resource{
   113  				MilliCPU:        4000,
   114  				Memory:          2000,
   115  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   116  			},
   117  			expected: &Resource{
   118  				MilliCPU:        4000,
   119  				Memory:          2000,
   120  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   121  			},
   122  		},
   123  		{
   124  			resource1: &Resource{
   125  				MilliCPU:        4000,
   126  				Memory:          4000,
   127  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   128  			},
   129  			resource2: &Resource{
   130  				MilliCPU:        4000,
   131  				Memory:          2000,
   132  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4, "hugepages-test": 5},
   133  			},
   134  			expected: &Resource{
   135  				MilliCPU:        4000,
   136  				Memory:          4000,
   137  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4, "hugepages-test": 5},
   138  			},
   139  		},
   140  	}
   141  
   142  	for _, test := range tests {
   143  		test.resource1.SetMaxResource(test.resource2)
   144  		if !reflect.DeepEqual(test.expected, test.resource1) {
   145  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
   146  		}
   147  	}
   148  }
   149  
   150  func TestIsZero(t *testing.T) {
   151  	tests := []struct {
   152  		resource     *Resource
   153  		resourceName v1.ResourceName
   154  		expected     bool
   155  	}{
   156  		{
   157  			resource:     &Resource{},
   158  			resourceName: "cpu",
   159  			expected:     true,
   160  		},
   161  		{
   162  			resource: &Resource{
   163  				MilliCPU:        4000,
   164  				Memory:          4000,
   165  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4, "hugepages-test": 5},
   166  			},
   167  			resourceName: "cpu",
   168  			expected:     false,
   169  		},
   170  		{
   171  			resource: &Resource{
   172  				MilliCPU:        4000,
   173  				Memory:          4000,
   174  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 5},
   175  			},
   176  			resourceName: "scalar.test/scalar1",
   177  			expected:     true,
   178  		},
   179  	}
   180  
   181  	for _, test := range tests {
   182  		flag := test.resource.IsZero(test.resourceName)
   183  		if !reflect.DeepEqual(test.expected, flag) {
   184  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
   185  		}
   186  	}
   187  }
   188  
   189  func TestAddResource(t *testing.T) {
   190  	tests := []struct {
   191  		resource1 *Resource
   192  		resource2 *Resource
   193  		expected  *Resource
   194  	}{
   195  		{
   196  			resource1: &Resource{},
   197  			resource2: &Resource{
   198  				MilliCPU:        4000,
   199  				Memory:          2000,
   200  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   201  			},
   202  			expected: &Resource{
   203  				MilliCPU:        4000,
   204  				Memory:          2000,
   205  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   206  			},
   207  		},
   208  		{
   209  			resource1: &Resource{
   210  				MilliCPU:        4000,
   211  				Memory:          4000,
   212  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   213  			},
   214  			resource2: &Resource{
   215  				MilliCPU:        4000,
   216  				Memory:          2000,
   217  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4, "hugepages-test": 5},
   218  			},
   219  			expected: &Resource{
   220  				MilliCPU:        8000,
   221  				Memory:          6000,
   222  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 5, "hugepages-test": 7},
   223  			},
   224  		},
   225  		{
   226  			resource1: &Resource{
   227  				MilliCPU:        4000,
   228  				Memory:          4000,
   229  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1},
   230  			},
   231  			resource2: &Resource{
   232  				MilliCPU:        4000,
   233  				Memory:          2000,
   234  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4, "hugepages-test": 5},
   235  			},
   236  			expected: &Resource{
   237  				MilliCPU:        8000,
   238  				Memory:          6000,
   239  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 5, "hugepages-test": 5},
   240  			},
   241  		},
   242  	}
   243  
   244  	for _, test := range tests {
   245  		test.resource1.Add(test.resource2)
   246  		if !reflect.DeepEqual(test.expected, test.resource1) {
   247  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
   248  		}
   249  	}
   250  }
   251  
   252  func TestSubResource(t *testing.T) {
   253  	tests := []struct {
   254  		resource1 *Resource
   255  		resource2 *Resource
   256  		expected  *Resource
   257  	}{
   258  		{
   259  			resource1: &Resource{
   260  				MilliCPU:        4000,
   261  				Memory:          2000,
   262  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   263  			},
   264  			resource2: &Resource{},
   265  			expected: &Resource{
   266  				MilliCPU:        4000,
   267  				Memory:          2000,
   268  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
   269  			},
   270  		},
   271  		{
   272  			resource1: &Resource{
   273  				MilliCPU:        4000,
   274  				Memory:          4000,
   275  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   276  			},
   277  			resource2: &Resource{
   278  				MilliCPU:        3000,
   279  				Memory:          2000,
   280  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 500, "hugepages-test": 1000},
   281  			},
   282  			expected: &Resource{
   283  				MilliCPU:        1000,
   284  				Memory:          2000,
   285  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 500, "hugepages-test": 1000},
   286  			},
   287  		},
   288  	}
   289  
   290  	for _, test := range tests {
   291  		test.resource1.Sub(test.resource2)
   292  		if !reflect.DeepEqual(test.expected, test.resource1) {
   293  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
   294  		}
   295  	}
   296  }
   297  
   298  func TestDiff(t *testing.T) {
   299  	testsForDefaultZero := []struct {
   300  		resource1         *Resource
   301  		resource2         *Resource
   302  		expectedIncreased *Resource
   303  		expectedDecreased *Resource
   304  	}{
   305  		{
   306  			resource1: &Resource{},
   307  			resource2: &Resource{},
   308  			expectedIncreased: &Resource{
   309  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   310  			},
   311  			expectedDecreased: &Resource{
   312  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   313  			},
   314  		},
   315  		{
   316  			resource1: &Resource{
   317  				MilliCPU: 1000,
   318  				Memory:   2000,
   319  			},
   320  			resource2: &Resource{},
   321  			expectedIncreased: &Resource{
   322  				MilliCPU:        1000,
   323  				Memory:          2000,
   324  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   325  			},
   326  			expectedDecreased: &Resource{
   327  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   328  			},
   329  		},
   330  		{
   331  			resource1: &Resource{},
   332  			resource2: &Resource{
   333  				MilliCPU: 1000,
   334  				Memory:   2000,
   335  			},
   336  			expectedIncreased: &Resource{
   337  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   338  			},
   339  			expectedDecreased: &Resource{
   340  				MilliCPU:        1000,
   341  				Memory:          2000,
   342  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   343  			},
   344  		},
   345  		{
   346  			resource1: &Resource{
   347  				MilliCPU:        1000,
   348  				Memory:          2000,
   349  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   350  			},
   351  			resource2: &Resource{
   352  				MilliCPU: 2000,
   353  				Memory:   1000,
   354  			},
   355  			expectedIncreased: &Resource{
   356  				Memory:          1000,
   357  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   358  			},
   359  			expectedDecreased: &Resource{
   360  				MilliCPU:        1000,
   361  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   362  			},
   363  		},
   364  		{
   365  			resource1: &Resource{
   366  				MilliCPU: 2000,
   367  				Memory:   1000,
   368  			},
   369  			resource2: &Resource{
   370  				MilliCPU:        1000,
   371  				Memory:          2000,
   372  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   373  			},
   374  			expectedIncreased: &Resource{
   375  				MilliCPU:        1000,
   376  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   377  			},
   378  			expectedDecreased: &Resource{
   379  				Memory:          1000,
   380  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   381  			},
   382  		},
   383  		{
   384  			resource1: &Resource{
   385  				MilliCPU:        1000,
   386  				Memory:          2000,
   387  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 3000},
   388  			},
   389  			resource2: &Resource{
   390  				MilliCPU:        2000,
   391  				Memory:          1000,
   392  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   393  			},
   394  			expectedIncreased: &Resource{
   395  				Memory:          1000,
   396  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 2000},
   397  			},
   398  			expectedDecreased: &Resource{
   399  				MilliCPU:        1000,
   400  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   401  			},
   402  		},
   403  	}
   404  
   405  	testsForDefaultInfinity := []struct {
   406  		resource1         *Resource
   407  		resource2         *Resource
   408  		expectedIncreased *Resource
   409  		expectedDecreased *Resource
   410  	}{
   411  		{
   412  			resource1: &Resource{
   413  				MilliCPU:        1000,
   414  				Memory:          2000,
   415  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   416  			},
   417  			resource2: &Resource{
   418  				MilliCPU: 2000,
   419  				Memory:   1000,
   420  			},
   421  			expectedIncreased: &Resource{
   422  				Memory:          1000,
   423  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   424  			},
   425  			expectedDecreased: &Resource{
   426  				MilliCPU:        1000,
   427  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": -1},
   428  			},
   429  		},
   430  		{
   431  			resource1: &Resource{
   432  				MilliCPU: 2000,
   433  				Memory:   1000,
   434  			},
   435  			resource2: &Resource{
   436  				MilliCPU:        1000,
   437  				Memory:          2000,
   438  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000},
   439  			},
   440  			expectedIncreased: &Resource{
   441  				MilliCPU:        1000,
   442  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": -1},
   443  			},
   444  			expectedDecreased: &Resource{
   445  				Memory:          1000,
   446  				ScalarResources: make(map[v1.ResourceName]float64, 0),
   447  			},
   448  		},
   449  	}
   450  
   451  	for _, test := range testsForDefaultZero {
   452  		increased, decreased := test.resource1.Diff(test.resource2, Zero)
   453  		if !reflect.DeepEqual(test.expectedIncreased, increased) {
   454  			t.Errorf("expected: %#v, got: %#v", test.expectedIncreased, increased)
   455  		}
   456  		if !reflect.DeepEqual(test.expectedDecreased, decreased) {
   457  			t.Errorf("expected: %#v, got: %#v", test.expectedDecreased, decreased)
   458  		}
   459  	}
   460  	for _, test := range testsForDefaultInfinity {
   461  		increased, decreased := test.resource1.Diff(test.resource2, Infinity)
   462  		if !reflect.DeepEqual(test.expectedIncreased, increased) {
   463  			t.Errorf("expected: %#v, got: %#v", test.expectedIncreased, increased)
   464  		}
   465  		if !reflect.DeepEqual(test.expectedDecreased, decreased) {
   466  			t.Errorf("expected: %#v, got: %#v", test.expectedDecreased, decreased)
   467  		}
   468  	}
   469  }
   470  
   471  func TestLess(t *testing.T) {
   472  	testsForDefaultZero := []struct {
   473  		resource1 *Resource
   474  		resource2 *Resource
   475  		expected  bool
   476  	}{
   477  		{
   478  			resource1: &Resource{},
   479  			resource2: &Resource{},
   480  			expected:  false,
   481  		},
   482  		{
   483  			resource1: &Resource{},
   484  			resource2: &Resource{
   485  				MilliCPU:        4000,
   486  				Memory:          2000,
   487  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   488  			},
   489  			expected: true,
   490  		},
   491  		{
   492  			resource1: &Resource{
   493  				MilliCPU:        4000,
   494  				Memory:          4000,
   495  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   496  			},
   497  			resource2: &Resource{
   498  				MilliCPU:        8000,
   499  				Memory:          8000,
   500  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   501  			},
   502  			expected: true,
   503  		},
   504  		{
   505  			resource1: &Resource{
   506  				MilliCPU:        4000,
   507  				Memory:          4000,
   508  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 5000, "hugepages-test": 2000},
   509  			},
   510  			resource2: &Resource{
   511  				MilliCPU:        8000,
   512  				Memory:          8000,
   513  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   514  			},
   515  			expected: false,
   516  		},
   517  		{
   518  			resource1: &Resource{
   519  				MilliCPU:        9000,
   520  				Memory:          4000,
   521  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   522  			},
   523  			resource2: &Resource{
   524  				MilliCPU:        8000,
   525  				Memory:          8000,
   526  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   527  			},
   528  			expected: false,
   529  		},
   530  	}
   531  
   532  	testsForDefaultInfinity := []struct {
   533  		resource1 *Resource
   534  		resource2 *Resource
   535  		expected  bool
   536  	}{
   537  		{
   538  			resource1: &Resource{
   539  				MilliCPU:        1000,
   540  				Memory:          1000,
   541  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   542  			},
   543  			resource2: &Resource{
   544  				MilliCPU:        2000,
   545  				Memory:          2000,
   546  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 3000},
   547  			},
   548  			expected: true,
   549  		},
   550  		{
   551  			resource1: &Resource{
   552  				MilliCPU:        1000,
   553  				Memory:          1000,
   554  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 1000},
   555  			},
   556  			resource2: &Resource{
   557  				MilliCPU:        2000,
   558  				Memory:          2000,
   559  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   560  			},
   561  			expected: false,
   562  		},
   563  		{
   564  			resource1: &Resource{
   565  				MilliCPU:        1000,
   566  				Memory:          1000,
   567  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   568  			},
   569  			resource2: &Resource{
   570  				MilliCPU:        2000,
   571  				Memory:          2000,
   572  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   573  			},
   574  			expected: false,
   575  		},
   576  	}
   577  
   578  	for caseID, test := range testsForDefaultZero {
   579  		flag := test.resource1.Less(test.resource2, Zero)
   580  		if !reflect.DeepEqual(test.expected, flag) {
   581  			t.Errorf("caseID %d expected: %#v, got: %#v", caseID, test.expected, flag)
   582  		}
   583  	}
   584  	for caseID, test := range testsForDefaultInfinity {
   585  		flag := test.resource1.Less(test.resource2, Infinity)
   586  		if !reflect.DeepEqual(test.expected, flag) {
   587  			t.Errorf("caseID %d expected: %#v, got: %#v", caseID, test.expected, flag)
   588  		}
   589  	}
   590  }
   591  
   592  func TestLessEqual(t *testing.T) {
   593  	testsForDefaultZero := []struct {
   594  		resource1 *Resource
   595  		resource2 *Resource
   596  		expected  bool
   597  	}{
   598  		{
   599  			resource1: &Resource{},
   600  			resource2: &Resource{},
   601  			expected:  true,
   602  		},
   603  		{
   604  			resource1: &Resource{},
   605  			resource2: &Resource{
   606  				MilliCPU:        4000,
   607  				Memory:          2000,
   608  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   609  			},
   610  			expected: true,
   611  		},
   612  		{
   613  			resource1: &Resource{
   614  				MilliCPU:        4000,
   615  				Memory:          2000,
   616  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   617  			},
   618  			resource2: &Resource{},
   619  			expected:  false,
   620  		},
   621  		{
   622  			resource1: &Resource{
   623  				MilliCPU:        4000,
   624  				Memory:          4000,
   625  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   626  			},
   627  			resource2: &Resource{
   628  				MilliCPU:        8000,
   629  				Memory:          8000,
   630  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   631  			},
   632  			expected: true,
   633  		},
   634  		{
   635  			resource1: &Resource{
   636  				MilliCPU:        4000,
   637  				Memory:          8000,
   638  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   639  			},
   640  			resource2: &Resource{
   641  				MilliCPU:        8000,
   642  				Memory:          8000,
   643  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   644  			},
   645  			expected: true,
   646  		},
   647  		{
   648  			resource1: &Resource{
   649  				MilliCPU:        4000,
   650  				Memory:          4000,
   651  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 2000},
   652  			},
   653  			resource2: &Resource{
   654  				MilliCPU:        8000,
   655  				Memory:          8000,
   656  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   657  			},
   658  			expected: true,
   659  		},
   660  		{
   661  			resource1: &Resource{
   662  				MilliCPU:        4000,
   663  				Memory:          4000,
   664  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 5000, "hugepages-test": 2000},
   665  			},
   666  			resource2: &Resource{
   667  				MilliCPU:        8000,
   668  				Memory:          8000,
   669  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   670  			},
   671  			expected: false,
   672  		},
   673  		{
   674  			resource1: &Resource{
   675  				MilliCPU:        9000,
   676  				Memory:          4000,
   677  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   678  			},
   679  			resource2: &Resource{
   680  				MilliCPU:        8000,
   681  				Memory:          8000,
   682  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
   683  			},
   684  			expected: false,
   685  		},
   686  	}
   687  
   688  	testsForDefaultInfinity := []struct {
   689  		resource1 *Resource
   690  		resource2 *Resource
   691  		expected  bool
   692  	}{
   693  		{
   694  			resource1: &Resource{},
   695  			resource2: &Resource{},
   696  			expected:  true,
   697  		},
   698  		{
   699  			resource1: &Resource{},
   700  			resource2: &Resource{
   701  				MilliCPU:        4000,
   702  				Memory:          2000,
   703  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   704  			},
   705  			expected: false,
   706  		},
   707  		{
   708  			resource1: &Resource{
   709  				MilliCPU:        4000,
   710  				Memory:          2000,
   711  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   712  			},
   713  			resource2: &Resource{},
   714  			expected:  false,
   715  		},
   716  		{
   717  			resource1: &Resource{
   718  				MilliCPU: 4000,
   719  				Memory:   2000,
   720  			},
   721  			resource2: &Resource{
   722  				MilliCPU:        4000,
   723  				Memory:          2000,
   724  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   725  			},
   726  			expected: false,
   727  		},
   728  		{
   729  			resource1: &Resource{
   730  				MilliCPU:        4000,
   731  				Memory:          2000,
   732  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   733  			},
   734  			resource2: &Resource{
   735  				MilliCPU: 4000,
   736  				Memory:   2000,
   737  			},
   738  			expected: true,
   739  		},
   740  	}
   741  
   742  	for _, test := range testsForDefaultZero {
   743  		flag := test.resource1.LessEqual(test.resource2, Zero)
   744  		if !reflect.DeepEqual(test.expected, flag) {
   745  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
   746  		}
   747  	}
   748  	for caseID, test := range testsForDefaultInfinity {
   749  		flag := test.resource1.LessEqual(test.resource2, Infinity)
   750  		if !reflect.DeepEqual(test.expected, flag) {
   751  			t.Errorf("caseID %d expected: %#v, got: %#v", caseID, test.expected, flag)
   752  		}
   753  	}
   754  }
   755  
   756  func TestLessPartly(t *testing.T) {
   757  	testsForDefaultZero := []struct {
   758  		resource1 *Resource
   759  		resource2 *Resource
   760  		expected  bool
   761  	}{
   762  		{
   763  			resource1: &Resource{},
   764  			resource2: &Resource{},
   765  			expected:  false,
   766  		},
   767  		{
   768  			resource1: &Resource{},
   769  			resource2: &Resource{
   770  				MilliCPU:        2000,
   771  				Memory:          2000,
   772  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   773  			},
   774  			expected: true,
   775  		},
   776  		{
   777  			resource1: &Resource{
   778  				MilliCPU:        2000,
   779  				Memory:          2000,
   780  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   781  			},
   782  			resource2: &Resource{},
   783  			expected:  false,
   784  		},
   785  		{
   786  			resource1: &Resource{
   787  				MilliCPU:        2000,
   788  				Memory:          2000,
   789  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   790  			},
   791  			resource2: &Resource{
   792  				MilliCPU:        4000,
   793  				Memory:          2000,
   794  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   795  			},
   796  			expected: true,
   797  		},
   798  		{
   799  			resource1: &Resource{
   800  				MilliCPU:        2000,
   801  				Memory:          2000,
   802  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   803  			},
   804  			resource2: &Resource{
   805  				MilliCPU:        2000,
   806  				Memory:          4000,
   807  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   808  			},
   809  			expected: true,
   810  		},
   811  		{
   812  			resource1: &Resource{
   813  				MilliCPU:        2000,
   814  				Memory:          2000,
   815  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   816  			},
   817  			resource2: &Resource{
   818  				MilliCPU:        2000,
   819  				Memory:          2000,
   820  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 2000, "hugepages-test": 2000},
   821  			},
   822  			expected: true,
   823  		},
   824  		{
   825  			resource1: &Resource{
   826  				MilliCPU:        2000,
   827  				Memory:          2000,
   828  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   829  			},
   830  			resource2: &Resource{
   831  				MilliCPU:        2000,
   832  				Memory:          2000,
   833  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   834  			},
   835  			expected: true,
   836  		},
   837  		{
   838  			resource1: &Resource{
   839  				MilliCPU:        4000,
   840  				Memory:          4000,
   841  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   842  			},
   843  			resource2: &Resource{
   844  				MilliCPU:        2000,
   845  				Memory:          2000,
   846  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   847  			},
   848  			expected: false,
   849  		},
   850  		{
   851  			resource1: &Resource{
   852  				MilliCPU:        2000,
   853  				Memory:          2000,
   854  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   855  			},
   856  			resource2: &Resource{
   857  				MilliCPU:        2000,
   858  				Memory:          2000,
   859  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   860  			},
   861  			expected: false,
   862  		},
   863  	}
   864  
   865  	testsForDefaultInfinity := []struct {
   866  		resource1 *Resource
   867  		resource2 *Resource
   868  		expected  bool
   869  	}{
   870  		{
   871  			resource1: &Resource{
   872  				MilliCPU:        2000,
   873  				Memory:          2000,
   874  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   875  			},
   876  			resource2: &Resource{
   877  				MilliCPU:        2000,
   878  				Memory:          2000,
   879  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   880  			},
   881  			expected: false,
   882  		},
   883  		{
   884  			resource1: &Resource{
   885  				MilliCPU:        2000,
   886  				Memory:          2000,
   887  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   888  			},
   889  			resource2: &Resource{
   890  				MilliCPU:        2000,
   891  				Memory:          2000,
   892  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   893  			},
   894  			expected: true,
   895  		},
   896  	}
   897  
   898  	for caseID, test := range testsForDefaultZero {
   899  		flag := test.resource1.LessPartly(test.resource2, Zero)
   900  		if !reflect.DeepEqual(test.expected, flag) {
   901  			t.Errorf("caseID %d expected: %#v, got: %#v", caseID, test.expected, flag)
   902  		}
   903  	}
   904  	for _, test := range testsForDefaultInfinity {
   905  		flag := test.resource1.LessPartly(test.resource2, Infinity)
   906  		if !reflect.DeepEqual(test.expected, flag) {
   907  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
   908  		}
   909  	}
   910  }
   911  
   912  func TestLessEqualPartly(t *testing.T) {
   913  	testsForDefaultZero := []struct {
   914  		resource1 *Resource
   915  		resource2 *Resource
   916  		expected  bool
   917  	}{
   918  		{
   919  			resource1: &Resource{},
   920  			resource2: &Resource{},
   921  			expected:  true,
   922  		},
   923  		{
   924  			resource1: &Resource{},
   925  			resource2: &Resource{
   926  				MilliCPU:        2000,
   927  				Memory:          2000,
   928  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   929  			},
   930  			expected: true,
   931  		},
   932  		{
   933  			resource1: &Resource{
   934  				MilliCPU:        2000,
   935  				Memory:          2000,
   936  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   937  			},
   938  			resource2: &Resource{},
   939  			expected:  false,
   940  		},
   941  		{
   942  			resource1: &Resource{
   943  				MilliCPU:        2000,
   944  				Memory:          2000,
   945  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   946  			},
   947  			resource2: &Resource{
   948  				MilliCPU:        4000,
   949  				Memory:          2000,
   950  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   951  			},
   952  			expected: true,
   953  		},
   954  		{
   955  			resource1: &Resource{
   956  				MilliCPU:        2000,
   957  				Memory:          2000,
   958  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   959  			},
   960  			resource2: &Resource{
   961  				MilliCPU:        2000,
   962  				Memory:          4000,
   963  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   964  			},
   965  			expected: true,
   966  		},
   967  		{
   968  			resource1: &Resource{
   969  				MilliCPU:        2000,
   970  				Memory:          2000,
   971  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   972  			},
   973  			resource2: &Resource{
   974  				MilliCPU:        2000,
   975  				Memory:          2000,
   976  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 2000, "hugepages-test": 2000},
   977  			},
   978  			expected: true,
   979  		},
   980  		{
   981  			resource1: &Resource{
   982  				MilliCPU:        2000,
   983  				Memory:          2000,
   984  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
   985  			},
   986  			resource2: &Resource{
   987  				MilliCPU:        2000,
   988  				Memory:          2000,
   989  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   990  			},
   991  			expected: true,
   992  		},
   993  		{
   994  			resource1: &Resource{
   995  				MilliCPU:        4000,
   996  				Memory:          4000,
   997  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
   998  			},
   999  			resource2: &Resource{
  1000  				MilliCPU:        2000,
  1001  				Memory:          2000,
  1002  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1003  			},
  1004  			expected: true,
  1005  		},
  1006  		{
  1007  			resource1: &Resource{
  1008  				MilliCPU:        2000,
  1009  				Memory:          2000,
  1010  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1011  			},
  1012  			resource2: &Resource{
  1013  				MilliCPU:        2000,
  1014  				Memory:          2000,
  1015  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
  1016  			},
  1017  			expected: true,
  1018  		},
  1019  	}
  1020  
  1021  	testsForDefaultInfinity := []struct {
  1022  		resource1 *Resource
  1023  		resource2 *Resource
  1024  		expected  bool
  1025  	}{
  1026  		{
  1027  			resource1: &Resource{
  1028  				MilliCPU:        2000,
  1029  				Memory:          2000,
  1030  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
  1031  			},
  1032  			resource2: &Resource{
  1033  				MilliCPU:        2000,
  1034  				Memory:          2000,
  1035  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1036  			},
  1037  			expected: true,
  1038  		},
  1039  		{
  1040  			resource1: &Resource{
  1041  				MilliCPU:        2000,
  1042  				Memory:          2000,
  1043  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1044  			},
  1045  			resource2: &Resource{
  1046  				MilliCPU:        2000,
  1047  				Memory:          2000,
  1048  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
  1049  			},
  1050  			expected: true,
  1051  		},
  1052  	}
  1053  
  1054  	for _, test := range testsForDefaultZero {
  1055  		flag := test.resource1.LessEqualPartly(test.resource2, Zero)
  1056  		if !reflect.DeepEqual(test.expected, flag) {
  1057  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
  1058  		}
  1059  	}
  1060  	for _, test := range testsForDefaultInfinity {
  1061  		flag := test.resource1.LessEqualPartly(test.resource2, Infinity)
  1062  		if !reflect.DeepEqual(test.expected, flag) {
  1063  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
  1064  		}
  1065  	}
  1066  }
  1067  
  1068  func TestEqual(t *testing.T) {
  1069  	tests := []struct {
  1070  		resource1 *Resource
  1071  		resource2 *Resource
  1072  		expected  bool
  1073  	}{
  1074  		{
  1075  			resource1: &Resource{},
  1076  			resource2: &Resource{},
  1077  			expected:  true,
  1078  		},
  1079  		{
  1080  			resource1: &Resource{
  1081  				MilliCPU:        2000,
  1082  				Memory:          2000,
  1083  				ScalarResources: map[v1.ResourceName]float64{},
  1084  			},
  1085  			resource2: &Resource{
  1086  				MilliCPU:        2000,
  1087  				Memory:          2000,
  1088  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0},
  1089  			},
  1090  			expected: true,
  1091  		},
  1092  		{
  1093  			resource1: &Resource{
  1094  				MilliCPU:        2000,
  1095  				Memory:          2000,
  1096  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
  1097  			},
  1098  			resource2: &Resource{
  1099  				MilliCPU:        2000,
  1100  				Memory:          2000,
  1101  				ScalarResources: map[v1.ResourceName]float64{"hugepages-test": 2000},
  1102  			},
  1103  			expected: true,
  1104  		},
  1105  		{
  1106  			resource1: &Resource{},
  1107  			resource2: &Resource{
  1108  				MilliCPU:        2000,
  1109  				Memory:          4000,
  1110  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1111  			},
  1112  			expected: false,
  1113  		},
  1114  	}
  1115  
  1116  	for _, test := range tests {
  1117  		flag := test.resource1.Equal(test.resource2, Zero)
  1118  		if !reflect.DeepEqual(test.expected, flag) {
  1119  			t.Errorf("expected: %#v, got: %#v", test.expected, flag)
  1120  		}
  1121  	}
  1122  }
  1123  
  1124  func TestMinDimensionResourceZero(t *testing.T) {
  1125  	tests := []struct {
  1126  		resource1 *Resource
  1127  		resource2 *Resource
  1128  		expected  *Resource
  1129  	}{
  1130  		{
  1131  			resource1: &Resource{
  1132  				MilliCPU:        4000,
  1133  				Memory:          2000,
  1134  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
  1135  			},
  1136  			resource2: &Resource{
  1137  				MilliCPU:        3000,
  1138  				Memory:          2000,
  1139  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
  1140  			},
  1141  			expected: &Resource{
  1142  				MilliCPU:        3000,
  1143  				Memory:          2000,
  1144  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
  1145  			},
  1146  		},
  1147  		{
  1148  			resource1: &Resource{
  1149  				MilliCPU:        4000,
  1150  				Memory:          4000,
  1151  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1152  			},
  1153  			resource2: &Resource{
  1154  				MilliCPU:        5000,
  1155  				Memory:          2000,
  1156  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 3000},
  1157  			},
  1158  			expected: &Resource{
  1159  				MilliCPU:        4000,
  1160  				Memory:          2000,
  1161  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 2000},
  1162  			},
  1163  		},
  1164  		{
  1165  			resource1: &Resource{
  1166  				MilliCPU:        4000,
  1167  				Memory:          2000,
  1168  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
  1169  			},
  1170  			resource2: &Resource{
  1171  				MilliCPU:        3000,
  1172  				Memory:          2000,
  1173  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0},
  1174  			},
  1175  			expected: &Resource{
  1176  				MilliCPU:        3000,
  1177  				Memory:          2000,
  1178  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
  1179  			},
  1180  		},
  1181  		{
  1182  			resource1: &Resource{
  1183  				MilliCPU:        4000,
  1184  				Memory:          4000,
  1185  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1186  			},
  1187  			resource2: &Resource{
  1188  				MilliCPU: math.MaxFloat64,
  1189  				Memory:   2000,
  1190  			},
  1191  			expected: &Resource{
  1192  				MilliCPU:        4000,
  1193  				Memory:          2000,
  1194  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
  1195  			},
  1196  		},
  1197  	}
  1198  
  1199  	for _, test := range tests {
  1200  		test.resource1.MinDimensionResource(test.resource2, Zero)
  1201  		if !reflect.DeepEqual(test.expected, test.resource1) {
  1202  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
  1203  		}
  1204  	}
  1205  }
  1206  
  1207  func TestMinDimensionResourceInfinity(t *testing.T) {
  1208  	tests := []struct {
  1209  		resource1 *Resource
  1210  		resource2 *Resource
  1211  		expected  *Resource
  1212  	}{
  1213  		{
  1214  			resource1: &Resource{
  1215  				MilliCPU:        4000,
  1216  				Memory:          2000,
  1217  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
  1218  			},
  1219  			resource2: &Resource{
  1220  				MilliCPU:        3000,
  1221  				Memory:          2000,
  1222  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0},
  1223  			},
  1224  			expected: &Resource{
  1225  				MilliCPU:        3000,
  1226  				Memory:          2000,
  1227  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 2},
  1228  			},
  1229  		},
  1230  		{
  1231  			resource1: &Resource{
  1232  				MilliCPU:        4000,
  1233  				Memory:          4000,
  1234  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1235  			},
  1236  			resource2: &Resource{
  1237  				MilliCPU: math.MaxFloat64,
  1238  				Memory:   2000,
  1239  			},
  1240  			expected: &Resource{
  1241  				MilliCPU:        4000,
  1242  				Memory:          2000,
  1243  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1244  			},
  1245  		},
  1246  	}
  1247  
  1248  	for _, test := range tests {
  1249  		test.resource1.MinDimensionResource(test.resource2, Infinity)
  1250  		if !reflect.DeepEqual(test.expected, test.resource1) {
  1251  			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
  1252  		}
  1253  	}
  1254  }
  1255  
  1256  func TestResource_LessEqualResource(t *testing.T) {
  1257  	testsForDefaultZero := []struct {
  1258  		resource1 *Resource
  1259  		resource2 *Resource
  1260  		expected  []string
  1261  	}{
  1262  		{
  1263  			resource1: &Resource{},
  1264  			resource2: &Resource{},
  1265  			expected:  []string{},
  1266  		},
  1267  		{
  1268  			resource1: &Resource{},
  1269  			resource2: &Resource{
  1270  				MilliCPU:        4000,
  1271  				Memory:          2000,
  1272  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1273  			},
  1274  			expected: []string{},
  1275  		},
  1276  		{
  1277  			resource1: &Resource{
  1278  				MilliCPU:        4000,
  1279  				Memory:          2000,
  1280  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1281  			},
  1282  			resource2: &Resource{},
  1283  			expected:  []string{"cpu", "memory", "scalar.test/scalar1", "hugepages-test"},
  1284  		},
  1285  		{
  1286  			resource1: &Resource{
  1287  				MilliCPU:        4000,
  1288  				Memory:          4000,
  1289  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1290  			},
  1291  			resource2: &Resource{
  1292  				MilliCPU:        8000,
  1293  				Memory:          8000,
  1294  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
  1295  			},
  1296  			expected: []string{},
  1297  		},
  1298  		{
  1299  			resource1: &Resource{
  1300  				MilliCPU:        4000,
  1301  				Memory:          8000,
  1302  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1303  			},
  1304  			resource2: &Resource{
  1305  				MilliCPU:        8000,
  1306  				Memory:          8000,
  1307  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
  1308  			},
  1309  			expected: []string{},
  1310  		},
  1311  		{
  1312  			resource1: &Resource{
  1313  				MilliCPU:        4000,
  1314  				Memory:          4000,
  1315  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 2000},
  1316  			},
  1317  			resource2: &Resource{
  1318  				MilliCPU:        8000,
  1319  				Memory:          8000,
  1320  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
  1321  			},
  1322  			expected: []string{},
  1323  		},
  1324  		{
  1325  			resource1: &Resource{
  1326  				MilliCPU:        4000,
  1327  				Memory:          4000,
  1328  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 5000, "hugepages-test": 2000},
  1329  			},
  1330  			resource2: &Resource{
  1331  				MilliCPU:        8000,
  1332  				Memory:          8000,
  1333  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
  1334  			},
  1335  			expected: []string{"scalar.test/scalar1"},
  1336  		},
  1337  		{
  1338  			resource1: &Resource{
  1339  				MilliCPU:        9000,
  1340  				Memory:          4000,
  1341  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1342  			},
  1343  			resource2: &Resource{
  1344  				MilliCPU:        8000,
  1345  				Memory:          8000,
  1346  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 4000, "hugepages-test": 5000},
  1347  			},
  1348  			expected: []string{"cpu"},
  1349  		},
  1350  	}
  1351  
  1352  	testsForDefaultInfinity := []struct {
  1353  		resource1 *Resource
  1354  		resource2 *Resource
  1355  		expected  []string
  1356  	}{
  1357  		{
  1358  			resource1: &Resource{},
  1359  			resource2: &Resource{},
  1360  			expected:  []string{},
  1361  		},
  1362  		{
  1363  			resource1: &Resource{},
  1364  			resource2: &Resource{
  1365  				MilliCPU:        4000,
  1366  				Memory:          2000,
  1367  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1368  			},
  1369  			expected: []string{},
  1370  		},
  1371  		{
  1372  			resource1: &Resource{
  1373  				MilliCPU:        4000,
  1374  				Memory:          2000,
  1375  				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
  1376  			},
  1377  			resource2: &Resource{},
  1378  			expected:  []string{"cpu", "memory"},
  1379  		},
  1380  	}
  1381  
  1382  	for _, test := range testsForDefaultZero {
  1383  		_, reason := test.resource1.LessEqualWithResourcesName(test.resource2, Zero)
  1384  		sort.Strings(test.expected)
  1385  		sort.Strings(reason)
  1386  		if !reflect.DeepEqual(test.expected, reason) {
  1387  			t.Errorf("expected: %#v, got: %#v", test.expected, reason)
  1388  		}
  1389  	}
  1390  	for caseID, test := range testsForDefaultInfinity {
  1391  		_, reason := test.resource1.LessEqualWithResourcesName(test.resource2, Infinity)
  1392  		sort.Strings(test.expected)
  1393  		sort.Strings(reason)
  1394  		if !reflect.DeepEqual(test.expected, reason) {
  1395  			t.Errorf("caseID %d expected: %#v, got: %#v", caseID, test.expected, reason)
  1396  		}
  1397  	}
  1398  }