{{- if and (.Values.networkPolicy.enabled) (eq .Values.networkPolicy.flavor "kubernetes") }}
kind: NetworkPolicy
apiVersion: {{ template "minio.networkPolicy.apiVersion" . }}
metadata:
  name: {{ template "minio.fullname" . }}
  labels:
    app: {{ template "minio.name" . }}
    chart: {{ template "minio.chart" . }}
    release: {{ .Release.Name }}
    heritage: {{ .Release.Service }}
spec:
  podSelector:
    matchLabels:

     *
     * @param fieldName the name of the field to get configuration for
     * @return an OptionalThing containing the Config if the field exists and has a non-blank value,
     *         otherwise an empty OptionalThing
     */
    public OptionalThing<Config> getConfig(final String fieldName) {
        final String value = params.get(fieldName);
        if (StringUtil.isNotBlank(value)) {

    // Helper methods

    private Object getFieldValue(Object obj, String fieldName) {
        try {
            Field field = getField(obj.getClass(), fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to get field value: " + fieldName, e);
        }
    }

    }

    @Test
    @DisplayName("Test date conversion from FILETIME")
    void testFiletimeConversion() throws Exception {
        // Test the FILETIME conversion logic
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write a known FILETIME value

public class StandardSystemPropertyTest extends TestCase {

  public void testGetKeyMatchesString() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      String fieldName = property.name();
      String expected = Ascii.toLowerCase(fieldName).replaceAll("_", ".");
      assertThat(property.key()).isEqualTo(expected);
    }
  }

  public void testGetValue() {

            final String[] newValues) {
        final Object existingObj = existingSource.get(fieldName);
        if (existingObj instanceof List) {
            @SuppressWarnings("unchecked")
            final List<String> existingValues = (List<String>) existingObj;
            concatValues(existingValues, newValues);
            map.put(fieldName, existingValues);
        } else {

     * Returns whether the {@link FieldDesc} exists.
     *
     * @param fieldName
     *            The field name. Must not be {@literal null} or empty string
     * @return Whether the {@link FieldDesc} exists
     */
    boolean hasFieldDesc(String fieldName);

    /**
     * Returns the {@link FieldDesc}.
     *
     * @param fieldName
     *            The field name. Must not be {@literal null} or empty string

        if (result instanceof TermQueryBuilder) {
            TermQueryBuilder termQueryBuilder = (TermQueryBuilder) result;
            assertEquals("field", termQueryBuilder.fieldName());
            assertEquals("value", termQueryBuilder.value());
            assertEquals(2.5f, termQueryBuilder.boost());
        }
    }

    @Test
    public void test_execute_withMatchAllDocsQuery() {

        for (i in 0 until headers.size) {
          val fieldName = headers.name(i)
          val value = headers.value(i)
          when {
            fieldName.equals("Date", ignoreCase = true) -> {
              servedDate = value.toHttpDateOrNull()
              servedDateString = value
            }

            fieldName.equals("Expires", ignoreCase = true) -> {

internal fun <T> readFieldOrNull(
  instance: Any,
  fieldType: Class<T>,
  fieldName: String,
): T? {
  var c: Class<*> = instance.javaClass
  while (c != Any::class.java) {
    try {
      val field = c.getDeclaredField(fieldName)
      field.isAccessible = true
      val value = field.get(instance)