From db71a082d501be5bace4af53c536e9ee8f3d17e3 Mon Sep 17 00:00:00 2001 From: fabriziopandini Date: Thu, 25 Jul 2024 11:33:47 +0200 Subject: [PATCH] test api serialization --- .../topologymutation/serialization_test.go | 47 ++ util/api/serialization_tester.go | 794 ++++++++++++++++++ 2 files changed, 841 insertions(+) create mode 100644 test/extension/handlers/topologymutation/serialization_test.go create mode 100644 util/api/serialization_tester.go diff --git a/test/extension/handlers/topologymutation/serialization_test.go b/test/extension/handlers/topologymutation/serialization_test.go new file mode 100644 index 000000000000..949789149c48 --- /dev/null +++ b/test/extension/handlers/topologymutation/serialization_test.go @@ -0,0 +1,47 @@ +/* +Copyright 2022 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package topologymutation + +import ( + "testing" + + . "github.com/onsi/gomega" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + + infrav1 "sigs.k8s.io/cluster-api/test/infrastructure/docker/api/v1beta1" + apiquality "sigs.k8s.io/cluster-api/util/api" +) + +func TestSerialization(t *testing.T) { + g := NewWithT(t) + + var apiType runtime.Object = &infrav1.DockerClusterTemplate{ + TypeMeta: metav1.TypeMeta{ + Kind: "DockerClusterTemplate", + APIVersion: infrav1.GroupVersion.String(), + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "test-serialization", + }, + } + + err := apiquality.NewSerializationTester(). + FillAndTest(testScheme, apiType, "../../../infrastructure/docker/config/crd/bases/infrastructure.cluster.x-k8s.io_dockerclustertemplates.yaml") + + g.Expect(err).ToNot(HaveOccurred()) +} diff --git a/util/api/serialization_tester.go b/util/api/serialization_tester.go new file mode 100644 index 000000000000..a18147b11dd7 --- /dev/null +++ b/util/api/serialization_tester.go @@ -0,0 +1,794 @@ +/* +Copyright 2022 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Package api provides utils to ensure quality of APIs. +package api + +import ( + "encoding/json" + "fmt" + "os" + "reflect" + "slices" + "sort" + "strings" + + "github.com/pkg/errors" + "gomodules.xyz/jsonpatch/v2" + apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/runtime/serializer" + kerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/validation/field" + "k8s.io/utils/set" +) + +// SerializationTester provides the ability to test API types for inconsistencies between what the API server +// accepts, which is based on generated CRD schemas, and Marshal/Unmarshal of the corresponding golang types. +// Ensuring consistency between this two dimensions of our API (CRD and golang types) is key for +// use cases when it is required to make assumptions on what diff exists between an object being computed in a +// controller and the same object stored in the API server, like e.g the topology controller and RuntimeExtensions. +type SerializationTester struct { + customFillFuncs map[string]any + acknowledgedErrors map[string]string + + decoder runtime.Decoder + + testObj runtime.Object + u map[string]interface{} + n int + + cache set.Set[string] +} + +// NewSerializationTester returns a new SerializationTester. +func NewSerializationTester() *SerializationTester { + return &SerializationTester{} +} + +// WithCustomFillFunctions allows to set custom fill functions to be used by the SerializationTester. +func (w *SerializationTester) WithCustomFillFunctions(fns map[string]any) *SerializationTester { + return &SerializationTester{ + customFillFuncs: fns, + } +} + +// AcknowledgedErrors allows to set errors to be acknowledged by the SerializationTester. +func (w *SerializationTester) AcknowledgedErrors(fns map[string]string) *SerializationTester { + return &SerializationTester{ + acknowledgedErrors: fns, + } +} + +// FillAndTest an object incrementally (taking into account required fields), and runs serialization tests at every step. +func (w *SerializationTester) FillAndTest(scheme *runtime.Scheme, obj runtime.Object, crdPath string) error { + // Create a copy of the object to be used as the openAPISchema used to drive filling the object json/yaml. + w.testObj = obj.DeepCopyObject() + + gvks, _, _ := scheme.ObjectKinds(w.testObj) + if len(gvks) != 1 { + return errors.New("failed to get a unique gvk for the object") + } + + // Read the CRD, check it matches with the obj kind & version, and get the open API openAPISchema for the object. + w.decoder = serializer.NewCodecFactory(scheme).UniversalDecoder(gvks[0].GroupVersion()) + + crdBytes, err := os.ReadFile(crdPath) //nolint:gosec + if err != nil { + return errors.Wrap(err, "failed to read crd") + } + + crd := &apiextensionsv1.CustomResourceDefinition{} + _, _, err = w.decoder.Decode(crdBytes, nil, crd) + if err != nil { + return errors.Wrap(err, "failed to decode crd") + } + + if !strings.EqualFold(crd.Spec.Names.Singular, gvks[0].Kind) { + return errors.New("crd.Spec.Names.Singular does not match obj Kind") + } + + var openAPISchema *apiextensionsv1.JSONSchemaProps + for _, version := range crd.Spec.Versions { + if version.Name == gvks[0].Version { + openAPISchema = version.Schema.OpenAPIV3Schema + break + } + } + + if openAPISchema == nil { + return errors.Errorf("crd does not have version %s", w.testObj.GetObjectKind().GroupVersionKind().String()) + } + + // Start testing from the object itself, which is the root of the tree of fields that + // is going to be filled. + // NOTE: The object at this stage will be empty (except for TypeMeta and ObjectMeta, if added). + + errs := []error{} + root := w.newRootField(w.testObj, gvks[0], openAPISchema) + ctx := withField(nil, root) + w.n++ + rootCtx := withTestCase(ctx, w.n, "%s without spec", root.Path()) + if err := w.doTest(rootCtx); err != nil { + errs = append(errs, err) + } + + // The test will focus on the spec field only, and the goes recursively through all the spec's nested fields. + spec := root.FieldByName("spec") + ctx = withField(ctx, spec) + if err := w.doFill(ctx); err != nil { + errs = append(errs, err) + } + + return kerrors.NewAggregate(errs) +} + +func (w *SerializationTester) newRootField(obj runtime.Object, gvk schema.GroupVersionKind, openAPISchema *apiextensionsv1.JSONSchemaProps) *apiField { + w.u, _ = runtime.DefaultUnstructuredConverter.ToUnstructured(obj) + + delete(w.u, "spec") + delete(w.u, "status") + + return &apiField{ + path: field.NewPath(gvk.Kind), + openAPISchemaPath: field.NewPath(gvk.Kind), + openAPISchema: openAPISchema, + uGetter: func() any { + return w.u + }, + } +} + +const ( + apiTypeBoolean = "boolean" + apiTypeString = "string" + apiTypeInteger = "integer" + apiTypeArray = "array" + apiTypeObject = "object" +) + +func (w *SerializationTester) doFill(ctx serializationTestContext) error { + field := ctx.Field() + ctx = withMessage(ctx, "fill %s value: %s", field.Path(), field.Value()) + + // If there is a custom field filler for this field, use it to set the field, and then run the test. + if w.tryCustom(field) { + w.n++ + ctx := withTestCase(ctx, w.n, "test: %s set with custom fill function", field.Path()) + return w.doTest(ctx) + } + + errs := []error{} + + switch field.Type() { + case apiTypeBoolean: + if field.Value() == nil { + if field.isRequired { + field.SetValue(false) + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to false", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } else { + ctx = withMessage(ctx, "fill: %s not set to false because it is isRequired", field.Path()) + } + } + field.SetValue(true) + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to true", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + case apiTypeString: + if field.Value() == nil { + if field.isRequired { + field.SetValue("") + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to \"\"", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } else { + ctx = withMessage(ctx, "fill: %s not set to \"\" because it is isRequired", field.Path()) + } + } + field.SetValue("foo") + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to \"foo\"", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + case apiTypeInteger: + if field.Value() == nil && field.isRequired { + if field.isRequired { + field.SetValue(0) + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to 0", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } else { + ctx = withMessage(ctx, "fill: %s not set to 0 because it is isRequired", field.Path()) + } + } + field.SetValue(123) + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set with 123", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + case apiTypeArray: + // If the array is still nit, initialize it before staring adding items + // Also, run a test case with the empty array. + if field.Value() == nil { + field.SetValue(make([]any, 0)) + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to empty slice", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } + + // Then add one item at time to the slide and fill it. + n := 2 + for i := range n { + itemField := field.Index(i) + + itemCtx := withField(ctx, itemField) + if err := w.doFill(itemCtx); err != nil { + errs = append(errs, err) + } + } + case apiTypeObject: + // Default value for fields of type struct is tested at the beginning of this func. + + // If the object has isRequired fields, they must be set (API server do not accept a yaml without them) + // in case this operation changes the object, run a test. + var isChanged bool + ctx, isChanged = w.setRequiredFields(ctx, field) + if isChanged { + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set with required fields", field.Path()) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } + + // If after adding isRequired fields the object is still nit, initialize it before staring adding fields + // Also, run a test case with the empty object. + if field.Value() == nil { + w.n++ + ctx := withTestCase(ctx, w.n, "fill: %s set to empty struct", field.Path()) + field.SetValue(map[string]any{}) + if err := w.doTest(ctx); err != nil { + errs = append(errs, err) + } + } + + // Then add fields one by one and fill them too. + for i := range field.NumField() { + structField := field.Field(i) + structCtx := withField(ctx, structField) + if err := w.doFill(structCtx); err != nil { + errs = append(errs, err) + } + + // After filling one field / testing all its permutation, clean it up so we keep the yaml surface as small as possible. + structField.UnsetSetValue() + if structField.IsRequired() { + w.setRequiredFields(structCtx, structField) + } + } + + if field.IsMap() { + n := 2 + for i := range n { + key := fmt.Sprintf("key%d", i) + elemField := field.Key(key) + + elemCtx := withField(ctx, elemField) + if err := w.doFill(elemCtx); err != nil { + errs = append(errs, err) + } + } + } + default: + panic(fmt.Sprintf("dofill for type %s is not implemented yet", field.Type())) + } + + return kerrors.NewAggregate(errs) +} + +func (w *SerializationTester) setRequiredFields(ctx serializationTestContext, field *apiField) (serializationTestContext, bool) { + valueBeforeFillRequired := field.Value() + + if w.tryCustom(field) { + ctx = withMessage(ctx, "field %s set with custom fill function (required field)", field.Path()) + return ctx, !reflect.DeepEqual(field.Value(), valueBeforeFillRequired) + } + + switch field.Type() { + case apiTypeString: + if field.Value() == nil { + ctx = withMessage(ctx, "field %s set to \"\" (required field)", field.Path()) + field.SetValue("") + } + case apiTypeInteger: + if field.Value() == nil { + ctx = withMessage(ctx, "field %s set to 0 (required field)", field.Path()) + field.SetValue(0) + } + case apiTypeObject: + requiredFieldNames := field.RequiredFieldNames() + + if (field.Value() == nil || field.Value().(map[string]any) == nil) && len(requiredFieldNames) > 0 { + ctx = withMessage(ctx, "field %s initialized to host nested required fields (%s)", field.Path(), strings.Join(requiredFieldNames, ",")) + field.SetValue(map[string]any{}) + } + if (field.Value() == nil || field.Value().(map[string]any) == nil) && field.isRequired { + ctx = withMessage(ctx, "field %s set to empty object (required field)", field.Path()) + field.SetValue(map[string]any{}) + } + for i := range field.NumField() { + structField := field.Field(i) + if structField.isRequired { + ctx, _ = w.setRequiredFields(ctx, structField) + } + } + default: + panic(fmt.Sprintf("setRequiredFields for type %s is not implemented yet", field.Type())) + } + + return ctx, !reflect.DeepEqual(field.Value(), valueBeforeFillRequired) +} + +func (w *SerializationTester) tryCustom(field *apiField) bool { + if v, ok := w.customFillFuncs[field.openAPISchemaPath.String()]; ok { + field.SetValue(v) + return true + } + return false +} + +func (w *SerializationTester) doTest(ctx serializationTestContext) error { + testNumber, testTitle := ctx.TestCase() + field := ctx.Field() + + fmt.Println("---") + fmt.Printf("TEST #%d: %s\n", testNumber, testTitle) + fmt.Println("Path: ", field.Path()) + fmt.Println("OpenAPISchemaPath: ", field.OpenAPISchemaPath(), " isRequired: ", field.IsRequired()) + for _, m := range ctx.Messages() { + fmt.Println(" - ", m) + } + + fmt.Println() + // Marshal the unstructured object to json (called original like the input object for the walker in the topology mutation hook) + jsonOriginal, err := json.Marshal(w.u) + if err != nil { + panic(err) + } + fmt.Println("Test: ", string(jsonOriginal)) + + // If the generated json has been already tested, exit. + if w.cache == nil { + w.cache = set.New[string]() + } + if w.cache.Has(string(jsonOriginal)) { + fmt.Println("already tested") + return nil + } + w.cache.Insert(string(jsonOriginal)) + + // Otherwise run the test + + // Decode the json into an object (called modified like the object to which the walker in the topology mutation hook applies patches) + modified := w.testObj.DeepCopyObject() + modified, _, err = w.decoder.Decode(jsonOriginal, nil, modified) + if err != nil { + panic(err) + } + + // Compute the patch to align original and modified, there should be no patch operations because we are not applying patches. + // If there are patch operations, it means that the API type in go applies some defaults different to json's defaults. + + jsonModified, err := json.Marshal(modified) + if err != nil { + panic(err) + } + + patch, err := jsonpatch.CreatePatch(jsonOriginal, jsonModified) + if err != nil { + panic(err) + } + + patchBytes, err := json.Marshal(patch) + if err != nil { + panic(err) + } + fmt.Println("Diff: ", string(patchBytes)) + fmt.Println() + if len(patchBytes) > 2 { + if acknowledgedDiff := w.acknowledgedErrors[testTitle]; acknowledgedDiff == string(patchBytes) { + fmt.Println("diff acknowledged") + return nil + } + return errors.Errorf("TEST #%d %s is generating a diff: %s", testNumber, testTitle, string(patchBytes)) + } + + return nil +} + +type apiField struct { + path *field.Path + openAPISchemaPath *field.Path + openAPISchema *apiextensionsv1.JSONSchemaProps + isRequired bool + // value any + + uGetter func() any + uSetter func(v any) + uUnSetter func() +} + +func (f *apiField) Name() string { + if i := strings.LastIndex(f.openAPISchemaPath.String(), "."); i > 0 { + return f.openAPISchemaPath.String()[i+1:] + } + return f.openAPISchemaPath.String() +} + +func (f *apiField) Type() string { + return f.openAPISchema.Type +} + +func (f *apiField) Path() *field.Path { + return f.path +} + +func (f *apiField) OpenAPISchemaPath() *field.Path { + return f.openAPISchemaPath +} + +func (f *apiField) Value() any { + if f.uGetter == nil { + panic("uGetter function is not defined!") + } + return f.uGetter() +} + +func (f *apiField) NumField() int { + return len(f.openAPISchema.Properties) +} + +func (f *apiField) IsRequired() bool { + return f.isRequired +} + +func (f *apiField) RequiredFieldNames() []string { + return f.openAPISchema.Required +} + +func (f *apiField) IsMap() bool { + return f.openAPISchema.AdditionalProperties != nil +} + +func (f *apiField) SetValue(v any) { + if f.uSetter == nil { + panic("uSetter function is not defined!") + } + // f.value = v + f.uSetter(v) +} + +func (f *apiField) UnsetSetValue() { + if f.uUnSetter == nil { + panic("uUnSetter function is not defined!") + } + // f.value = nil + f.uUnSetter() +} + +// Field returns a struct type's i'th field. +func (f *apiField) Field(i int) *apiField { + names := make([]string, 0, len(f.openAPISchema.Properties)) + for k := range f.openAPISchema.Properties { + names = append(names, k) + } + sort.Strings(names) + return f.FieldByName(names[i]) +} + +// FieldByName returns the struct field with the given name. +func (f *apiField) FieldByName(name string) *apiField { + if f.Type() != apiTypeObject { + panic(fmt.Sprintf("field %s is not an object!", f.Name())) + } + fi := &apiField{ + path: f.path.Child(name), + openAPISchemaPath: f.openAPISchemaPath.Child(name), + openAPISchema: func() *apiextensionsv1.JSONSchemaProps { + // Get the open API openAPISchema for the field + for n, p := range f.openAPISchema.Properties { + if n == name { + return &p + } + } + panic("cannot find openapi definition for field " + name) + }(), + isRequired: func() bool { + // Get the isRequired setting for the field + for _, p := range f.openAPISchema.Required { + if p == name { + return true + } + } + return false + }(), + // Func to get the field value from u + uGetter: func() any { + structValue, ok := f.Value().(map[string]any) + if !ok { + return nil + } + if structValue == nil { + return nil + } + return structValue[name] + }, + // Func to set the field value back in u (the root value) + uSetter: func(v any) { + structValue, ok := f.Value().(map[string]any) + if !ok { + panic(fmt.Sprintf("fieldValue for field %s is not a map[string]any!", f.Name())) + } + if structValue == nil { + structValue = make(map[string]any) + } + structValue[name] = v + }, + // Func to unset the field value back in u (the root value) + uUnSetter: func() { + structValue, ok := f.Value().(map[string]any) + if !ok { + panic(fmt.Sprintf("fieldValue for field %s is not a map[string]any!", f.Name())) + } + delete(structValue, name) + }, + } + + return fi +} + +// Index returns v's i'th element. +func (f *apiField) Index(i int) *apiField { + if f.Type() != apiTypeArray { + panic(fmt.Sprintf("field %s is not an array!", f.Name())) + } + fi := &apiField{ + path: f.path.Index(i), + openAPISchemaPath: f.openAPISchemaPath, + openAPISchema: func() *apiextensionsv1.JSONSchemaProps { + // In open API there the openAPISchema of an item of an array is defined in Items.Schema of the array object itself. + return f.openAPISchema.Items.Schema + }(), + isRequired: func() bool { + // When we get the item in a array, it should be considered isRequired. + return true + }(), + // Func to get the field value from u + uGetter: func() any { + array, ok := f.Value().([]any) + if !ok { + return nil + } + if len(array) < i+1 { + return nil + } + return array[i] + }, + // Func to set the field value back in u (the root value) + uSetter: func(v any) { + array, ok := f.Value().([]any) + if !ok { + panic(fmt.Sprintf("fieldValue for field %s is not a []any!", f.Name())) + } + + // Extend the array if necessary + missingItems := i + 1 - len(array) + for range missingItems { + array = append(array, nil) + } + array[i] = v + + f.SetValue(array) + }, + } + + return fi +} + +// Key returns key's element. +func (f *apiField) Key(key string) *apiField { + if f.Type() != apiTypeObject && !f.IsMap() { + panic(fmt.Sprintf("field %s is not a map!", f.Name())) + } + fi := &apiField{ + path: f.path.Key(key), + openAPISchemaPath: f.openAPISchemaPath, + openAPISchema: func() *apiextensionsv1.JSONSchemaProps { + // In open API there the openAPISchema of an element of a map is the AdditionalProperties in the openAPISchema of the map object itself. + return f.openAPISchema.AdditionalProperties.Schema + }(), + isRequired: func() bool { + // When we get the elem in a map, it should be considered isRequired. + return true + }(), + // Func to get the field value from u + uGetter: func() any { + structValue, ok := f.Value().(map[string]any) + if !ok { + return nil + } + if structValue == nil { + return nil + } + return structValue[key] + }, + // Func to set the field value back in u (the root value) + uSetter: func(v any) { + structValue, ok := f.Value().(map[string]any) + if !ok { + panic(fmt.Sprintf("fieldValue for field %s is not a map[string]any!", f.Name())) + } + structValue[key] = v + }, + } + + return fi +} + +type serializationTestContext interface { + Field() *apiField + Messages() []string + TestCase() (int, string) +} + +type fieldCtx struct { + serializationTestContext + field *apiField +} + +func withField(parent serializationTestContext, field *apiField) serializationTestContext { + return &fieldCtx{ + serializationTestContext: parent, + field: field, + } +} + +func (c *fieldCtx) Field() *apiField { + return getField(c) +} + +func (c *fieldCtx) Messages() []string { + return messages(c) +} + +func (c *fieldCtx) TestCase() (int, string) { + return testCase(c) +} + +type msgCtx struct { + serializationTestContext + message string +} + +func withMessage(parent serializationTestContext, format string, a ...any) serializationTestContext { + return &msgCtx{ + serializationTestContext: parent, + message: fmt.Sprintf(format, a...), + } +} + +func (c *msgCtx) Field() *apiField { + return getField(c) +} + +func (c *msgCtx) Messages() []string { + return messages(c) +} + +func (c *msgCtx) TestCase() (int, string) { + return testCase(c) +} + +type testCaseCtx struct { + serializationTestContext + n int + title string +} + +func withTestCase(parent serializationTestContext, n int, format string, a ...any) serializationTestContext { + return &testCaseCtx{ + serializationTestContext: parent, + n: n, + title: fmt.Sprintf(format, a...), + } +} + +func (c *testCaseCtx) Field() *apiField { + return getField(c) +} + +func (c *testCaseCtx) Messages() []string { + return messages(c) +} + +func (c *testCaseCtx) TestCase() (int, string) { + return testCase(c) +} + +func getField(c serializationTestContext) *apiField { + switch ctx := c.(type) { + case *fieldCtx: + return ctx.field + case *msgCtx: + return getField(ctx.serializationTestContext) + case *testCaseCtx: + return getField(ctx.serializationTestContext) + default: + return nil + } +} + +func messages(c serializationTestContext) []string { + var messages []string + for { + if c == nil { + slices.Reverse(messages) + return messages + } + + switch ctx := c.(type) { + case *fieldCtx: + c = ctx.serializationTestContext + case *msgCtx: + messages = append(messages, ctx.message) + c = ctx.serializationTestContext + case *testCaseCtx: + c = ctx.serializationTestContext + } + } +} + +func testCase(c serializationTestContext) (int, string) { + for { + if c == nil { + return 0, "" + } + + switch ctx := c.(type) { + case *fieldCtx: + c = ctx.serializationTestContext + case *msgCtx: + c = ctx.serializationTestContext + case *testCaseCtx: + return ctx.n, ctx.title + } + } +}