Weight:      5,
		}, {
			Destination: &networking.Destination{Host: "foo.baz.east"},
			Weight:      -1,
		}}, valid: false},
		{name: "total weight > 100", routes: []*networking.RouteDestination{{
			Destination: &networking.Destination{Host: "foo.baz.south"},
			Weight:      550,
		}, {
			Destination: &networking.Destination{Host: "foo.baz.east"},
			Weight:      500,
		}}, valid: true},

	}

	rss, err = fp.ipvs.GetRealServers(vs)
	if err != nil {
		t.Errorf("failed to get real server, err: %v", err)
	}
	for _, rs := range rss {
		if rs.Weight != 1 {
			t.Logf("unexpected realserver weight: %d, expected weight: 1", rs.Weight)
			t.Errorf("unexpected realserver state")
		}
	}
}

func TestIPv4Proxier(t *testing.T) {
	tests := []struct {
		name         string

  return %1 : tensor<1x2x3x5xf32>
}

// CHECK: %[[WEIGHT:.+]] = "tfl.pseudo_qconst"() <{qtype = tensor<1x2x4x5x!quant.uniform<i8:f32, 1.000000e+00>>, value = dense<1> : tensor<1x2x4x5xi8>}>
// CHECK: %[[DQ:.+]] = "tfl.dequantize"(%[[WEIGHT]]) : (tensor<1x2x4x5x!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<1x2x4x5xf32>

      ('to_xla_per_tensor', quant_opts_pb2.XLA, False),
      ('stablehlo_per_channel', quant_opts_pb2.STABLEHLO, True),
      # TODO: b/289761265 - [Converter Component][TF-Quantizer] Improve Weight-
      # only Quantization
      # Enable this back once new weight-only quantizer is supported for per-
      # channel quantization.
      # ('to_xla_per_channel', quant_opts_pb2.XLA, True),
  )
  @test_util.run_in_graph_and_eager_modes

				{
					ExtenderName: "FakeExtender1",
					Weight:       1,
					Prioritizers: []tf.PriorityConfig{
						{
							Weight:   3,
							Function: tf.Node1PrioritizerExtender,
						},
					},
				},
				{
					ExtenderName: "FakeExtender2",
					Weight:       1,
					Prioritizers: []tf.PriorityConfig{
						{
							Weight:   2,
							Function: tf.Node2PrioritizerExtender,

    - destination:
        host: {{ (index .dst 0).Config.Service }}
      headers:
        request:
          set:
            Host: dest-authority
      weight: 50
    - destination:
        host: {{ (index .dst 0).Config.Service }}
      weight: 50
    headers:
      request:
        set:
          :authority: route-authority`,
		opts: echo.CallOptions{
			Port: echo.Port{
				Name: "http",
			},

  // expected-error @+1 {{'tfl.unidirectional_sequence_lstm' op failed to verify that either projection weight must be specified or both projection weight and projection bias must not be specified}}

	NS_DNS       = 12
	NS_NLA       = 15
	NS_BTH       = 16
	NS_EMAIL     = 37
	NS_PNRPNAME  = 38
	NS_PNRPCLOUD = 39
)

type DNSSRVData struct {
	Target   *uint16
	Priority uint16
	Weight   uint16
	Port     uint16
	Pad      uint16
}

type DNSPTRData struct {
	Host *uint16
}

type DNSMXData struct {
	NameExchange *uint16
	Preference   uint16

			}

			if tt.expectedLocalityWeightedConfig && c.CommonLbConfig.GetLocalityWeightedLbConfig() == nil {
				t.Errorf("cluster expected to have weighed config, but is nil")
			}
			if tt.expectClusterLoadAssignmenttoBeNil && c.LoadAssignment != nil {
				t.Errorf("cluster expected not to have load assignmentset, but is present")
			}
		})
	}
}

  let constructor = "TFTPU::CreateTPUColocateSplitsPass()";
  let description = [{
    It is beneficial for performance to assign a `Split` op to the same device
    as its predecessor. This is because the weight of cut edges is always
    minimized when the `Split` is with its predecessor. This colocation
    constraint will be used by the placer graph optimization to assign a device
    to the op.