Requirement{"key", selection.In, []string{"value", "value1"}},
				Requirement{"key2", selection.In, []string{"value2"}},
			},
			label:         "key2",
			expectedFound: true,
			expectedValue: "value2",
		},
		{
			name:          "keyEqualOperatorExactMatch",
			sel:           internalSelector{Requirement{"key", selection.Equals, []string{"value"}}},
			label:         "key",
			expectedFound: true,

    checkNotNull(value2);
    checkArgument(!Objects.equal(value1, value2), "Duplicate value provided.");
    distinctValues.replaceValues(type, ImmutableList.of(value1, value2));
    setDefault(type, value1);
    return this;
  }

  /**
   * Tests that {@code cls} properly checks null on all constructor and method parameters that
   * aren't annotated nullable (according to the rules of {@link NullPointerTester}). In details:
   *

  %keys = "tf.Const"() {value = dense<["a", "b", "c", "d"]> : tensor<4x!tf_type.string>} : () -> tensor<4x!tf_type.string>
  %values = "tf.Const"() {value = dense<[1, 2, 3, 4]> : tensor<4xi64>} : () -> tensor<4xi64>
  "tf.LookupTableImportV2"(%handle, %keys, %values) {device = ""} : (tensor<!tf_type.resource>, tensor<4x!tf_type.string>, tensor<4xi64>) -> ()

func createNodeAffinity(key string, value string) *v1.VolumeNodeAffinity {
	return &v1.VolumeNodeAffinity{
		Required: &v1.NodeSelector{
			NodeSelectorTerms: []v1.NodeSelectorTerm{
				{
					MatchExpressions: []v1.NodeSelectorRequirement{
						{
							Key:      key,
							Operator: v1.NodeSelectorOpIn,
							Values:   []string{value},
						},
					},
				},

	}
	sort.Strings(known)
	return known
}

// NewFeatureGate parses a string of the form "key1=value1,key2=value2,..." into a
// map[string]bool of known keys or returns an error.
func NewFeatureGate(f *FeatureList, value string) (map[string]bool, error) {
	featureGate := map[string]bool{}
	for _, s := range strings.Split(value, ",") {
		if len(s) == 0 {
			continue
		}

		arr := strings.SplitN(s, "=", 2)

				b.Fatalf("Unmarshal error: %v", err)
			}
		}
	})
}

func BenchmarkUnmarshalMap(b *testing.B) {
	b.ReportAllocs()
	data := []byte(`{"key1":"value1","key2":"value2","key3":"value3"}`)
	b.RunParallel(func(pb *testing.PB) {
		x := make(map[string]string, 3)
		for pb.Next() {
			if err := Unmarshal(data, &x); err != nil {
				b.Fatalf("Unmarshal error: %v", err)
			}
		}

my-git9 <******@****.***> 1717171652 +0800

  // This is the same as the default equality operator, which works because
  // we're interning all strings. It is specified here so we are explicit about
  // it. We're not saying "= default;" because we can't use C++20 features yet.
  bool operator==(const String& other) const { return value_ == other.value_; }

  const std::string& str() const { return *value_; }

  /** Absl hash function. */

        private final String value;

        public NamedBean(String name, String value) {
            this.name = name;
            this.value = value;
        }

        @Override
        public String getName() {
            return name;
        }

        @Input
        public String getValue() {
            return value;
        }
    }

            "type": "object"
          }
        },
        "priorityClassName": {
          "type": "string"
        }
      }
    }
  },
  "defaults": {
    "$ref": "#/$defs/values"
  },
  "$ref": "#/$defs/values"