1 * buildController.fromBuildModel(false, _) >> { Boolean b, BuildTreeModelAction modelAction -> modelAction.fromBuildModel(modelController) }
        1 * internalAction.execute(_) >> model
        1 * payloadSerializer.serialize(model) >> serialized
    }

    def "can run action and reports failure"() {
        given:
        def failure = new RuntimeException()

     * returns.
     *
     * @param request The reader request to deserialize the model, must not be {@code null}.
     * @return The deserialized model, never {@code null}.
     * @throws IOException If the model could not be deserialized.
     * @throws XmlReaderException If the input format could not be parsed.
     */

## Decision

We do not use Java serialization.
Instead, we use custom serialization where we explicitly describe how data objects should be serialized and deserialized.

For internal purposes, we use binary formats for their brevity.
We use the `Serializer` abstraction to separate the actual implementation of serialization from its uses.

 */

package org.gradle.tooling.internal.provider.serialization;

import java.util.Map;

public interface SerializeMap {
    /**
     * Visits a class to be serialized, returning the id of the deserialize ClassLoader to associate this class with.
     * The id is unique only for this serialization, and is used as the key for the map built by {@link #collectClassLoaderDefinitions(Map)}.
     *

  auto deserialized = DeserializeStablehlo(context, op);
  if (!deserialized.ok()) {
    return op.emitOpError()
           << "failed to deserialize StableHLO module from XlaCallModule: "
           << deserialized.status().ToString();
  }
  OwningOpRef<ModuleOp> stablehlo_module = *std::move(deserialized);

  CopyStablehloModuleAttrs(*stablehlo_module, op);

/**
 * Methods factored out so that they can be emulated differently in GWT.
 *
 * @author Chris Povirk
 */
final class Platform {
  /** Serializes and deserializes the specified object (a no-op under GWT). */
  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    return checkNotNull(object);
  }

  private Platform() {}

        deserialize(serialize(action))

    private
    fun <T> serialize(action: TestableIsolatedAction<T>) =
        IsolatedActionSerializer(ownerGradle(), DefaultBeanStateWriterLookup(), isolatedActionCodecsFactory())
            .serialize(action)

    private
    fun <T> deserialize(serialized: SerializedIsolatedActionGraph<TestableIsolatedAction<T>>) =

            }
        }

        // Save the existing object being deserialized.
        NSDictionary stack = currentObject;

        currentObject = new NSDictionary();
        currentObject.put("isa", obj.isa());
        obj.serializeInto(this);
        objects.put(obj.getGlobalID(), currentObject);

        // Restore the existing object being deserialized.
        currentObject = stack;
        return obj.getGlobalID();
    }

 *
 * @author Chris Povirk
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class Platform {
  /** Serializes and deserializes the specified object. */
  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    checkNotNull(object);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);

 *
 * @author Chris Povirk
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class Platform {
  /** Serializes and deserializes the specified object. */
  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    checkNotNull(object);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);