`
	var job BatchJobRequest
	err := yaml.Unmarshal([]byte(expireYaml), &job)
	if err != nil {
		t.Fatal("Failed to parse batch-job-expire yaml", err)
	}
	if !slices.Equal(job.Expire.Prefix.F(), []string{"myprefix"}) {
		t.Fatal("Failed to parse batch-job-expire yaml")
	}

	multiPrefixExpireYaml := `
expire: # Expire objects that match a condition
  apiVersion: v1

    HashCode hashCodeA = HashCode.fromBytes(bytesA);
    HashCode hashCodeB = HashCode.fromBytes(bytesB);

    // They aren't equal...
    assertFalse(hashCodeA.equals(hashCodeB));

    // But they still have the same Object#hashCode() value.
    // Technically not a violation of the equals/hashCode contract, but...?
    assertEquals(hashCodeA.hashCode(), hashCodeB.hashCode());
  }

    }

    /**
     * Gets the relation type indicating how the record count should be interpreted.
     *
     * @return The record count relation (e.g., "eq" for exact, "gte" for greater than or equal)
     */
    public String getAllRecordCountRelation() {
        return allRecordCountRelation;
    }

    /**
     * Gets the time taken to execute the search query.
     *

        List<? super String> list) {
      return notSubtype(list);
    }

    // Can't test getSupertype() or getSubtype() because JDK reflection doesn't consider
    // Foo<?> and Foo<? extends Bar> equal for class Foo<T extends Bar>
    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public UseIterable<?> explicitTypeBoundIsSubtypeOfImplicitTypeBound(
        UseIterable<? extends Iterable<?>> obj) {

   * example, {@code [] < [1L] < [1L, 2L] < [2L] < [1L << 63]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(long[],
   * long[])}.
   *
   * <p><b>Java 9+ users:</b> Use {@link Arrays#compareUnsigned(long[], long[])
   * Arrays::compareUnsigned}.
   */

          TypeVariableImpl<?> that = typeVariableInvocationHandler.typeVariableImpl;
          return name.equals(that.getName())
              && genericDeclaration.equals(that.getGenericDeclaration())
              && bounds.equals(that.bounds);
        }
        return false;
      } else {
        // equal to any TypeVariable implementation regardless of bounds
        if (obj instanceof TypeVariable) {

        // Test that different instances are not equal
        DictionaryExpiredException exception1 = new DictionaryExpiredException();
        DictionaryExpiredException exception2 = new DictionaryExpiredException();

        assertNotSame(exception1, exception2);
        assertFalse(exception1.equals(exception2));
        assertTrue(exception1.equals(exception1));
    }

    public void test_hashCode() {

   * example, {@code [] < [1] < [1, 2] < [2]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(int[], int[])}.
   *
   * @since 2.0
   */
  public static Comparator<int[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }

		t.Run(tt.name, func(t *testing.T) {
			if err := yaml.Unmarshal([]byte(tt.args.yamlStr), &tt.b); (err != nil) != tt.wantErr {
				t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
			}
			if !slices.Equal(tt.b.Prefix.F(), tt.want) {
				t.Errorf("UnmarshalYAML() = %v, want %v", tt.b.Prefix.F(), tt.want)
			}
		})
	}

 *
 * <p>This class does <i>not</i> forward the {@code hashCode} and {@code equals} methods through to
 * the backing object, but relies on {@code Object}'s implementation. This is necessary to preserve
 * the symmetry of {@code equals}. Custom definitions of equality are usually based on an interface,
 * such as {@code Set} or {@code List}, so that the implementation of {@code equals} can cast the