def channelId = new ChannelIdentifier("channel name")
        def message = new ChannelMessage(channelId, "payload")

        when:
        def serialized = serialize(message)
        def result = deserialize(serialized)

        then:
        result instanceof ChannelMessage
        result.channel == channelId
        result.payload == "payload"
    }

// Test simple serialized computation consisting of a function named `main`
// with a tf.Identity op forwarding the function single argument to the function
// single result.

// CHECK-LABEL: module

// Every stablehlo function deserialized from XlaCallModule has this attribute.
constexpr llvm::StringRef kFromXlaCallModuleAttrName = "_from_xla_call_module";

// Name of `tf.XlaCallModule`'s dictionary attribute for keeping the
// deserialized stablehlo module's attributes.
constexpr llvm::StringRef kStablehloModuleAttrsAttrName =
    "_stablehlo_module_attrs";

}  // namespace TF
}  // namespace mlir

        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);

        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();
    }