@agoric/cosmos 0.34.2-dev-ecf2d8e.0 → 0.35.0-other-dev-70beeb7.0

package/x/vstorage/capdata/capdata_test.go

@@ -1,352 +0,0 @@
-package capdata
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func ptr[T any](v T) *T {
-	return &v
-}
-
-func mustJsonMarshal(val any) string {
-	jsonText, err := JsonMarshal(val)
-	if err != nil {
-		panic(err)
-	}
-	return string(jsonText)
-}
-
-func mustJsonUnmarshal(jsonText string, ptr any) {
-	if err := json.Unmarshal([]byte(jsonText), ptr); err != nil {
-		panic(err)
-	}
-}
-
-func prefixBigint(bigint *CapdataBigint) interface{} {
-	return fmt.Sprintf("bigint:%s", bigint.Normalized)
-}
-
-func remotableToString(r *CapdataRemotable) interface{} {
-	iface := ""
-	if r.Iface != nil {
-		iface = *r.Iface
-	}
-	return fmt.Sprintf("remotable:%s{%s}", iface, r.Id)
-}
-
-func Test_JsonMarshal(t *testing.T) {
-	type testCase struct {
-		input       string
-		expected    string
-		errContains *string
-	}
-	testCases := []testCase{
-		{
-			input:    "<>&\u2028\u2029",
-			expected: `"<>&\u2028\u2029"`,
-		},
-	}
-	for _, desc := range testCases {
-		label := fmt.Sprintf("%q", desc.input)
-		result, err := JsonMarshal(desc.input)
-		if desc.errContains == nil {
-			if err != nil {
-				t.Errorf("%s: got unexpected error %v", label, err)
-			} else if string(result) != desc.expected {
-				t.Errorf("%s: wrong result: %#q", label, result)
-			}
-		} else if err == nil {
-			t.Errorf("%s: got no error, want error %q", label, *desc.errContains)
-		} else if !strings.Contains(err.Error(), *desc.errContains) {
-			t.Errorf("%s: got error %v, want error %q", label, err, *desc.errContains)
-		}
-	}
-}
-
-func Test_DecodeSerializedCapdata(t *testing.T) {
-	type testCase struct {
-		format          string
-		label           string
-		body            string
-		slots           []interface{}
-		expected        string
-		errContains     *string
-		transformations CapdataValueTransformations
-	}
-	testCases := []testCase{
-		// JSON
-		// cf. https://github.com/endojs/endo/blob/209b612e0a267239f33cd607e94ccd179d3ba248/packages/marshal/test/test-marshal-capdata.js#L11
-		{body: `[1, 2]`},
-		{body: `{ "foo": 1 }`},
-		{body: `{}`},
-		{body: `{ "a": 1, "b": 2 }`},
-		{body: `{ "a": 1, "b": { "c": 3 } }`},
-		{body: `true`},
-		{body: `1`},
-		{body: `"abc"`},
-		{body: `null`},
-
-		// transformation of non-JSON values
-		{format: "smallcaps", label: "bigint",
-			body:            `"+98765432101234567890"`,
-			expected:        `"bigint:98765432101234567890"`,
-			transformations: CapdataValueTransformations{Bigint: prefixBigint},
-		},
-		{format: "legacy", label: "bigint",
-			body:            `{ "@qclass": "bigint", "digits": "98765432101234567890" }`,
-			expected:        `"bigint:98765432101234567890"`,
-			transformations: CapdataValueTransformations{Bigint: prefixBigint},
-		},
-		{format: "smallcaps", label: "remotables",
-			body:            `["$0.Foo", "$0"]`,
-			slots:           []interface{}{"a"},
-			expected:        `["remotable:Foo{a}","remotable:Foo{a}"]`,
-			transformations: CapdataValueTransformations{Remotable: remotableToString},
-		},
-		{format: "legacy", label: "remotables",
-			body:            `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0}]`,
-			slots:           []interface{}{"a"},
-			expected:        `["remotable:Foo{a}","remotable:Foo{a}"]`,
-			transformations: CapdataValueTransformations{Remotable: remotableToString},
-		},
-		{format: "smallcaps", label: "escaped string",
-			body:     `"!#escaped"`,
-			expected: `"#escaped"`,
-		},
-
-		// unimplemented
-		{format: "smallcaps",
-			body:        `"#undefined"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "undefined",
-			body:        `{"@qclass":"undefined"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#NaN"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "NaN",
-			body:        `{"@qclass":"NaN"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#Infinity"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "Infinity",
-			body:        `{"@qclass":"Infinity"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps",
-			body:        `"#-Infinity"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "-Infinity",
-			body:        `{"@qclass":"-Infinity"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "symbol",
-			body:        `"%foo"`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "symbol",
-			body:        `{"@qclass":"symbol"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "tagged",
-			body:        `{"#tag":"foo","payload":"bar"}`,
-			errContains: ptr("not implemented: #tag"),
-		},
-		{format: "legacy", label: "tagged",
-			body:        `{"@qclass":"tagged","tag":"foo","payload":"bar"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "error",
-			body:        `{"#error":"","name":"Error"}`,
-			errContains: ptr("not implemented: #error"),
-		},
-		{format: "legacy", label: "error",
-			body:        `{"@qclass":"error","message":"foo","name":"bar"}`,
-			errContains: ptr("not implemented"),
-		},
-		{format: "smallcaps", label: "promise",
-			body:        `"&0"`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("not implemented"),
-		},
-		{format: "legacy", label: "error",
-			body:        `{"@qclass":"hilbert","original":"foo"}`,
-			errContains: ptr("not implemented"),
-		},
-
-		// missing transformations
-		{format: "smallcaps", label: "untransformed bigint",
-			body:        `"+98765432101234567890"`,
-			errContains: ptr("untransformed bigint"),
-		},
-		{format: "legacy", label: "untransformed bigint",
-			body:        `{ "@qclass": "bigint", "digits": "98765432101234567890" }`,
-			errContains: ptr("untransformed bigint"),
-		},
-		{format: "smallcaps", label: "untransformed remotable",
-			body:        `["$0.Foo", "$0"]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("untransformed remotable"),
-		},
-		{format: "legacy", label: "untransformed remotable",
-			body:        `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0}]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("untransformed remotable"),
-		},
-
-		// invalid data
-		{format: "smallcaps", label: "iface mismatch",
-			body:        `["$0.Foo", "$0."]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("iface mismatch"),
-		},
-		{format: "legacy", label: "iface mismatch",
-			body:        `[{"@qclass":"slot","index":0,"iface":"Foo"}, {"@qclass":"slot","index":0,"iface":""}]`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("iface mismatch"),
-		},
-		{format: "smallcaps", label: "invalid slot index (out of bounds)",
-			body:        `"$0.Foo"`,
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (out of bounds)",
-			body:        `{"@qclass":"slot","index":0}`,
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "smallcaps", label: "invalid slot index (bad format)",
-			body:        `"$x.Foo"`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (missing)",
-			body:        `{"@qclass":"slot"}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (null)",
-			body:        `{"@qclass":"slot","index":null}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (string)",
-			body:        `{"@qclass":"slot","index":"0"}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (non-integer)",
-			body:        `{"@qclass":"slot","index":0.1}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot index (negative)",
-			body:        `{"@qclass":"slot","index":-1}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot index"),
-		},
-		{format: "legacy", label: "invalid slot iface (number)",
-			body:        `{"@qclass":"slot","index":0,"iface":0}`,
-			slots:       []interface{}{"a"},
-			errContains: ptr("invalid slot iface"),
-		},
-		{format: "smallcaps", label: "unrecognized record type",
-			body:        `{"#foo":0}`,
-			errContains: ptr("unrecognized record type"),
-		},
-		{format: "legacy", label: "invalid @qclass (null)",
-			body:        `{"@qclass":null}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "invalid @qclass (number)",
-			body:        `{"@qclass":1}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "invalid @qclass (number)",
-			body:        `{"@qclass":1}`,
-			errContains: ptr("invalid @qclass"),
-		},
-		{format: "legacy", label: "unrecognized @qclass",
-			body:        `{"@qclass":"foo"}`,
-			errContains: ptr("unrecognized @qclass"),
-		},
-		{format: "smallcaps", label: "invalid copyRecord key",
-			body:        `{"+0":0}`,
-			errContains: ptr("invalid copyRecord key"),
-		},
-		{format: "smallcaps", label: "invalid bigint (`--`)",
-			body:        `"--"`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "smallcaps", label: "invalid bigint (`+0x`)",
-			body:        `"+0x"`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (no digits)",
-			body:        `{"@qclass":"bigint"}`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (null digits)",
-			body:        `{"@qclass":"bigint","digits":null}`,
-			errContains: ptr("invalid bigint"),
-		},
-		{format: "legacy", label: "invalid bigint (`7up`)",
-			body:        `{"@qclass":"bigint","digits":"7up"}`,
-			errContains: ptr("invalid bigint"),
-		},
-	}
-
-	for _, desc := range testCases {
-		slots := desc.slots
-		if slots == nil {
-			slots = []interface{}{}
-		}
-		var expected interface{}
-		if desc.expected != "" {
-			mustJsonUnmarshal(desc.expected, &expected)
-		} else {
-			mustJsonUnmarshal(desc.body, &expected)
-		}
-		for _, format := range []string{"smallcaps", "legacy"} {
-			if desc.format != "" && desc.format != format {
-				continue
-			}
-			label := fmt.Sprintf("%s %s", format, desc.label)
-			if desc.label == "" {
-				label = fmt.Sprintf("%s %s", format, desc.body)
-			}
-			capdata := Capdata{desc.body, slots}
-			if format == "smallcaps" {
-				capdata.Body = "#" + capdata.Body
-			}
-			intermediate, err := DecodeSerializedCapdata(mustJsonMarshal(capdata), desc.transformations)
-			// Replace each Remotable with its representation before comparing.
-			var got interface{}
-			mustJsonUnmarshal(mustJsonMarshal(intermediate), &got)
-			if desc.errContains == nil {
-				if err != nil {
-					t.Errorf("%s: got unexpected error %v", label, err)
-				} else if !reflect.DeepEqual(got, expected) {
-					result, err := JsonMarshal(got)
-					if err != nil {
-						panic(fmt.Errorf("%s: %v", label, err))
-					}
-					t.Errorf("%s: wrong result: %s", label, result)
-				}
-			} else if err == nil {
-				t.Errorf("%s: got no error, want error %q", label, *desc.errContains)
-			} else if !strings.Contains(err.Error(), *desc.errContains) {
-				t.Errorf("%s: got error %v, want error %q", label, err, *desc.errContains)
-			}
-		}
-	}
-}

package/x/vstorage/keeper/keeper_grpc_test.go

@@ -1,300 +0,0 @@
-package keeper
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-
-	grpcCodes "google.golang.org/grpc/codes"
-	grpcStatus "google.golang.org/grpc/status"
-
-	agoric "github.com/Agoric/agoric-sdk/golang/cosmos/types"
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/capdata"
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/types"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-func ptr[T any](v T) *T {
-	return &v
-}
-
-func mustJsonMarshal(val any) string {
-	jsonText, err := capdata.JsonMarshal(val)
-	if err != nil {
-		panic(err)
-	}
-	return string(jsonText)
-}
-
-func mustMarshalStreamCell(blockHeight string, values []string) string {
-	cell := map[string]any{
-		"blockHeight": blockHeight,
-		"values":      values,
-	}
-	return mustJsonMarshal(cell)
-}
-
-func TestCapData(t *testing.T) {
-	testKit := makeTestKit()
-	ctx, keeper := testKit.ctx, testKit.vstorageKeeper
-	querier := Querier{keeper}
-
-	type testCase struct {
-		label       string
-		data        *string
-		request     types.QueryCapDataRequest
-		expected    types.QueryCapDataResponse
-		errCode     grpcCodes.Code
-		errContains *string
-	}
-	testCases := []testCase{}
-
-	// Test simple cases (various kinds of bad data up to simple flat JSON-compatible CapData).
-	decodableSmallcaps := `{"body":"#true","slots":[]}`
-	decodableLegacy := `{"body":"true","slots":[]}`
-	testCases = append(testCases, []testCase{
-		{label: "no data",
-			data:        nil,
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("no data"),
-		},
-		{label: "zero-length data",
-			data:        ptr(""),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("JSON"),
-		},
-		{label: "cell with empty string",
-			data:        ptr(mustMarshalStreamCell("1", []string{decodableSmallcaps, "", decodableLegacy})),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("JSON"),
-		},
-		{label: "non-JSON data",
-			data:        ptr("foo"),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("invalid"),
-		},
-		{label: "cell with non-JSON",
-			data:        ptr(mustMarshalStreamCell("1", []string{decodableSmallcaps, "foo", decodableLegacy})),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("invalid"),
-		},
-		{label: "lone non-CapData",
-			data:        ptr("{}"),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("invalid CapData"),
-		},
-		{label: "cell with non-CapData",
-			data:        ptr(mustMarshalStreamCell("1", []string{decodableSmallcaps, "{}", decodableLegacy})),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("invalid CapData"),
-		},
-		{label: "lone smallcaps CapData",
-			data:     ptr(decodableSmallcaps),
-			request:  types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			expected: types.QueryCapDataResponse{Value: `true`},
-		},
-		{label: "cell with smallcaps CapData",
-			data:     ptr(mustMarshalStreamCell("1", []string{decodableSmallcaps})),
-			request:  types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			expected: types.QueryCapDataResponse{BlockHeight: "1", Value: `true`},
-		},
-		{label: "lone legacy CapData",
-			data:     ptr(decodableLegacy),
-			request:  types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			expected: types.QueryCapDataResponse{Value: `true`},
-		},
-		{label: "cell with legacy CapData",
-			data:     ptr(mustMarshalStreamCell("1", []string{decodableLegacy})),
-			request:  types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			expected: types.QueryCapDataResponse{BlockHeight: "1", Value: `true`},
-		},
-	}...)
-
-	// Test option validation.
-	testCases = append(testCases, []testCase{
-		{label: "explicit JSON Lines",
-			data:     ptr(decodableSmallcaps),
-			request:  types.QueryCapDataRequest{MediaType: "JSON Lines", RemotableValueFormat: "string"},
-			expected: types.QueryCapDataResponse{Value: `true`},
-		},
-		{label: "invalid media type",
-			data:        ptr(decodableSmallcaps),
-			request:     types.QueryCapDataRequest{MediaType: "JSONLines", RemotableValueFormat: "string"},
-			errCode:     grpcCodes.InvalidArgument,
-			errContains: ptr("media_type"),
-		},
-		{label: "invalid item format",
-			data:        ptr(decodableSmallcaps),
-			request:     types.QueryCapDataRequest{ItemFormat: "deep", RemotableValueFormat: "string"},
-			errCode:     grpcCodes.InvalidArgument,
-			errContains: ptr("item_format"),
-		},
-		{label: "missing remotable value format",
-			data:        ptr(decodableSmallcaps),
-			request:     types.QueryCapDataRequest{},
-			errCode:     grpcCodes.InvalidArgument,
-			errContains: ptr("remotable_value_format"),
-		},
-		{label: "invalid remotable value format",
-			data:        ptr(decodableSmallcaps),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "foo"},
-			errCode:     grpcCodes.InvalidArgument,
-			errContains: ptr("remotable_value_format"),
-		},
-	}...)
-
-	// Test formatting options against sufficiently complex CapData,
-	// deriving legacy encoding from smallcaps encoding to ensure equivalence
-	// and deriving expectations from marshalling to avoid spurious mismatches
-	// from Go's unpredictable field ordering (e.g., `{"a":0,"b":1}` vs. `{"b":1,"a":0}`).
-	slots := []any{"a"}
-	deepSmallcapsBody := `{"arr":[{"bigint":"+42","remotable":"$0.Alleged: Foo brand","ref2":"$0"}]}`
-	deepLegacyBody := deepSmallcapsBody
-	legacyFromSmallcaps := [][2]string{
-		[2]string{`"+42"`, `{"@qclass":"bigint","digits":"42"}`},
-		[2]string{`"$0.Alleged: Foo brand"`, `{"@qclass":"slot","index":0,"iface":"Alleged: Foo brand"}`},
-		[2]string{`"$0"`, `{"@qclass":"slot","index":0}`},
-	}
-	for _, pair := range legacyFromSmallcaps {
-		deepLegacyBody = strings.Replace(deepLegacyBody, pair[0], pair[1], -1)
-	}
-	cell := mustMarshalStreamCell("1", []string{
-		mustJsonMarshal(map[string]any{"body": "#" + deepSmallcapsBody, "slots": slots}),
-		mustJsonMarshal(map[string]any{"body": deepLegacyBody, "slots": slots}),
-	})
-	mustMarshalTwoLines := func(val any) string {
-		line := mustJsonMarshal(val)
-		return fmt.Sprintf("%s\n%s", line, line)
-	}
-	testCases = append(testCases, testCase{label: "remotables as strings",
-		data:    ptr(cell),
-		request: types.QueryCapDataRequest{RemotableValueFormat: "string"},
-		expected: types.QueryCapDataResponse{
-			BlockHeight: "1",
-			Value: mustMarshalTwoLines(map[string]any{
-				"arr": []any{
-					map[string]any{
-						"bigint":    "42",
-						"remotable": "[Alleged: Foo brand <a>]",
-						"ref2":      "[Alleged: Foo brand <a>]",
-					},
-				},
-			}),
-		},
-	})
-	testCases = append(testCases, testCase{label: "remotables as strings, flat",
-		data:    ptr(cell),
-		request: types.QueryCapDataRequest{ItemFormat: "flat", RemotableValueFormat: "string"},
-		expected: types.QueryCapDataResponse{
-			BlockHeight: "1",
-			Value: mustMarshalTwoLines(map[string]any{
-				"arr-0-bigint":    "42",
-				"arr-0-remotable": "[Alleged: Foo brand <a>]",
-				"arr-0-ref2":      "[Alleged: Foo brand <a>]",
-			}),
-		},
-	})
-	testCases = append(testCases, testCase{label: "remotables as objects",
-		data:    ptr(cell),
-		request: types.QueryCapDataRequest{RemotableValueFormat: "object"},
-		expected: types.QueryCapDataResponse{
-			BlockHeight: "1",
-			Value: mustMarshalTwoLines(map[string]any{
-				"arr": []any{
-					map[string]any{
-						"bigint":    "42",
-						"remotable": map[string]any{"id": "a", "allegedName": "Foo brand"},
-						"ref2":      map[string]any{"id": "a", "allegedName": "Foo brand"},
-					},
-				},
-			}),
-		},
-	})
-	testCases = append(testCases, testCase{label: "remotables as objects, flat",
-		data:    ptr(cell),
-		request: types.QueryCapDataRequest{ItemFormat: "flat", RemotableValueFormat: "object"},
-		expected: types.QueryCapDataResponse{
-			BlockHeight: "1",
-			Value: mustMarshalTwoLines(map[string]any{
-				"arr-0-bigint":                "42",
-				"arr-0-remotable-id":          "a",
-				"arr-0-remotable-allegedName": "Foo brand",
-				"arr-0-ref2-id":               "a",
-				"arr-0-ref2-allegedName":      "Foo brand",
-			}),
-		},
-	})
-
-	// Test errors from CapData that includes unsupported values.
-	expectNotImplemented := func(label, capdataBody string, slots []any) testCase {
-		if slots == nil {
-			slots = []any{}
-		}
-		serialized := mustJsonMarshal(map[string]any{
-			"body":  capdataBody,
-			"slots": slots,
-		})
-		return testCase{
-			label:       label,
-			data:        ptr(serialized),
-			request:     types.QueryCapDataRequest{RemotableValueFormat: "string"},
-			errCode:     grpcCodes.FailedPrecondition,
-			errContains: ptr("not implemented"),
-		}
-	}
-	testCases = append(testCases, []testCase{
-		expectNotImplemented("smallcaps undefined", `#"#undefined"`, nil),
-		expectNotImplemented("smallcaps NaN", `#"#NaN"`, nil),
-		expectNotImplemented("smallcaps infinity", `#"#Infinity"`, nil),
-		expectNotImplemented("smallcaps negative infinity", `#"#-Infinity"`, nil),
-		expectNotImplemented("smallcaps symbol", `#"%foo"`, nil),
-		expectNotImplemented("smallcaps promise", `#"&0"`, []any{"a"}),
-		expectNotImplemented("smallcaps tagged", `#{"#tag":"copySet","payload":[]}`, nil),
-		expectNotImplemented("smallcaps error", `#{"#error":"foo","name":"Error"}`, nil),
-		expectNotImplemented("legacy undefined", `{"@qclass":"undefined"}`, nil),
-		expectNotImplemented("legacy NaN", `{"@qclass":"NaN"}`, nil),
-		expectNotImplemented("legacy infinity", `{"@qclass":"Infinity"}`, nil),
-		expectNotImplemented("legacy negative infinity", `{"@qclass":"-Infinity"}`, nil),
-		expectNotImplemented("legacy symbol", `{"@qclass":"symbol","name":"foo"}`, nil),
-		expectNotImplemented("smallcaps tagged", `{"@qclass":"tagged","tag":"copySet","payload":[]}`, nil),
-		expectNotImplemented("smallcaps error", `{"@qclass":"error","message":"foo","name":"Error"}`, nil),
-		expectNotImplemented("smallcaps Hilbert Hotel", `{"@qclass":"hilbert","original":"foo"}`, nil),
-	}...)
-	for _, desc := range testCases {
-		desc.request.Path = "key"
-		if desc.data == nil {
-			keeper.SetStorage(ctx, agoric.NewKVEntryWithNoValue(desc.request.Path))
-		} else {
-			keeper.SetStorage(ctx, agoric.NewKVEntry(desc.request.Path, *desc.data))
-		}
-		resp, err := querier.CapData(sdk.WrapSDKContext(ctx), &desc.request)
-		if desc.errCode == grpcCodes.OK {
-			if err != nil {
-				t.Errorf("%s: got unexpected error %v", desc.label, err)
-			} else if reflect.DeepEqual(resp, &desc.expected) {
-				continue
-			}
-			if resp.Value != desc.expected.Value {
-				lines := strings.Split(resp.Value, "\n")
-				t.Errorf("%s: wrong result value lines: %#q", desc.label, lines)
-			} else {
-				t.Errorf("%s: wrong result: %#v", desc.label, resp)
-			}
-		} else if err == nil {
-			t.Errorf("%s: got no error, want error %q", desc.label, *desc.errContains)
-		} else if code := grpcStatus.Code(err); code != desc.errCode {
-			t.Errorf("%s: got error code %q, want %q", desc.label, code, desc.errCode)
-		} else if desc.errContains != nil && !strings.Contains(err.Error(), *desc.errContains) {
-			t.Errorf("%s: got error %v, want error %q", desc.label, err, *desc.errContains)
-		}
-	}
-}