assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);

  }

  static <T extends Enum<T>> Optional<T> getEnumIfPresent(Class<T> enumClass, String value) {
    WeakReference<? extends Enum<?>> ref = Enums.getEnumConstants(enumClass).get(value);
    /*
     * We use `fromNullable` instead of `of` because `WeakReference.get()` has a nullable return
     * type.
     *
     * In practice, we are very unlikely to see `null`: The `WeakReference` to the enum constant

  }

  static <T extends Enum<T>> Optional<T> getEnumIfPresent(Class<T> enumClass, String value) {
    WeakReference<? extends Enum<?>> ref = Enums.getEnumConstants(enumClass).get(value);
    /*
     * We use `fromNullable` instead of `of` because `WeakReference.get()` has a nullable return
     * type.
     *
     * In practice, we are very unlikely to see `null`: The `WeakReference` to the enum constant

### Criando uma classe `Enum`

Importe `Enum` e crie uma sub-classe que herde de `str` e de `Enum`.

Por herdar de `str` a documentação da API vai ser capaz de saber que os valores devem ser do tipo `string` e assim ser capaz de mostrar eles corretamente.

import javax.annotation.Nullable;

/**
 * Isolates an Enum value and is a snapshot for that value.
 */
public class IsolatedEnumValueSnapshot extends EnumValueSnapshot implements Isolatable<Enum<?>> {
    private final Enum<?> value;

    public IsolatedEnumValueSnapshot(Enum<?> value) {
        super(value);
        this.value = value;
    }

    public Enum<?> getValue() {
        return value;
    }

    @Override

	ret.Pattern = v.Pattern
	ret.MaxItems = v.MaxItems
	ret.MinItems = v.MinItems
	ret.UniqueItems = v.UniqueItems
	ret.MultipleOf = v.MultipleOf
	if v.Enum != nil {
		ret.Enum = make([]interface{}, 0, len(v.Enum))
		for i := range v.Enum {
			ret.Enum = append(ret.Enum, v.Enum[i].Object)
		}
	}
	ret.MaxProperties = v.MaxProperties
	ret.MinProperties = v.MinProperties
	ret.Required = v.Required
	for i := range v.AllOf {

				if strings.Contains(prop.Description, "enum") {
					enumAppeared = true
					if !tc.shouldHaveEnum {
						t.Errorf("enum appeared, description: %s", prop.Description)
					}
				}
				if len(prop.Enum) != 0 {
					enumAppeared = true
					if !tc.shouldHaveEnum {
						t.Errorf("enum appeared, enum: %v", prop.Enum)
					}
				}
			}
			if !enumAppeared && tc.shouldHaveEnum {

            return this;
        }
        return snapshotter.snapshot(value);
    }

    private boolean isEqualEnum(@Nullable Object value) {
        if (value instanceof Enum<?>) {
            Enum<?> enumValue = (Enum<?>) value;
            return enumValue.name().equals(name) && enumValue.getDeclaringClass().getName().equals(className);
        }
        return false;
    }

    @Override

}

public typealias KtKClassAnnotationValue = KaKClassAnnotationValue

/**
 * Some enum entry (enum constant) used as annotation argument. E.g: `@A(Color.RED)`
 */
public class KaEnumEntryAnnotationValue @KaAnalysisApiInternals constructor(
    /**
     * Fully qualified name of used enum entry.
     */
    callableId: CallableId?,
    sourcePsi: KtElement?,
    token: KaLifetimeToken

import java.util.EnumSet;

/**
 * Request for interceptors. Currently, we support filter just for interception types, but in the feature we could also filter per version etc.
 *
 * Implemented as a enum, so it's easier to generate bytecode.
 */
public enum BytecodeInterceptorFilter {
    INSTRUMENTATION_ONLY(EnumSet.of(BytecodeInterceptorType.INSTRUMENTATION)),