}
	return f.Type.DefaultValue()
}

// EnumValues returns the set of values that this field may take.
func (f *DeclField) EnumValues() []ref.Val {
	if f.enumValues == nil || len(f.enumValues) == 0 {
		return []ref.Val{}
	}
	ev := make([]ref.Val, len(f.enumValues))
	for i, e := range f.enumValues {
		ev[i] = types.DefaultTypeAdapter.NativeToValue(e)
	}
	return ev
}

		// an object will always be serialized at least as {}, so account for that
		minSerializedSize := int64(2)
		for name, prop := range s.Properties() {
			var enumValues []interface{}
			if prop.Enum() != nil {
				for _, e := range prop.Enum() {
					enumValues = append(enumValues, e)
				}
			}
			if fieldType := SchemaDeclType(prop, prop.IsXEmbeddedResource()); fieldType != nil {
				if propName, ok := apiservercel.Escape(name); ok {

  public void testEnumValueOf() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValueOf.kt");
  }

  @Test
  @TestMetadata("enumValues.kt")
  public void testEnumValues() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValues.kt");
  }

  @Test
  @TestMetadata("explicitLambdaParameter.kt")
  public void testExplicitLambdaParameter() {

  public void testEnumValueOf() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValueOf.kt");
  }

  @Test
  @TestMetadata("enumValues.kt")
  public void testEnumValues() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValues.kt");
  }

  @Test
  @TestMetadata("explicitLambdaParameter.kt")
  public void testExplicitLambdaParameter() {

  public void testEnumValueOf() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValueOf.kt");
  }

  @Test
  @TestMetadata("enumValues.kt")
  public void testEnumValues() {
    runTest("analysis/analysis-api/testData/symbols/symbolByReference/enumValues.kt");
  }

  @Test
  @TestMetadata("explicitLambdaParameter.kt")
  public void testExplicitLambdaParameter() {

			}
		}
		if (prop.ValueValidation == nil || len(prop.ValueValidation.Enum) == 0) && len(f.EnumValues()) != 0 {
			t.Errorf("field had more enum values than the property. field: %s", f.Name)
		}
		if prop.ValueValidation != nil {
			fevs := f.EnumValues()
			for _, fev := range fevs {
				found := false
				for _, pev := range prop.ValueValidation.Enum {

			}
		}
		if (len(prop.Enum) == 0) && len(f.EnumValues()) != 0 {
			t.Errorf("field had more enum values than the property. field: %s", f.Name)
		}

		fevs := f.EnumValues()
		for _, fev := range fevs {
			found := false
			for _, pev := range prop.Enum {
				celpev := types.DefaultTypeAdapter.NativeToValue(pev)

}


fun <E : Enum<E>> Encoder.writeEnum(value: E) {
    writeSmallInt(value.ordinal)
}


inline fun <reified E : Enum<E>> Decoder.readEnum(): E =
    readSmallInt().let { ordinal -> enumValues<E>()[ordinal] }


inline
fun <reified T : Any> ReadContext.readClassOf(): Class<out T> =
    readClass().asSubclass(T::class.java)


/**

        assertThat(annotation.value(), equalTo("test"));
        assertThat(annotation.values(), equalTo(new String[]{"1", "2"}));
        assertThat(annotation.enumValue(), equalTo(AnnotationEnum.A));
        assertThat(annotation.enumValues(), equalTo(new AnnotationEnum[]{AnnotationEnum.A, AnnotationEnum.B}));
        assertThat(annotation.number(), equalTo(1));
        assertThat(annotation.numbers(), equalTo(new int[]{1, 2}));

	case *dwarf.EnumType:
		if t.Align = t.Size; t.Align >= c.ptrSize {
			t.Align = c.ptrSize
		}
		t.C.Set("enum " + dt.EnumName)
		signed := 0
		t.EnumValues = make(map[string]int64)
		for _, ev := range dt.Val {
			t.EnumValues[ev.Name] = ev.Val
			if ev.Val < 0 {
				signed = signedDelta
			}
		}
		switch t.Size + int64(signed) {
		default: