for _, container := range allContainers {
		// process requests
		for name, quantity := range container.Resources.Requests {
			if !isSupportedQoSComputeResource(name) {
				continue
			}
			if quantity.Cmp(zeroQuantity) == 1 {
				delta := quantity.DeepCopy()
				if _, exists := requests[name]; !exists {
					requests[name] = delta
				} else {
					delta.Add(requests[name])
					requests[name] = delta
				}
			}

git branch -m main

git tag has-nested

at 2023-11-14T13:00:01-05:00

git rm -r nested
git commit -m 'nested: delete subdirectory'

git show-ref --tags --heads
cmp stdout .git-refs

git log --pretty=oneline
cmp stdout .git-log

-- .git-refs --
f213069baa68ec26412fb373c7cf6669db1f8e69 refs/heads/main
08a4fa6bb9c04ffba03b26ae427b0d6335d90a2a refs/tags/has-nested
-- .git-log --

	CALL	libc_mmap(SB)
	MOVD	$0, R1
	CMP	$-1, R0
	BNE	noerr
	CALL	libc_errno(SB)
	MOVW	(R0), R1		// errno
	MOVD	$0, R0
noerr:
	MOVD	R0, 32(R19)
	MOVD	R1, 40(R19)
	RET

TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
	MOVD	8(R0), R1		// arg 2 - len
	MOVD	0(R0), R0		// arg 1 - addr
	CALL	libc_munmap(SB)
	CMP	$-1, R0
	BNE	3(PC)
	MOVD	$0, R0			// crash on failure

	}
	for _, testCase := range table {
		q := MustParse(testCase.quantity)
		// Won't currently get an error as MarshalTo can't return one
		result, _ := q.Marshal()
		q.MarshalTo(result)
		if q.Cmp(testCase.expect) != 0 {
			t.Errorf("Expected: %v, Actual: %v", testCase.expect, q)
		}
	}
	// Test when i is {0,0}
	table2 := []struct {
		dec    *inf.Dec
		expect Quantity
	}{

limitations under the License.
*/

package cmd

import (
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/stretchr/testify/assert"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/utils/ptr"

			cmp := v_0.Args[0]
			b.resetWithControl(Block386GE, cmp)
			return true
		}
		// match: (If (SETEQ cmp) yes no)
		// result: (EQ cmp yes no)
		for b.Controls[0].Op == Op386SETEQ {
			v_0 := b.Controls[0]
			cmp := v_0.Args[0]
			b.resetWithControl(Block386EQ, cmp)
			return true
		}
		// match: (If (SETNE cmp) yes no)
		// result: (NE cmp yes no)

stdout '"Name": "a"'
stdout '"Stale": true'

# Test -json=false produces non-json output.
go list -json=false
cmp stdout want-non-json.txt

# Test -json=<field> keeps only that field.
go list -json=Name
cmp stdout want-json-name.txt

# Test -json=<field> with multiple fields.
go list -json=ImportPath,Name,GoFiles,Imports
cmp stdout want-json-multiple.txt

# Test -json=<field> with Deps outputs the Deps field.
go list -json=Deps

See the License for the specific language governing permissions and
limitations under the License.
*/

package v1

import (
	"testing"

	"github.com/google/go-cmp/cmp"

	apiequality "k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apimachinery/pkg/runtime"
	utilpointer "k8s.io/utils/pointer"
)

func TestDefaults(t *testing.T) {
	scheme := runtime.NewScheme()

	MOVW	0(R0), R0	// arg 1 fd
	BL	libc_write(SB)
	MOVD	$-1, R1
	CMP	R0, R1
	BNE	noerr
	BL	libc_error(SB)
	MOVW	(R0), R0
	NEG	R0, R0		// caller expects negative errno value
noerr:
	RET

TEXT runtime·read_trampoline(SB),NOSPLIT,$0
	MOVD	8(R0), R1	// arg 2 buf
	MOVW	16(R0), R2	// arg 3 count
	MOVW	0(R0), R0	// arg 1 fd
	BL	libc_read(SB)
	MOVD	$-1, R1
	CMP	R0, R1
	BNE	noerr
	BL	libc_error(SB)
	MOVW	(R0), R0

stdout '^example\.net/lazy@v0\.1\.0 example\.com/retract/incompatible@v1\.0\.0$'
! stdout 'example\.com/retract/incompatible@v2\.0\.0\+incompatible'

go mod graph -go=1.17
cmp stdout graph-1.17.txt

cmp go.mod go.mod.orig


# Setting -go=1.16 should report the graph as viewed by Go 1.16,
# but should not edit the go.mod file.

go mod graph -go=1.16
cp stdout graph-1.16.txt