t.Run(test.name, func(t *testing.T) {
			actualNodes, actualEdges := toDOTNodesAndEdgesForObj(test.uidToNode, test.uids...)
			compareGraphs(test.expectNodes, actualNodes, test.expectEdges, actualEdges, t)
		})
	}
}

func compareGraphs(expectedNodes, actualNodes []*dotVertex, expectedEdges, actualEdges []dotEdge, t *testing.T) {
	if len(expectedNodes) != len(actualNodes) {
		t.Fatal(dump.Pretty(actualNodes))
	}

        return conflictResolver;
    }

    protected void assertResolveConflict(
            ResolutionNode expectedNode, ResolutionNode actualNode1, ResolutionNode actualNode2) {
        ResolutionNode resolvedNode = getConflictResolver().resolveConflict(actualNode1, actualNode2);

        assertNotNull(resolvedNode, "Expected resolvable");
        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

	// Tests that all regular pods are recorded correctly.
	actualPods := podManager.GetPods()
	if len(actualPods) != len(expectedPods) {
		t.Errorf("expected %d pods, got %d pods; expected pods %#v, got pods %#v", len(expectedPods), len(actualPods),
			expectedPods, actualPods)
	}
	for _, expected := range expectedPods {
		found := false
		for _, actual := range actualPods {
			if actual.UID == expected.UID {

	}

	for name, tc := range testcases {
		t.Run(name, func(t *testing.T) {
			var actualModel Model
			for _, resources := range tc.resources {
				AddResources(&actualModel, resources)
			}
			for _, allocation := range tc.allocations {
				AddAllocation(&actualModel, allocation)
			}

			require.Equal(t, tc.expectModel, actualModel)
		})
	}

}

func TestController(t *testing.T) {

     */
    void hasNodeStructure(ReportNode expectedNode) {
        def parsedNodes = parsedModelReport.reportNode
        def actualNode = parsedNodes.findFirstByName(expectedNode.name())
        assert actualNode: "Could not find the first node to begin comparison"
        checkNodes(actualNode, expectedNode)
    }

    /**
     * A fuzzy assertion which recursively asserts that:

	}

	for i, testCase := range testCases {
		config.SetRegion(globalServerConfig, testCase.serverConfigRegion)
		_, actualCode := parseLocationConstraint(testCase.request)
		if testCase.expectedCode != actualCode {
			t.Errorf("Test %d: Expected the APIErrCode to be %d, but instead found %d", i+1, testCase.expectedCode, actualCode)
		}
	}
}

// Tests validate metadata extraction from http headers.

	if err != nil {
		test.t.Errorf(err.Error())
		return
	}

	actualMode := fileInfo.Mode()
	expectedMode := os.FileMode(step.expectedMode)
	if actualMode != expectedMode {
		test.t.Errorf("Found mode `%v` expected %v", actualMode, expectedMode)
	}
}

type reSetUp struct {
	stepName
	linkShouldChange bool
	newLabels        map[string]string
}

				}
				actualMode := st.Mode()
				if actualMode != test.perm {
					if actualMode^test.perm == os.ModeSetgid && test.perm&os.ModeSetgid == 0 {
						// when TMPDIR is a kubernetes emptydir, the sticky gid bit is set due to fsgroup
						t.Logf("masking bit from %o", actualMode)
					} else {
						t.Errorf("expected permissions %o, got %o (%b)", test.perm, actualMode, test.perm^actualMode)
					}
				}

      result=1
  fi
  if [ "${actualcode}" -ne "${expectedcode}" ]; then
      echo "${bold}${red}"
      echo "$(kube::test::get_caller): FAIL!"
      echo "Return code for ${message}"
      echo "  Expected: ${expectedcode}"
      echo "  Got:      ${actualcode}"
      echo "${reset}${red}"
      caller
      echo "${reset}"
      result=1
  fi

        StringBuilder matched = new StringBuilder()
        expectedSorted.each { node ->
            def actualNode = actualSorted.find { it.id == node.id }

            if (!actualNode) {
                errors.append("Expected to find node ${node.id} but wasn't present in result\n")
            } else if (!node.diff(actualNode, errors)) {
                matched.append("   - $node\n")
            }
        }