problemMessage, actualMessages);
            assertTrue(false, message);
        }

        return this;
    }

    // Helper method for backward compatibility
    static ProjectBuildingResultWithProblemMessageAssert projectBuildingResultWithProblemMessage(String message) {
        return new ProjectBuildingResultWithProblemMessageAssert(null).hasProblemMessage(message);
    }

                    public String foo() { return "bar"; }
                }
            """,
            v2 = """
                import $nullableAnnotationName;
                public class Source {
                    @Nullable public String nonFinalField = null;
                    @Nullable public final String finalField = null;
                    @Nullable public String foo() { return "bar"; }
                }
            """

        _ * classMetaData.className >> name
        return classMetaData
    }

    def classDoc(String name = 'org.gradle.Class') {
        ClassDoc doc = Mock()
        _ * doc.name >> name
        _ * doc.toString() >> "ClassDoc '$name'"
        return doc
    }

    def property(String name, ClassMetaData classMetaData) {
        return property([:], name, classMetaData)
    }

        switch (messageType) {
        case 'D':
            return new LogMessage(LogLevel.DEBUG, message);
        case 'I':
            return new LogMessage(LogLevel.INFO, message);
        case 'W':
            return new LogMessage(LogLevel.WARN, message);
        case 'E':
            return new LogMessage(LogLevel.ERROR, message);
        case 'F':
            return new LogMessage(LogLevel.FATAL, message);
        default:

        return sa or None

    @property
    def required(self) -> bool:
        return self.field_info.is_required()

    @property
    def default(self) -> Any:
        return self.get_default()

    @property
    def type_(self) -> Any:
        return self.field_info.annotation

    def __post_init__(self) -> None:
        with warnings.catch_warnings():

                return OptionalEntity.of(mappingItem);
            }
        }
        return OptionalEntity.empty();
    }

    /**
     * Retrieves a paginated list of character mapping items.
     *
     * @param offset the starting index for pagination (0-based)
     * @param size the maximum number of items to return

    /**
     * Normalizes the string representation of a number.
     *
     * @param s
     *            A string representing a number
     * @return The normalized string
     * @see #normalize(String, Locale)
     */
    public static String normalize(final String s) {
        return normalize(s, LocaleUtil.getDefault());
    }

    /**
     * Normalizes the string representation of a number by removing grouping separators

        bufferIndex += 12; // 10 reserved

        return bufferIndex - start;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        // handled special in SmbTransport.doRecv()
        return 0;
    }

    @Override
    public String toString() {

    private WebConfig webConfig;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

  @Override
  public SampleElements<AnEnum> samples() {
    return new Enums();
  }

  @Override
  public Multiset<AnEnum> create(Object... elements) {
    AnEnum[] array = new AnEnum[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (AnEnum) e;
    }
    return create(array);
  }

  protected abstract Multiset<AnEnum> create(AnEnum[] elements);