if ok {
		k, _ := cache.MetaNamespaceKeyFunc(ao)
		return Key[O](k)
	}
	panic(fmt.Sprintf("Cannot get Key, got %T", a))
}

// Named is a convenience struct. It is ideal to be embedded into a type that has a name and namespace,
// and will automatically implement the various interfaces to return the name, namespace, and a key based on these two.
type Named struct {
	Name, Namespace string
}

	cert, err := os.ReadFile(c.certFile)
	if err != nil {
		return err
	}
	key, err := os.ReadFile(c.keyFile)
	if err != nil {
		return err
	}
	if len(cert) == 0 || len(key) == 0 {
		return fmt.Errorf("missing content for serving cert %q", c.Name())
	}

	// Ensure that the key matches the cert and both are valid
	_, err = tls.X509KeyPair(cert, key)
	if err != nil {
		return err
	}

	newCertKey := &certKeyContent{

	return tCtx, cache, informer
}

func verify(tCtx ktesting.TContext, cache *AssumeCache, key string, expectedObject, expectedAPIObject interface{}) {
	tCtx.Helper()
	actualObject, err := cache.Get(key)
	if err != nil {
		tCtx.Fatalf("unexpected error retrieving object for key %s: %v", key, err)
	}
	if actualObject != expectedObject {
		tCtx.Fatalf("Get() returned %v, expected %v", actualObject, expectedObject)

      }
    ]
  },
  "spec": {
    "podSelector": {
      "matchLabels": {
        "matchLabelsKey": "matchLabelsValue"
      },
      "matchExpressions": [
        {
          "key": "keyValue",
          "operator": "operatorValue",
          "values": [
            "valuesValue"
          ]
        }
      ]
    },
    "ingress": [
      {
        "ports": [
          {

      }
    ]
  },
  "spec": {
    "podSelector": {
      "matchLabels": {
        "matchLabelsKey": "matchLabelsValue"
      },
      "matchExpressions": [
        {
          "key": "keyValue",
          "operator": "operatorValue",
          "values": [
            "valuesValue"
          ]
        }
      ]
    },
    "ingress": [
      {
        "ports": [
          {

	Metric      string
	Aggregation string
	Labels      map[string]string
}

func (q Query) String() string {
	query := q.Metric + `{`

	keys := []string{}
	for k := range q.Labels {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		v := q.Labels[k]
		query += fmt.Sprintf(`%s=%q,`, k, v)
	}
	query += "}"
	if q.Aggregation != "" {

        matchExpressions:
        - key: keyValue
          operator: operatorValue
          values:
          - valuesValue
        matchLabels:
          matchLabelsKey: matchLabelsValue
      targetAverageValue: "0"
      targetValue: "0"
    object:
      averageValue: "0"
      metricName: metricNameValue
      selector:
        matchExpressions:
        - key: keyValue
          operator: operatorValue

    for key, value in update_dict.items():
        if (
            key in main_dict
            and isinstance(main_dict[key], dict)
            and isinstance(value, dict)
        ):
            deep_dict_update(main_dict[key], value)
        elif (
            key in main_dict
            and isinstance(main_dict[key], list)
            and isinstance(update_dict[key], list)

    }

    static void checkEnvironmentVariableUnset(String key) {
        // We can't "unset" the variable with the API executer provides, but it isn't necessary, thanks to the filtering in
        // build-logic/jvm/src/main/kotlin/gradlebuild/propagated-env-variables.kt
        if (System.getenv().containsKey(key)) {
            throw new IllegalStateException("Environment variable $key is present for this process and may affect tests")
        }
    }

        </entry>
        <entry key="$PROJECT_DIR$/compiler/testData/codegen/boxInline">
          <value>
            <array>
              <option value="$PROJECT_DIR$/js/js.tests/build/node/{out,out-min,out-per-module,out-per-module-min}/codegen/{boxInline,irBoxInline,firBoxInline,firEs6BoxInline}/$TEST_DATA_FILE$_v5.js" />
            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/compiler/testData/debug">