with(resolution("configuring { property = value() }")) {
            val assignment = assignments.single()
            val lhs = replaceInnerReceiverWithTopLevel(assignment.lhs.receiverObject)
            val rhs = replaceInnerReceiverWithTopLevel(assignment.rhs)

            assertEquals(topLevelReceiver, (lhs as ObjectOrigin.ImplicitThisReceiver).resolvedTo)

	if policyName != "none" {
		t.Errorf("NonePolicy Name() error. expected: none, returned: %v", policyName)
	}
}

func TestNonePolicyAllocate(t *testing.T) {
	policy := &nonePolicy{}

	st := &mockState{
		assignments:   state.ContainerCPUAssignments{},
		defaultCPUSet: cpuset.New(1, 2, 3, 4, 5, 6, 7),
	}

	testPod := makePod("fakePod", "fakeContainer", "1000m", "1000m")

	container := &testPod.Spec.Containers[0]

            }
            """.trimIndent(),
            defaultCodeResolver(elementFilter = AnalysisStatementFilterUtils.isCallNamed("n2").not())
        )

        assertEquals(1, result.assignments.size)
        assertEquals("4", result.assignments.single().rhs.originElement.sourceData.text())
    }

				mgr.AddContainer(testCase.podAllocate, &testCase.podAllocate.Spec.Containers[i], appContainer.Name)
			}

			assignments := mgr.state.GetMemoryAssignments()
			if !areContainerMemoryAssignmentsEqual(t, assignments, testCase.expectedAssignments) {
				t.Fatalf("Actual assignments %v are different from the expected %v", assignments, testCase.expectedAssignments)
			}

			machineState := mgr.state.GetMachineState()

package p

func f[T any]() (f, g T) { return f, g }

// Tests for generic function instantiation on the right hande side of multi-value
// assignments.

func g() {
	// Multi-value assignment within a function
	var _, _ = f[int]()
}

// Multi-value assignment outside a function.

                    )
                )
            )""".trimIndent()
        parse(code).assert(expected)
    }

    @Test
    fun `missing assignment in one of a series of assignments`() {
        val code = """
            val a = 1
            val b = 2
            val c 3
            val d = 4
            val e = 5
        """.trimIndent()

        val expected = """

var _ checkpointmanager.Checkpoint = &CPUManagerCheckpointV2{}
var _ checkpointmanager.Checkpoint = &CPUManagerCheckpoint{}

// CPUManagerCheckpoint struct is used to store cpu/pod assignments in a checkpoint in v2 format
type CPUManagerCheckpoint struct {
	PolicyName    string                       `json:"policyName"`
	DefaultCPUSet string                       `json:"defaultCpuSet"`

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Some uses of zeroed constants in non-assignment
// expressions broke with our more aggressive zeroing
// of assignments (internal compiler errors).

package main

func f1() {
	type T [2]int
	p := T{0, 1}
	switch p {
	case T{0, 0}:
		panic("wrong1")
	case T{0, 1}:
		// ok

}


fun printResolutionResults(
    result: ResolutionResult
) {
    println(result.errors.joinToString("\n") { "ERROR: ${it.errorReason} in ${it.element.sourceData.text()}\n" })
    println("Assignments:\n" + result.assignments.joinToString("\n") { (k, v) -> "$k := $v" })
    println()
    println("Additions:\n" + result.additions.joinToString("\n") { (container, obj) -> "$container += $obj" })
}

}


interface AnalysisContextView : TypeRefContext {
    val schema: AnalysisSchema
    val imports: Map<String, FqName>
    val currentScopes: List<AnalysisScopeView>
    val assignments: List<AssignmentRecord>
}


class SchemaTypeRefContext(val schema: AnalysisSchema) : TypeRefContext {
    override fun resolveRef(dataTypeRef: DataTypeRef): DataType = when (dataTypeRef) {