for (RoundingMode mode : ALL_SAFE_ROUNDING_MODES) {
        BigDecimal expected = new BigDecimal(d).setScale(0, mode);
        boolean isInBounds =
            expected.compareTo(MAX_INT_AS_BIG_DECIMAL) <= 0
                & expected.compareTo(MIN_INT_AS_BIG_DECIMAL) >= 0;

        try {
          assertEquals(expected.intValue(), DoubleMath.roundToInt(d, mode));
          assertTrue(isInBounds);

  constexpr StringRef kTarget0 = "tpu0";
  EXPECT_EQ(clusters.count(kTarget0), 1);
  EXPECT_EQ(clusters[kTarget0].size(), 1);
  EXPECT_EQ(clusters[kTarget0][0].ops.size(), 2);

  constexpr StringRef kTarget1 = "tpu1";
  EXPECT_EQ(clusters.count(kTarget1), 1);
  EXPECT_EQ(clusters[kTarget1].size(), 1);
  EXPECT_EQ(clusters[kTarget1][0].ops.size(), 2);
}

	type Case struct {
		path     string
		expected bool
	}

	// Credits https://github.com/kubernetes/kubernetes/pull/124084/files#r1557566941
	cases := []Case{
		{path: "/logs", expected: true},
		{path: "/var/lib/something", expected: true},
		{path: "var/lib/something", expected: true},
		{path: "var\\lib\\something", expected: true},
		{path: "/", expected: true},
		{path: ".", expected: true},

            Type expected = new Key<Set<Integer>>() {}.getType();
            assertEquals(expected, simplifyType(type));
        }

        {
            Type type = new Key<Set<? extends Set<? extends Set<? extends Integer>>>>() {}.getType();
            Type expected = new Key<Set<Set<Set<Integer>>>>() {}.getType();
            assertEquals(expected, simplifyType(type));
        }

        {

			manifestsDir:  "/etc/bar/",
			expected:      "/etc/bar/foo.yaml",
		},
	}
	for _, rt := range tests {
		t.Run(rt.componentName, func(t *testing.T) {
			actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir)
			expected := filepath.FromSlash(rt.expected)
			if actual != expected {
				t.Errorf(
					"failed GetStaticPodFilepath:\n\texpected: %s\n\t  actual: %s",
					rt.expected,
					actual,
				)
			}
		})

	if pod2.Name != pod.Name {
		t.Errorf("expected %q, got %q", pod.Name, pod2.Name)
	}

	if pod2.Namespace != pod.Namespace {
		t.Errorf("expected %q, got %q", pod.Namespace, pod2.Namespace)
	}

	if !reflect.DeepEqual(pod2.Labels, pod.Labels) {
		t.Errorf("expected %v, got %v", pod.Labels, pod2.Labels)
	}

	if pod2.Spec.RestartPolicy != pod.Spec.RestartPolicy {

      result.get(),
      "slice_with_slice_input/static_shaped_slice/static_shaped_slice");
  ASSERT_NE(static_shaped_slice, nullptr);
  EXPECT_EQ(static_shaped_slice->output_type(0), DT_FLOAT)
      << "Expected DT_FLOAT, was "
      << DataType_Name(static_shaped_slice->output_type(0));
  EXPECT_THAT(
      static_shaped_slice,
      NodeWith(
          Op("Slice"),

		}
		if !reflect.DeepEqual(actual.CPUQuota, testCase.expected.CPUQuota) {
			t.Errorf("unexpected result, test: %v, cpu quota not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CPUQuota, *actual.CPUQuota)
		}
		if !reflect.DeepEqual(actual.CPUShares, testCase.expected.CPUShares) {

        value = "Fess,フェス";
        expected = Arrays.asList("Fess", "フェス");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "\"Fess,FESS\"";
        expected = Arrays.asList("\"Fess,FESS\"");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = " ";

	containerInfo := getContainerInfoFromAnnotations(annotations)
	if !reflect.DeepEqual(containerInfo, expected) {
		t.Errorf("expected %v, got %v", expected, containerInfo)
	}
	if v, ok := annotations[opts.Annotations[0].Name]; !ok || v != opts.Annotations[0].Value {
		t.Errorf("expected annotation %s to exist got %v, %v", opts.Annotations[0].Name, ok, v)
	}