### Crea una clase `Enum`

Importa `Enum` y crea una sub-clase que herede desde `str` y desde `Enum`.

Al heredar desde `str` la documentación de la API podrá saber que los valores deben ser de tipo `string` y podrá mostrarlos correctamente.

Luego crea atributos de clase con valores fijos, que serán los valores disponibles válidos:

      }
    },
    LinkedHashMultisetImpl {
      @Override
      public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
        return LinkedHashMultiset.create(contents);
      }
    },
    ConcurrentHashMultisetImpl {
      @Override
      public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
        return ConcurrentHashMultiset.create(contents);
      }

				a("g", "v", "r", "exec", "name", admission.Create, &metav1.CreateOptions{}),
				a("2", "v", "r2", "proxy", "name", admission.Create, &metav1.CreateOptions{}),
				a("2", "v", "r3", "proxy", "name", admission.Create, &metav1.CreateOptions{}),
			),
			noMatch: attrList(
				a("g", "v", "r", "", "name", admission.Create, &metav1.CreateOptions{}),
				a("2", "v", "r2", "", "name", admission.Create, &metav1.CreateOptions{}),

            ContiguousSet.create(Range.closed(1, 3), integers()),
            ContiguousSet.closed(1, 3),
            ContiguousSet.create(Range.closedOpen(1, 4), integers()),
            ContiguousSet.closedOpen(1, 4),
            ContiguousSet.create(Range.openClosed(0, 3), integers()),
            ContiguousSet.create(Range.open(0, 4), integers()),
            ContiguousSet.create(Range.closed(1, 3), NOT_EQUAL_TO_INTEGERS),

    Multiset<String> ms1 = HashMultiset.create();
    Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a"));
    assertEquals(ms2, Multisets.union(ms1, ms2));
  }

  public void testUnionNonemptyEmpty() {
    Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a"));
    Multiset<String> ms2 = HashMultiset.create();
    assertEquals(ms1, Multisets.union(ms1, ms2));
  }

	Metrics.ObserveMatchConditionEvalError(context.TODO(), "x", kindWebhook, stepValidate, string(admission.Create))
	Metrics.ObserveMatchConditionEvalError(context.TODO(), "x", kindPolicy, stepAdmit, string(admission.Create))
	Metrics.ObserveMatchConditionEvalError(context.TODO(), "x", kindPolicy, stepValidate, string(admission.Create))
	wantLabelsCounterPolicyAdmit := map[string]string{

            }
        }
    }
// tag::create-rule-no-config[]
// tag::configure-rule[]
// tag::create-rule[]
// tag::managed-type-nested-config-rule[]
}
// end::create-rule[]
// end::create-rule-no-config[]
// end::configure-rule[]
// end::rule-inputs[]
// end::managed-type-nested-config-rule[]

// tag::model-map-nested-configure-rule[]
// tag::model-map-nested-create-rule[]
// tag::model-map-all-rule[]
model {

                }
            }

            extensions.create("thing", Thing, "a", "b", "c")
        """

        expect:
        fails()
        failure.assertHasCause("Could not create an instance of type Thing.")
        failure.assertHasCause("Too many parameters provided for constructor for type Thing. Expected 2, received 3.")
    }

    def "can create instance of interface with mutable property of type #type"() {

  /** Creates an {@code AtomicLongMap}. */
  public static <K> AtomicLongMap<K> create() {
    return new AtomicLongMap<>(new ConcurrentHashMap<>());
  }

  /** Creates an {@code AtomicLongMap} with the same mappings as the specified {@code Map}. */
  public static <K> AtomicLongMap<K> create(Map<? extends K, ? extends Long> m) {
    AtomicLongMap<K> result = create();
    result.putAll(m);
    return result;
  }

  /**

        container.create(name: "task")

        then:
        def e = thrown(GradleException)
        e.message == "Could not create task ':project:task'."
        e.cause == failure
    }

    void "create wraps task creation failure"() {
        given:
        def failure = new RuntimeException()

        taskFactory.create(_ as TaskIdentity) >> { throw failure }

        when:
        container.create("task")