}
			assert.Equal(t, test.expected, source)
		})
	}
}

func TestString(t *testing.T) {
	tests := []struct {
		sp       SyncPodType
		expected string
	}{
		{
			sp:       SyncPodCreate,
			expected: "create",
		},
		{
			sp:       SyncPodUpdate,
			expected: "update",
		},
		{
			sp:       SyncPodSync,
			expected: "sync",
		},
		{

// RUN: tf-opt %s -split-input-file -verify-diagnostics

// Tests invalid #tf_type.func attributes.

// expected-error@+1 {{expected '<'}}
func.func @main() attributes {tf._implements = #tf_type.func} {
  func.return
}

// -----

// expected-error@+2 {{expected attribute value}}
// expected-error@+1 {{expected symbol while parsing tf.func attribute}}
func.func @main() attributes {tf._implements = #tf_type.func<>} {
  func.return
}

      chunk = Math.max(1, Math.min(chunk, input.length()));
      assertEquals(expectProcess, bufferHelper(input, chunk));
      assertEquals(expectRead, readUsingJava(input, chunk));
      assertEquals(expectRead, readUsingReader(input, chunk, true));
      assertEquals(expectRead, readUsingReader(input, chunk, false));
    }
  }

  private static List<String> bufferHelper(String input, int chunk) throws IOException {

      chunk = Math.max(1, Math.min(chunk, input.length()));
      assertEquals(expectProcess, bufferHelper(input, chunk));
      assertEquals(expectRead, readUsingJava(input, chunk));
      assertEquals(expectRead, readUsingReader(input, chunk, true));
      assertEquals(expectRead, readUsingReader(input, chunk, false));
    }
  }

  private static List<String> bufferHelper(String input, int chunk) throws IOException {

    // expected-remark@+1 {{Cost: 1}}
    %9 = "tf.Const"() {value = dense<> : tensor<0x!tf_type.string>} : () -> tensor<0x!tf_type.string>
    // expected-remark@+1 {{Cost: 1}}
    %10 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    // expected-remark@+1 {{Cost: 1}}
    %11 = "tf.Const"() {value = dense<-1> : tensor<i32>} : () -> tensor<i32>
    // expected-remark@+1 {{Cost: 19}}

 */
class ToolingApiModelChecker {

    static <T> void checkModel(T actual, T expected, List<Object> specs) {
        assert (actual == null) == (expected == null)
        if (expected == null) {
            return
        }

        if (expected instanceof Collection) {
            assert actual instanceof Collection
            checkCollection(actual, expected) { actualItem, expectedItem ->

			aggregate{fmt.Errorf("abc (repeated 2 times)"), fmt.Errorf("ghi")},
		},
	}

	var expected, agg []error
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			if testCase.expected != nil {
				expected = testCase.expected.Errors()
				sort.Slice(expected, func(i, j int) bool { return expected[i].Error() < expected[j].Error() })
			}
			if testCase.mcm != nil {

			if tc.errStr != "" {
				t.Errorf("[%s] no error seen, but expected failure: %s", tc.name, tc.errStr)
			} else if actual != tc.expected {
				t.Errorf("[%s] expected address %q, got %q", tc.name, tc.expected, actual)
			}
		}
	}
}

func TestAllIPv6(t *testing.T) {
	tests := []struct {
		name     string
		addrs    []string
		expected bool
	}{
		{
			name:     "ipv4 only",

      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);

					Number:   80,
					Protocol: string(protocol.TCP),
					Name:     "tcp",
				},
			},
			expected: false,
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			actual := IsTLSServer(tc.server)
			if actual != tc.expected {
				t.Errorf("IsTLSServer(%s) => %t, want %t",
					tc.server, actual, tc.expected)
			}
		})
	}
}

func TestIsHTTPServer(t *testing.T) {
	cases := []struct {