}
	if ncalls != 3 {
		println("wrong number of calls:", ncalls, "!= 3")
		panic("fail")
	}
}

func main() {
	testfunc0()
	testfunc1()
	testfunc2()
	testfunc3()
	testfunc4()
	testfunc5()
	testfunc6()
	testfunc7()
	testfunc8()
	testfunc9()
	testcalls()
	testcalls1()

		expectedPVC *v1.PersistentVolumeClaim
		testFunc    func(*v1.PersistentVolumeClaim, clientset.Interface, resource.Quantity) (*v1.PersistentVolumeClaim, error)
	}{
		{
			name:        "mark fs resize, with no other conditions",
			pvc:         basePVC.get(),
			expectedPVC: basePVC.withStorageResourceStatus(v1.PersistentVolumeClaimNodeResizePending).get(),

TEST(DeviceCompilationProfilerTest, RegisterExecution) {
  DeviceCompilationProfiler* profiler = new DeviceCompilationProfiler();
  core::ScopedUnref profiler_ref(profiler);

  NameAttrList function;
  function.set_name("TestFunc");

  for (int i = 0; i < 5; ++i) {
    profiler->RegisterExecution(function);
  }
  TF_ASSERT_OK_AND_ASSIGN(auto stats, profiler->GetCompileStats(function));
  EXPECT_EQ(stats.execution_count, 5);
}

	if hasVX {
		for _, a := range sumVV {
			arg := a
			testFunVV(t, "addVV_novec", addVV_novec, arg)

			arg = argVV{a.z, a.y, a.x, a.c}
			testFunVV(t, "addVV_novec symmetric", addVV_novec, arg)

			arg = argVV{a.x, a.z, a.y, a.c}
			testFunVV(t, "subVV_novec", subVV_novec, arg)

			arg = argVV{a.y, a.z, a.x, a.c}
			testFunVV(t, "subVV_novec symmetric", subVV_novec, arg)
		}
	}

	a := 0
	b := func() {
		switch {
		}
		a++
	}
	b()
	b()
	return a
}

func testCFunc(t *testing.T) {
	if want, got := 2, testCFunc_ssa(); got != want {
		t.Errorf("expected %d, got %d", want, got)
	}
}

// TestClosure tests closure related behavior.
func TestClosure(t *testing.T) {
	testCFunc(t)

				ftype := fmt.Sprintf("float%d", fWidth)
				seg := strings.Replace(testSegment, "$F", ftype, -1)
				seg = strings.Replace(seg, "$I", itype, -1)
				segs.WriteString(seg)
			}
			body := strings.Replace(testFunc, "$I", itype, -1)
			if typ[0] == 'u' {
				body = strings.Replace(body, "$TEST", " || i < 0", 1)
			} else {
				body = strings.Replace(body, "$TEST", "", 1)
			}

		{Version: " ", Err: true},
		{Version: "1", ExpectVersion: 1},
		{Version: "10", ExpectVersion: 10},
	}

	v := APIObjectVersioner{}
	testFuncs := []func(string) (uint64, error){
		v.ParseResourceVersion,
	}

	for _, testCase := range testCases {
		for i, f := range testFuncs {
			version, err := f(testCase.Version)
			switch {
			case testCase.Err && err == nil:

		fmt.Fprintf(w, "  a,b int%d\n", sz)
		fmt.Fprintf(w, "  add,sub,mul,div,mod int%d\n", sz)
		fmt.Fprintf(w, "}\n")
	}

	// the function being tested
	testFunc, err := template.New("testFunc").Parse(
		`//go:noinline
		func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} {
	return a {{.SymFirst}} b
}
`)
	if err != nil {
		panic(err)
	}

					code0 := gen(b, "testFunc"+s, "", "yield2", i, double, func(c int) bool { return c == j || c == k })
					code1 := gen(b, "testSlice"+s, "_, ", "slice2", i, double, func(c int) bool { return c == j || c == k })
					if code0 != code1 {
						panic("bad generator")
					}
					tests += "test" + s + "()\n"
					p(b, testCode, "test"+s, []int{j, k}, "testFunc"+s, "testSlice"+s)
					flush(false)
				}
			}

    return 1
  fi
}

function test_func() {
  local -r name="${1}"

  echo_blue "=== TEST ${name}"
  setup
  if ! "${name}"; then
    failures=$((failures+1))
    error "=== FAIL"
  else
    echo_green "=== PASS"
  fi
  teardown
}

failures=0
test_func test_create_resource_reconcile
test_func test_create_resource_ensureexists
test_func test_create_multiresource