PRUNTIME_FUNCTION FunctionEntry;
		ULONG64 ImageBase;
		VOID *HandlerData;
		ULONG64 EstablisherFrame;

		FunctionEntry = RtlLookupFunctionEntry(ControlPc, &ImageBase, NULL);

		if (!FunctionEntry) {
			// For simplicity, don't unwind leaf entries, which are not used in this test.
			break;
		} else {
			RtlVirtualUnwind(0, ImageBase, ControlPc, FunctionEntry, &context, &HandlerData, &EstablisherFrame, NULL);
		}

## Date

2012-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

{!../../../docs_src/sql_databases/sql_app/tests/test_sql_app.py!}
```

!!! tip
    You could reduce duplication in that code by putting it in a function and using it from both `database.py` and `tests/test_sql_app.py`.

    For simplicity and to focus on the specific testing code, we are just copying it.

## Create the database

Because now we are going to use a new database in a new file, we need to make sure we create the database with:

```Python

package pkgpath

import (
	"internal/testenv"
	"os"
	"testing"
)

const testEnvName = "GO_PKGPATH_TEST_COMPILER"

// This init function supports TestToSymbolFunc. For simplicity,
// we use the test binary itself as a sample gccgo driver.
// We set an environment variable to specify how it should behave.
func init() {
	switch os.Getenv(testEnvName) {
	case "":
		return
	case "v1":

func (c Topology) StableName() string {
	var prefix string
	// If its a known cluster name, use that directly.
	// This will not be dynamic, and allows 1:1 correlation of cluster name and test name for simplicity.
	if _, f := knownClusterNames[c.Name()]; f {
		return c.Name()
	}
	if c.IsPrimary() {
		if c.IsConfig() {
			prefix = "primary"
		} else {
			prefix = "externalistiod"
		}

// if it doesn't exist. This allows users to manage it through other means or modify it as they wish.
// If it is deleted, however, it will be added back.
// This controller intentionally does not do leader election for simplicity. Because we only create
// and not update there is no need; the first controller to create the GatewayClass wins.
type ClassController struct {
	queue   controllers.Queue
	classes kclient.Client[*gateway.GatewayClass]
}

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

/**
 * Since Gradle creates a high volume of progress events, this serializer trades simplicity
 * for the smallest possible serialized form. It uses a single byte indicating the presence of optional
 * fields instead of writing an "absent" byte for each of them like most of our serializers do.

}

// internalCollection is a superset of Collection for internal usage. All collections must implement this type, but
// we only expose some functions to external users for simplicity.
type internalCollection[T any] interface {
	Collection[T]

	// Name is a human facing name for this collection.
	// Note this may not be universally unique
	name() string

// request’s actual service time is known. This is similar, although
// not exactly isomorphic, to the original paper’s adjustment by
// `$\delta$` for the sake of promptness.
//
// For implementation simplicity (see below), let us use the same
// initial service time guess for every request; call that duration
// G. A good choice might be the service time limit (1
// minute). Different guesses will give slightly different dynamics,

	// We don't expect stack trace from the panic to be included in the log.
	if isStackTraceLoggedByRuntime(capturedOutput) {
		t.Errorf("unexpected stack trace in log, actual = %v", capturedOutput)
	}
	// For the sake of simplicity and clarity this matches the full log line.
	// This is not part of the Kubernetes API and could change.