}
}

func TestValueEqual(t *testing.T) {
	var x, y int
	vals := []Value{
		{},
		Int64Value(1),
		Int64Value(2),
		Float64Value(3.5),
		Float64Value(3.7),
		BoolValue(true),
		BoolValue(false),
		TimeValue(testTime),
		TimeValue(time.Time{}),
		TimeValue(time.Date(2001, 1, 2, 3, 4, 5, 0, time.UTC)),
		TimeValue(time.Date(2300, 1, 1, 0, 0, 0, 0, time.UTC)),            // overflows nanoseconds

}

// NamedResourcesAttributeValue must have one and only one field set.
type NamedResourcesAttributeValue struct {
	// QuantityValue is a quantity.
	QuantityValue *resource.Quantity
	// BoolValue is a true/false value.
	BoolValue *bool
	// IntValue is a 64-bit integer.
	IntValue *int64
	// IntSliceValue is an array of 64-bit integers.
	IntSliceValue *NamedResourcesIntSlice
	// StringValue is a string.
	StringValue *string

							LocalityLbSetting: &networking.LocalityLoadBalancerSetting{
								FailoverPriority: []string{
									"a",
									"b",
								},
								Enabled: &wrapperspb.BoolValue{Value: false},
							},
						},
					},
				},
			},
			expectedLabels: nil,
		},
		{
			name: "mesh LocalityLoadBalancerSetting",
			dr: &config.Config{

type NamedResourcesAttributeValue struct {
	// QuantityValue is a quantity.
	QuantityValue *resource.Quantity `json:"quantity,omitempty" protobuf:"bytes,6,opt,name=quantity"`
	// BoolValue is a true/false value.
	BoolValue *bool `json:"bool,omitempty" protobuf:"bytes,2,opt,name=bool"`
	// IntValue is a 64-bit integer.
	IntValue *int64 `json:"int,omitempty" protobuf:"varint,7,opt,name=int"`

			klog.Warningf("Setting deprecated feature gate %s=%s. It will be removed in a future release.", k, v)
		}

		boolValue, err := strconv.ParseBool(v)
		if err != nil {
			return nil, errors.Errorf("invalid value %v for feature-gate key: %s, use true|false instead", v, k)
		}
		featureGate[k] = boolValue
	}

	return featureGate, nil
}

			componentName, err)
	}
	if !found || componentNodeI == nil {
		return false, nil
	}
	componentNode, ok := componentNodeI.(*wrapperspb.BoolValue)
	if !ok {
		return false, fmt.Errorf("component %s enabled has bad type %T, expect *v1alpha1.BoolValueForPB", componentName, componentNodeI)
	}
	if componentNode == nil {
		return false, nil
	}

			// Create a route with a retry policy with RetryRemoteLocalities enabled.
			route: &networking.HTTPRoute{
				Retries: &networking.HTTPRetry{
					Attempts: 2,
					RetryRemoteLocalities: &wrappers.BoolValue{
						Value: true,
					},
				},
			},
			assertFunc: func(g *WithT, policy *envoyroute.RetryPolicy) {
				g.Expect(policy).To(Not(BeNil()))

      "path": "pathValue",
      "readOnly": true
    },
    "rbd": {
      "monitors": [
        "monitorsValue"
      ],
      "image": "imageValue",
      "fsType": "fsTypeValue",
      "pool": "poolValue",
      "user": "userValue",
      "keyring": "keyringValue",
      "secretRef": {
        "name": "nameValue",
        "namespace": "namespaceValue"
      },
      "readOnly": true
    },
    "iscsi": {

        user: userValue
        volume: volumeValue
      rbd:
        fsType: fsTypeValue
        image: imageValue
        keyring: keyringValue
        monitors:
        - monitorsValue
        pool: poolValue
        readOnly: true
        secretRef:
          name: nameValue
          namespace: namespaceValue
        user: userValue
      scaleIO:
        fsType: fsTypeValue
        gateway: gatewayValue

    tenant: tenantValue
    user: userValue
    volume: volumeValue
  rbd:
    fsType: fsTypeValue
    image: imageValue
    keyring: keyringValue
    monitors:
    - monitorsValue
    pool: poolValue
    readOnly: true
    secretRef:
      name: nameValue
      namespace: namespaceValue
    user: userValue
  scaleIO:
    fsType: fsTypeValue
    gateway: gatewayValue