bindings.methodBindings*.getClass() == [ManagedPropertyMethodBinding, ManagedPropertyMethodBinding]
        bindings.methodBindings*.viewMethod*.name == ["getZ", "setZ"]
    }

    static abstract class TypeWithImplementedProperty {
        int getZ() { 0 }
        void setZ(int value) {}
    }

    def "extracts simple type with an implemented property"() {
        def bindings = extract(TypeWithImplementedProperty)

}

func (t *T) GetX() int {
	return t.X
}
func (t *T) GetY() int {
	return t.Y
}
func (t *T) GetZ() int {
	return t.Z
}

func samePackage() {
	var t T
	println(t.GetX())
	println(t.GetZ())
}

func crossPackage() {
	var t a.T
	println(t.GetX())
	println(t.GetZ())
}

// This global variable is set by the linker using the -k option.

package a

type T struct {
	X int `go:"track"`
	Y int `go:"track"`
	Z int // untracked
}

func (t *T) GetX() int {
	return t.X
}
func (t *T) GetY() int {
	return t.Y
}
func (t *T) GetZ() int {
	return t.Z

   * has three properties, {@code x}, {@code y}, and {@code z}, one could write:
   *
   * <pre>{@code
   * public int hashCode() {
   *   return Objects.hashCode(getX(), getY(), getZ());
   * }
   * }</pre>
   *
   * <p><b>Warning:</b> When a single object is supplied, the returned hash code does not equal the
   * hash code of that object.
   *

   * has three properties, {@code x}, {@code y}, and {@code z}, one could write:
   *
   * <pre>{@code
   * public int hashCode() {
   *   return Objects.hashCode(getX(), getY(), getZ());
   * }
   * }</pre>
   *
   * <p><b>Warning:</b> When a single object is supplied, the returned hash code does not equal the
   * hash code of that object.
   *

    Operation *op = rewriter.create(state);
    rewriter.replaceOp(batch_norm, op->getResults());

    // Depending on the case, we may fuse the add, the relu, or both.
    if (!add_op || add_op.getZ().hasOneUse()) {
      // We fuse the Relu only if the add has a single use, otherwise we only
      // fuse the add itself.
      op->setAttr("activation_mode", rewriter.getStringAttr("Relu"));

	JGE:       "jnl",
	JNE:       "jnz",
	JG:        "jnle",
	JE:        "jz",
	SETAE:     "setnb",
	SETA:      "setnbe",
	SETGE:     "setnl",
	SETNE:     "setnz",
	SETG:      "setnle",
	SETE:      "setz",
	CMOVAE:    "cmovnb",
	CMOVA:     "cmovnbe",
	CMOVGE:    "cmovnl",
	CMOVNE:    "cmovnz",
	CMOVG:     "cmovnle",
	CMOVE:     "cmovz",
	LCALL:     "call far",
	LJMP:      "jmp far",

    auto new_filter =
        rewriter.create<TF::MulOp>(mul_op.getLoc(), filter, new_const_val)
            .getZ();
    // If bias isn't None, it needs to be multiplied as well.
    if (!mlir::isa<NoneType>(bias.getType())) {
      bias = rewriter.create<TF::MulOp>(mul_op.getLoc(), bias, constant_val)
                 .getZ();
    }

    auto fc = rewriter.create<TFL::FullyConnectedOp>(

func testClientWrites(t *testing.T, mode testMode) {
	ts := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) {
	})).ts

	writes := 0
	dialer := func(netz string, addr string) (net.Conn, error) {
		c, err := net.Dial(netz, addr)
		if err == nil {
			c = &writeCountingConn{c, &writes}
		}
		return c, err
	}
	c := ts.Client()
	c.Transport.(*Transport).Dial = dialer

      /*weight_zp=*/0,
      /*input_output_dims=*/ArrayRef<int64_t>({0}),
      /*weight_output_dims=*/ArrayRef<int64_t>({num_dims - 1}));
  return builder.create<TF::SubOp>(loc, xla_conv_output, zp_offset).getZ();
}

// Creates a XlaConvV2Op from TF Conv2DOp and returns its output. The returned
// value will be used as an input of the next op.
Value CreateXlaConvOpFromTfConv2dOp(OpBuilder &builder, Location loc,