attrs = AttributeTestUtil.attributesFactory().mutable()
        services.configureAttributes(Stub(HasConfigurableAttributes) { getAttributes() >> attrs }) {
            it.platform()
        }

        then:
        attrs.asMap() == [
            (CATEGORY_ATTRIBUTE): named(Category, REGULAR_PLATFORM)
        ]

        when:
        attrs = AttributeTestUtil.attributesFactory().mutable()

		},
	},
	{
		name:        "attrs",
		explanation: withSource("a Handler should output attributes passed to the logging function"),
		f: func(l *slog.Logger) {
			l.Info("message", "k", "v")
		},
		checks: []check{
			hasAttr("k", "v"),
		},
	},
	{
		name:        "empty-attr",
		explanation: withSource("a Handler should ignore an empty Attr"),
		f: func(l *slog.Logger) {

  string padding;
  string data_format;
  auto attrs = op.output(0).node()->attrs();
  TF_RETURN_IF_ERROR(GetNodeAttr(attrs, "ksize", &ksize));
  TF_RETURN_IF_ERROR(GetNodeAttr(attrs, "strides", &strides));
  TF_RETURN_IF_ERROR(GetNodeAttr(attrs, "padding", &padding));
  TF_RETURN_IF_ERROR(GetNodeAttr(attrs, "data_format", &data_format));
  MaxPool3DGrad::Attrs grad_attrs;
  auto dx =

                    attributes.attribute(Attribute.of("attr1", Named), objects.named(Named,"value"))
                }
            }
        """
        buildFile << """
            configurations {
                dependencyScope("implementation")
                resolvable("runtimeClasspath") {
                    attributes.attribute(Attribute.of("attr1", Named), objects.named(Named,"value"))

	node0 := &user.DefaultInfo{Name: "system:node:node0", Groups: []string{"system:nodes"}}

	tests := []struct {
		name     string
		attrs    authorizer.AttributesRecord
		expect   authorizer.Decision
		features featuregate.FeatureGate
	}{
		{
			name:   "allowed configmap",
			attrs:  authorizer.AttributesRecord{User: node0, ResourceRequest: true, Verb: "get", Resource: "configmaps", Name: "configmap0-pod0-node0", Namespace: "ns0"},

func TestIgnoresNonPodResource(t *testing.T) {
	pod := &api.Pod{}
	attrs := admission.NewAttributesRecord(pod, nil, api.Kind("Pod").WithVersion("version"), "myns", "myname", api.Resource("CustomResource").WithVersion("version"), "", admission.Create, &metav1.CreateOptions{}, false, nil)
	handler := admissiontesting.WithReinvocationTesting(t, NewServiceAccount())
	err := handler.Admit(context.TODO(), attrs, nil)
	if err != nil {

		}
		return &unstructured.Unstructured{Object: m}
	}
	testcases := []struct {
		Name          string
		Attrs         *VersionedAttributes
		GVK           schema.GroupVersionKind
		ExpectedAttrs *VersionedAttributes
	}{
		{
			Name: "noop",
			Attrs: &VersionedAttributes{
				Attributes: attrs(
					&example.Pod{ObjectMeta: metav1.ObjectMeta{Name: "newpod"}},

type Token any

// A StartElement represents an XML start element.
type StartElement struct {
	Name Name
	Attr []Attr
}

// Copy creates a new copy of StartElement.
func (e StartElement) Copy() StartElement {
	attrs := make([]Attr, len(e.Attr))
	copy(attrs, e.Attr)
	e.Attr = attrs
	return e
}

// End returns the corresponding XML end element.
func (e StartElement) End() EndElement {
	return EndElement{e.Name}
}

  if (flib_def.Find(n.type_string())) {
    NameAttrList callee;
    callee.set_name(n.type_string());
    *callee.mutable_attr() = n.def().attr();
    return {callee};
  }

  CallTargetListTy result;
  for (const auto& name_attr_pair : n.attrs()) {
    const AttrValue& attr_value = name_attr_pair.second;
    if (attr_value.value_case() == AttrValue::kFunc) {
      result.push_back(attr_value.func());

          is_ref: true
        }
        attr {
          name: "shape"
          type: "shape"
        }
        attr {
          name: "dtype"
          type: "type"
        }
        attr {
          name: "container"
          type: "string"
          default_value {
            s: ""
          }
        }
        attr {
          name: "shared_name"
          type: "string"