continue
		}
		reserialised, err := MarshalPKCS8PrivateKey(privKey)
		if err != nil {
			t.Errorf("%s: failed to marshal into PKCS#8: %s", test.name, err)
			continue
		}
		if !bytes.Equal(derBytes, reserialised) {
			t.Errorf("%s: marshaled PKCS#8 didn't match original: got %x, want %x", test.name, reserialised, derBytes)
			continue
		}

    private
    val pluginsSchema: AnalysisSchema = schema

    @Test
    fun `schema is serializable`() {
        val serialized = SchemaSerialization.schemaToJsonString(pluginsSchema)
        val deserialized = SchemaSerialization.schemaFromJsonString(serialized)

        val result = deserialized.resolve(
            """
            plugins {
                id("test")
            }
            """.trimIndent()
        )

}

// Decoder attempts to load an object from data.
type Decoder interface {
	// Decode attempts to deserialize the provided data using either the innate typing of the scheme or the
	// default kind, group, and version provided. It returns a decoded object as well as the kind, group, and
	// version from the serialized data, or an error. If into is non-nil, it will be used as the target type

    const ::stablehlo::quantization::PipelineConfig& pipeline_config,
    const ::stablehlo::quantization::DebuggerConfig& debugger_config);

// Deserializes StableHLO functions serialized and embedded in XlaCallModuleOps.
void AddXlaCallModuleOpDeserializationPasses(OpPassManager& pm);

// Legalizes shape/tensor/arith dialect ops to StableHLO for handling dynamic

    }

    def "deserialize and correctly map results"() {
        def result1 = 'result1'
        def serializedResult1 = Stub(SerializedPayload)
        def result2 = 'result2'
        def serializedResult2 = Stub(SerializedPayload)

        given:
        payloadSerializer.deserialize(serializedResult1) >> result1
        payloadSerializer.deserialize(serializedResult2) >> result2

        when:

absl::StatusOr<std::string> ConvertSerializedStableHloModuleToBfloat16(
    const StringRef serialized_stablehlo_module) {
  // StableHLO module is empty often because the XlaCallModuleOp is already
  // deserialized, e.g. after invoking XlaCallModuleDeserializationPass. We
  // don't handle this situation.
  if (serialized_stablehlo_module.empty()) {
    return absl::InvalidArgumentError("StableHLO module is empty.");
  }

	}

	// Add one more.
	if !replaced {
		keys = append(keys, []byte(key))
		vals = append(vals, value)
		plSize += len(key) + len(value) + msgp.StringPrefixSize + msgp.ArrayHeaderSize
	}

	// Reserialize...
	x.serialize(plSize, keys, vals)
}

// rename will rename a key.
// Returns whether the key was found.
func (x *xlMetaInlineData) rename(oldKey, newKey string) bool {
	in := x.afterVersion()

        def method = String.class.getMethod("substring", Integer.TYPE, Integer.TYPE)
        def invocation = new MethodInvocation(method, [1, 2] as Object[])

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

        then:
        result.method == method
        result.arguments == [1, 2] as Object[]
    }

    interface Thing {
        String doStuff(Thing[] things)
    }

  }

  public void testEqualsAndHashCode() {
    new EqualsTester()
        .addEqualityGroup(Optional.absent(), reserialize(Optional.absent()))
        .addEqualityGroup(Optional.of(Long.valueOf(5)), reserialize(Optional.of(Long.valueOf(5))))
        .addEqualityGroup(Optional.of(Long.valueOf(42)), reserialize(Optional.of(Long.valueOf(42))))
        .testEquals();
  }

  public void testToString_absent() {

    return proxyClass.isInstance(arg)
        // Equal proxy instances should mostly be instance of proxyClass
        // Under some edge cases (such as the proxy of JDK types serialized and then deserialized)
        // the proxy type may not be the same.
        // We first check isProxyClass() so that the common case of comparing with non-proxy objects
        // is efficient.