Function TestInternalSearchHelperEdges

mcdc_supplement_test.go:14–90

Verifies: STK-REQ-001 [malformed] MCDC STK-REQ-001: N/A Verifies: STK-REQ-005 [malformed] MCDC STK-REQ-005: N/A

(t *testing.T)

// Verifies: STK-REQ-005 [malformed]
// MCDC STK-REQ-005: N/A
func TestInternalSearchHelperEdges(t *testing.T) {
	if got := findTokenStart(nil, ','); got != 0 {
		t.Fatalf("findTokenStart(nil, ',') = %d, want 0", got)
	}
	if got := lastToken(nil); got != -1 {
		t.Fatalf("lastToken(nil) = %d, want -1", got)
	}

	t.Run("findKeyStart", func(t *testing.T) {
		cases := []struct {
			name      string
			data      string
			key       string
			wantFound bool
			wantErr   error
		}{
			{name: "whitespace only", data: "   \n\t", key: "a", wantErr: KeyPathNotFoundError},
			{name: "array root branch is tolerated", data: `[{"a":1}]`, key: "a", wantErr: KeyPathNotFoundError},
			{name: "escaped key is decoded", data: `{"a\nb":1}`, key: "a\nb", wantFound: true},
			{name: "malformed escaped key is rejected", data: `{"\uD800":1}`, key: "x", wantErr: KeyPathNotFoundError},
			{name: "missing value after key", data: `{"a"`, key: "a", wantErr: KeyPathNotFoundError},
			{name: "requested key has malformed escape", data: `{"a":1}`, key: `\uD800`, wantErr: KeyPathNotFoundError},
			{name: "unterminated key string", data: `{"a`, key: "a", wantErr: KeyPathNotFoundError},
		}

		for _, tc := range cases {
			t.Run(tc.name, func(t *testing.T) {
				offset, err := findKeyStart([]byte(tc.data), tc.key)
				if tc.wantErr != nil {
					if !errors.Is(err, tc.wantErr) {
						t.Fatalf("findKeyStart(%q, %q) error = %v, want %v", tc.data, tc.key, err, tc.wantErr)
					}
					if offset != -1 {
						t.Fatalf("findKeyStart(%q, %q) offset = %d, want -1", tc.data, tc.key, offset)
					}
					return
				}

				if err != nil {
					t.Fatalf("findKeyStart(%q, %q) returned error: %v", tc.data, tc.key, err)
				}
				if !tc.wantFound || offset < 0 {
					t.Fatalf("findKeyStart(%q, %q) offset = %d, want found offset", tc.data, tc.key, offset)
				}
			})
		}
	})

	t.Run("searchKeys", func(t *testing.T) {
		cases := []struct {
			name string
			data string
			keys []string
			want bool
		}{
			{name: "missing value after key", data: `{"a"`, keys: []string{"a"}, want: false},
			{name: "malformed escaped key", data: `{"\uD800":1}`, keys: []string{"x"}, want: false},
			{name: "nested mismatch still finds later path", data: `{"x":{"b":1},"a":{"b":2}}`, keys: []string{"a", "b"}, want: true},