charset = charset,
          )
        values +=
          value.canonicalizeWithCharset(
            encodeSet = FORM_ENCODE_SET,
            alreadyEncoded = true,
            plusIsSpace = true,
            charset = charset,
          )
      }

      fun build(): FormBody = FormBody(names, values)
    }

  companion object {

# Run custom mc command
runCommand() {
  ${MC} "$@"
  return $?
}

# Try connecting to MinIO instance
{{- if .Values.tls.enabled }}
scheme=https
{{- else }}
scheme=http
{{- end }}
connectToMinio $scheme

{{ if .Values.customCommands }}
# Run custom commands
{{- range .Values.customCommands }}
runCommand {{ .command }}
{{- end }}

@pytest.mark.parametrize(
    "path,headers,expected_status,expected_response",
    [
        ("/items", None, 200, {"X-Token values": None}),
        ("/items", {"x-token": "foo"}, 200, {"X-Token values": ["foo"]}),
        # TODO: fix this, is it a bug?
        # ("/items", [("x-token", "foo"), ("x-token", "bar")], 200, {"X-Token values": ["foo", "bar"]}),
    ],
)
def test(path, headers, expected_status, expected_response, client: TestClient):

{{- if .Values.serviceAccount.create }}
apiVersion: v1
kind: ServiceAccount
metadata:
  name: {{ .Values.serviceAccount.name | quote }}

      List<V> values = multimap().get(k);
      List<V> expectedValues = copyToList(values);

      assertTrue(multimap().put(k, v));
      expectedValues.add(v);
      assertGet(k, expectedValues);
      assertEquals(v, values.get(values.size() - 1));
    }
  }

    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {
      // Only trust the size of `values` if it is a Set and therefore probably already deduplicated.
      if (values instanceof Set<?>) {
        Set<?> collection = (Set<?>) values;
        return max(defaultExpectedValues, collection.size());
      } else {
        return defaultExpectedValues;
      }

      Collection<Object> values = cache.asMap().values();
      List<Entry<Object, Object>> warmed = warmUp(cache);

      Collection<Object> expected = Maps.newHashMap(cache.asMap()).values();
      assertThat(values).containsExactlyElementsIn(expected);
      assertThat(values.toArray()).asList().containsExactlyElementsIn(expected);

                        final String[] values = (String[]) e.getValue();
                        for (final String v : values) {
                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }
                    } else if (e.getValue() instanceof List) {
                        final List<String> values = (List<String>) e.getValue();

    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {
      // Only trust the size of `values` if it is a Set and therefore probably already deduplicated.
      if (values instanceof Set<?>) {
        Set<?> collection = (Set<?>) values;
        return max(defaultExpectedValues, collection.size());
      } else {
        return defaultExpectedValues;
      }

			return err
		}
	}
	return nil
}

// DropTable drop table for values
func (m Migrator) DropTable(values ...interface{}) error {
	values = m.ReorderModels(values, false)
	for i := len(values) - 1; i >= 0; i-- {
		tx := m.DB.Session(&gorm.Session{})
		if err := m.RunWithValue(values[i], func(stmt *gorm.Statement) error {
			return tx.Exec("DROP TABLE IF EXISTS ?", m.CurrentTable(stmt)).Error
		}); err != nil {