import org.gradle.tooling.events.problems.AdditionalData;

import java.io.Serializable;
import java.util.Map;

public class GeneralData implements AdditionalData, Serializable {

    private final Map<String, Object> additionalData;

    public GeneralData(Map<String, Object> additionalData) {
        this.additionalData = ImmutableMap.copyOf(additionalData);
    }

    @Override

 */

package org.gradle.api.problems.internal;

import java.util.Map;

/**
 * General additional data type that can be used to attach arbitrary data to a problem with a string map.
 */
public interface GeneralData extends AdditionalData {

    Map<String, String> getAsMap();

    }

    public static AdditionalDataBuilder<GeneralData> builder(GeneralData from) {
        return new DefaultGeneralDataBuilder(from);
    }

    private static class DefaultGeneralDataBuilder implements GeneralDataSpec, AdditionalDataBuilder<GeneralData> {
        private final ImmutableMap.Builder<String, String> mapBuilder = ImmutableMap.builder();

        private DefaultGeneralDataBuilder() {
        }

                out.name("typeName").value(((TypeValidationData) value).getTypeName());
            } else if (value instanceof GeneralData) {
                out.name("type").value("generalData");
                out.name("data");
                out.beginObject();
                Map<String, String> map = ((GeneralData) value).getAsMap();
                for (String key : map.keySet()) {
                    out.name(key).value(map.get(key));

            return new DefaultAdditionalData(builder.build());
        } else if (additionalData instanceof GeneralData) {
            GeneralData data = (GeneralData) additionalData;
            return new DefaultAdditionalData(
                data.getAsMap().entrySet().stream()
                    .filter(entry -> isSupportedType(entry.getValue()))

            return (AdditionalDataBuilder<S>) DefaultDeprecationData.builder((DeprecationData) instance);
        } else if (GeneralData.class.isInstance(instance)) {
            return (AdditionalDataBuilder<S>) DefaultGeneralData.builder((GeneralData) instance);
        } else {
            throw new IllegalArgumentException("Unsupported instance: " + instance);
        }
    }

        deserialized.size() == 1
        deserialized[0].definition.id.name == "id"
        deserialized[0].definition.id.displayName == "label"
        deserialized[0].additionalData instanceof GeneralData
        (deserialized[0].additionalData as GeneralData).asMap == ['foo' : 'bar']
    }

    def "can serialize deprecation additional data"() {
        given:
        def problem = problemReporter.create {
            it.id("id", "label")

import org.gradle.tooling.events.problems.LineInFileLocation
import org.gradle.tooling.events.problems.Severity
import org.gradle.tooling.events.problems.SingleProblemEvent
import org.gradle.tooling.events.problems.internal.GeneralData
import org.gradle.util.GradleVersion
import org.junit.Assume

import static org.gradle.integtests.fixtures.AvailableJavaHomes.getJdk17
import static org.gradle.integtests.fixtures.AvailableJavaHomes.getJdk21

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.problems.internal;

/**
 * Specifies configuration options when creating a new GeneralData instance.
 */
public interface GeneralDataSpec extends AdditionalDataSpec {
    GeneralDataSpec put(String key, String value);

 * <p>
 * This is effectively a sealed interface that is used to restrict the types of additional data that can be attached to a problem.
 * The list interfaces supported by the problems API are:
 * <ul>
 *     <li>{@link GeneralData}</li>
 *     <li>{@link org.gradle.api.problems.internal.TypeValidationData}</li>
 *     <li>{@link org.gradle.api.problems.internal.DeprecationData}</li>
 * </ul>
 *