mirror of
https://github.com/hanzoai/tsgo.git
synced 2026-10-30 19:37:15 +00:00
582 lines
22 KiB
Go
582 lines
22 KiB
Go
package spanmap_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/microsoft/typescript-go/internal/core"
|
|
"github.com/microsoft/typescript-go/internal/spanmap"
|
|
"gotest.tools/v3/assert"
|
|
)
|
|
|
|
func TestVirtualToOriginalSpanVerbatim(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Virtual [0,10) is a verbatim copy of original [100,110).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(3, 7))
|
|
assert.Equal(t, got.Pos(), 103)
|
|
assert.Equal(t, got.End(), 107)
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestVirtualToOriginalSpanAtom(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Virtual [0,3) is a synthesized gap; [3,14) ("MyComponent") is an atom of the original [60,71).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 3, VirtualEnd: 14, OriginalStart: 60, OriginalEnd: 71, Kind: spanmap.KindAtom, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
// A span inside the atom maps to the whole atom span.
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(5, 9))
|
|
assert.Equal(t, got.Pos(), 60)
|
|
assert.Equal(t, got.End(), 71)
|
|
assert.Equal(t, fidelity, spanmap.FidelityAtom)
|
|
}
|
|
|
|
func TestVirtualAlias(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 10, OriginalEnd: 11, Kind: spanmap.KindAlias, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(3, 6))
|
|
assert.Equal(t, got, core.NewTextRange(10, 11))
|
|
assert.Equal(t, fidelity, spanmap.FidelityAtom)
|
|
alias, ok := m.AliasForVirtualSpan(core.NewTextRange(3, 6))
|
|
assert.Assert(t, ok)
|
|
assert.Equal(t, alias.Kind, spanmap.KindAlias)
|
|
_, partial := m.AliasForVirtualSpan(core.NewTextRange(4, 6))
|
|
assert.Assert(t, !partial)
|
|
|
|
data, err := m.Marshal()
|
|
assert.NilError(t, err)
|
|
decoded, err := spanmap.Unmarshal(data)
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, decoded.Segments()[0].Kind, spanmap.KindAlias)
|
|
}
|
|
|
|
func TestVirtualToOriginalSpanSynthesizedGap(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// A gap between two verbatim segments is synthesized: it maps to the insertion point (the preceding
|
|
// segment's original end) with no fidelity.
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
{VirtualStart: 20, VirtualEnd: 30, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(12, 15))
|
|
assert.Equal(t, got.Pos(), 110)
|
|
assert.Equal(t, got.End(), 110)
|
|
assert.Equal(t, fidelity, spanmap.FidelityNone)
|
|
}
|
|
|
|
func TestOriginalToVirtualIntersectingSpansAllowsUncoveredEndpoints(t *testing.T) {
|
|
t.Parallel()
|
|
m := spanmap.New([]spanmap.Segment{{
|
|
VirtualStart: 10, VirtualEnd: 20,
|
|
OriginalStart: 100, OriginalEnd: 110,
|
|
Kind: spanmap.KindVerbatim, Features: spanmap.FeatureSemanticTokens | spanmap.FeatureInlayHints,
|
|
}})
|
|
|
|
for _, feature := range []spanmap.Feature{spanmap.FeatureSemanticTokens, spanmap.FeatureInlayHints} {
|
|
got := m.OriginalToVirtualIntersectingSpans(core.NewTextRange(90, 120), feature)
|
|
assert.Equal(t, len(got), 1)
|
|
assert.Equal(t, got[0].Span, core.NewTextRange(10, 20))
|
|
assert.Equal(t, got[0].Fidelity, spanmap.FidelityExact)
|
|
}
|
|
}
|
|
|
|
func TestVirtualToOriginalSpanEmptyIsSynthesized(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// An empty map describes fully synthesized output: everything maps to the start with no fidelity.
|
|
m := spanmap.New(nil)
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(5, 10))
|
|
assert.Equal(t, got.Pos(), 0)
|
|
assert.Equal(t, got.End(), 0)
|
|
assert.Equal(t, fidelity, spanmap.FidelityNone)
|
|
}
|
|
|
|
func TestVirtualToOriginalSpanCrossingSegments(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim},
|
|
{VirtualStart: 10, VirtualEnd: 20, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindVerbatim},
|
|
})
|
|
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(5, 15))
|
|
assert.Equal(t, got.Pos(), 105)
|
|
assert.Equal(t, got.End(), 205)
|
|
assert.Equal(t, fidelity, spanmap.FidelityApproximate)
|
|
}
|
|
|
|
func TestVirtualToOriginalSpanNilIdentity(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var m *spanmap.SpanMap
|
|
got, fidelity := m.VirtualToOriginalSpan(core.NewTextRange(3, 7))
|
|
assert.Equal(t, got.Pos(), 3)
|
|
assert.Equal(t, got.End(), 7)
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestVirtualToOriginalPosition(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Virtual [0,10) is a verbatim copy of original [100,110); [10,20) is an atom of original [200,210).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
{VirtualStart: 20, VirtualEnd: 30, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindAtom, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
testCases := []struct {
|
|
name string
|
|
pos core.TextPos
|
|
want core.TextPos
|
|
fidelity spanmap.Fidelity
|
|
}{
|
|
{"verbatim interpolates", 3, 103, spanmap.FidelityExact},
|
|
{"atom maps to its start", 25, 200, spanmap.FidelityAtom},
|
|
{"gap maps to insertion point", 15, 110, spanmap.FidelityNone},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got, fidelity := m.VirtualToOriginalPosition(tc.pos)
|
|
assert.Equal(t, got, tc.want)
|
|
assert.Equal(t, fidelity, tc.fidelity)
|
|
// VirtualToOriginalPosition must agree with VirtualToOriginalSpan on a zero-length range.
|
|
span, spanFidelity := m.VirtualToOriginalSpan(core.NewTextRange(int(tc.pos), int(tc.pos)))
|
|
assert.Equal(t, got, core.TextPos(span.Pos()))
|
|
assert.Equal(t, fidelity, spanFidelity)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMapPositionNilIdentity(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var m *spanmap.SpanMap
|
|
got, fidelity := m.VirtualToOriginalPosition(7)
|
|
assert.Equal(t, got, core.TextPos(7))
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestOriginalToVirtualSpanVerbatim(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Virtual [0,10) is a verbatim copy of original [100,110).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
results := m.OriginalToVirtualSpans(core.NewTextRange(103, 107), spanmap.FeatureAll)
|
|
assert.Equal(t, len(results), 1)
|
|
assert.Equal(t, results[0].Span.Pos(), 3)
|
|
assert.Equal(t, results[0].Span.End(), 7)
|
|
assert.Equal(t, results[0].Fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestOriginalToVirtualSpanAtom(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Virtual [3,14) is an atom of the original [60,71).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 3, VirtualEnd: 14, OriginalStart: 60, OriginalEnd: 71, Kind: spanmap.KindAtom, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
// A span inside the original atom maps to the whole virtual span.
|
|
results := m.OriginalToVirtualSpans(core.NewTextRange(63, 67), spanmap.FeatureAll)
|
|
assert.Equal(t, len(results), 1)
|
|
assert.Equal(t, results[0].Span.Pos(), 3)
|
|
assert.Equal(t, results[0].Span.End(), 14)
|
|
assert.Equal(t, results[0].Fidelity, spanmap.FidelityAtom)
|
|
}
|
|
|
|
func TestOriginalToVirtualSpanGap(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// An original range with no covering segment has no virtual counterpart.
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
{VirtualStart: 20, VirtualEnd: 30, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
assert.Equal(t, len(m.OriginalToVirtualSpans(core.NewTextRange(150, 160), spanmap.FeatureAll)), 0)
|
|
}
|
|
|
|
func TestOriginalToVirtualSpanNilIdentity(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var m *spanmap.SpanMap
|
|
results := m.OriginalToVirtualSpans(core.NewTextRange(3, 7), spanmap.FeatureAll)
|
|
assert.Equal(t, len(results), 1)
|
|
assert.Equal(t, results[0].Span.Pos(), 3)
|
|
assert.Equal(t, results[0].Span.End(), 7)
|
|
assert.Equal(t, results[0].Fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestOriginalToVirtualPositions(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Original [100,110) is a verbatim copy of virtual [0,10); [200,210) is an atom of virtual [20,30).
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
{VirtualStart: 20, VirtualEnd: 30, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindAtom, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
testCases := []struct {
|
|
name string
|
|
pos core.TextPos
|
|
want core.TextPos
|
|
fidelity spanmap.Fidelity
|
|
}{
|
|
{"verbatim interpolates", 103, 3, spanmap.FidelityExact},
|
|
{"atom maps to its start", 205, 20, spanmap.FidelityAtom},
|
|
{"gap has no projection", 150, 0, spanmap.FidelityNone},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
positions := m.OriginalToVirtualPositions(tc.pos, spanmap.FeatureAll)
|
|
spans := m.OriginalToVirtualSpans(core.NewTextRange(int(tc.pos), int(tc.pos)), spanmap.FeatureAll)
|
|
if tc.fidelity.IsNone() {
|
|
assert.Equal(t, len(positions), 0)
|
|
assert.Equal(t, len(spans), 0)
|
|
return
|
|
}
|
|
assert.Equal(t, len(positions), 1)
|
|
assert.Equal(t, positions[0].Position, tc.want)
|
|
assert.Equal(t, positions[0].Fidelity, tc.fidelity)
|
|
assert.Equal(t, len(spans), 1)
|
|
assert.Equal(t, core.TextPos(spans[0].Span.Pos()), tc.want)
|
|
assert.Equal(t, spans[0].Fidelity, tc.fidelity)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOriginalToVirtualPositionsAtEndpoint(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 2, VirtualEnd: 5, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureCompletion},
|
|
{VirtualStart: 8, VirtualEnd: 11, OriginalStart: 13, OriginalEnd: 16, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureCompletion},
|
|
{VirtualStart: 20, VirtualEnd: 23, OriginalStart: 30, OriginalEnd: 35, Kind: spanmap.KindAtom, Features: spanmap.FeatureCompletion},
|
|
})
|
|
|
|
assert.DeepEqual(t, m.OriginalToVirtualPositions(13, spanmap.FeatureCompletion), []spanmap.MappedPosition{
|
|
{Position: 5, Fidelity: spanmap.FidelityExact},
|
|
{Position: 8, Fidelity: spanmap.FidelityExact},
|
|
})
|
|
assert.DeepEqual(t, m.OriginalToVirtualPositions(35, spanmap.FeatureCompletion), []spanmap.MappedPosition{
|
|
{Position: 23, Fidelity: spanmap.FidelityAtom},
|
|
})
|
|
|
|
filtered := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 20, VirtualEnd: 23, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 2, VirtualEnd: 5, OriginalStart: 13, OriginalEnd: 16, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureCompletion},
|
|
})
|
|
assert.DeepEqual(t, filtered.OriginalToVirtualPositions(13, spanmap.FeatureAll), []spanmap.MappedPosition{
|
|
{Position: 2, Fidelity: spanmap.FidelityExact},
|
|
{Position: 23, Fidelity: spanmap.FidelityExact},
|
|
})
|
|
assert.DeepEqual(t, filtered.OriginalToVirtualPositions(13, spanmap.FeatureCompletion), []spanmap.MappedPosition{
|
|
{Position: 2, Fidelity: spanmap.FidelityExact},
|
|
})
|
|
}
|
|
|
|
func TestOriginalToVirtualDuplicateGroup(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureDefinition},
|
|
{VirtualStart: 10, VirtualEnd: 13, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 20, VirtualEnd: 25, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindAtom, Features: spanmap.FeatureDefinition},
|
|
})
|
|
|
|
semantic := m.OriginalToVirtualPositions(11, spanmap.FeatureHover)
|
|
assert.Equal(t, len(semantic), 1)
|
|
assert.Equal(t, semantic[0].Position, core.TextPos(11))
|
|
assert.Equal(t, semantic[0].Fidelity, spanmap.FidelityExact)
|
|
|
|
navigation := m.OriginalToVirtualPositions(11, spanmap.FeatureDefinition)
|
|
assert.Equal(t, len(navigation), 2)
|
|
assert.Equal(t, navigation[0].Position, core.TextPos(1))
|
|
assert.Equal(t, navigation[0].Fidelity, spanmap.FidelityExact)
|
|
assert.Equal(t, navigation[1].Position, core.TextPos(20))
|
|
assert.Equal(t, navigation[1].Fidelity, spanmap.FidelityAtom)
|
|
|
|
spans := m.OriginalToVirtualSpans(core.NewTextRange(10, 13), spanmap.FeatureDefinition)
|
|
assert.Equal(t, len(spans), 2)
|
|
assert.Equal(t, spans[0].Span.Pos(), 0)
|
|
assert.Equal(t, spans[0].Span.End(), 3)
|
|
assert.Equal(t, spans[1].Span.Pos(), 20)
|
|
assert.Equal(t, spans[1].Span.End(), 25)
|
|
}
|
|
|
|
func TestOriginalToVirtualCrossGroupProjections(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 2, OriginalStart: 0, OriginalEnd: 2, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 2, VirtualEnd: 4, OriginalStart: 2, OriginalEnd: 4, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 10, VirtualEnd: 12, OriginalStart: 0, OriginalEnd: 2, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 12, VirtualEnd: 14, OriginalStart: 2, OriginalEnd: 4, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
})
|
|
|
|
spans := m.OriginalToVirtualSpans(core.NewTextRange(1, 3), spanmap.FeatureHover)
|
|
assert.Equal(t, len(spans), 2)
|
|
assert.Equal(t, spans[0].Span, core.NewTextRange(1, 3))
|
|
assert.Equal(t, spans[1].Span, core.NewTextRange(11, 13))
|
|
for _, mapped := range spans {
|
|
assert.Equal(t, mapped.Fidelity, spanmap.FidelityApproximate)
|
|
}
|
|
}
|
|
|
|
func TestOriginalToVirtualExplicitZeroFeatures(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureNone},
|
|
})
|
|
|
|
assert.Equal(t, len(m.OriginalToVirtualPositions(11, spanmap.FeatureHover)), 0)
|
|
assert.Equal(t, len(m.OriginalToVirtualPositions(11, spanmap.FeatureDefinition)), 0)
|
|
assert.Equal(t, len(m.OriginalToVirtualSpans(core.NewTextRange(10, 13), spanmap.FeatureHover)), 0)
|
|
|
|
data, err := m.Marshal()
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, string(data), "[[0,3,10,3,0,0]]")
|
|
decoded, err := spanmap.Unmarshal(data)
|
|
assert.NilError(t, err)
|
|
segments := decoded.Segments()
|
|
assert.Equal(t, segments[0].Features, spanmap.FeatureNone)
|
|
|
|
legacy, err := spanmap.Unmarshal([]byte("[[0,3,10,3,0]]"))
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, legacy.Segments()[0].Features, spanmap.FeatureAll)
|
|
assert.Equal(t, len(legacy.OriginalToVirtualPositions(11, spanmap.FeatureHover)), 1)
|
|
}
|
|
|
|
func TestFeatureParticipationOriginalAndVirtual(t *testing.T) {
|
|
t.Parallel()
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 10, OriginalEnd: 13, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 20, OriginalEnd: 23, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureCompletion},
|
|
})
|
|
|
|
assert.Equal(t, len(m.OriginalToVirtualPositions(11, spanmap.FeatureHover)), 1)
|
|
assert.Equal(t, len(m.OriginalToVirtualPositions(11, spanmap.FeatureCompletion)), 0)
|
|
|
|
mapped, fidelity := m.VirtualToOriginalSpanForFeature(core.NewTextRange(0, 3), spanmap.FeatureHover)
|
|
assert.Equal(t, mapped, core.NewTextRange(10, 13))
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
_, fidelity = m.VirtualToOriginalSpanForFeature(core.NewTextRange(0, 3), spanmap.FeatureCompletion)
|
|
assert.Equal(t, fidelity, spanmap.FidelityNone)
|
|
|
|
// Diagnostics and edit safety use unfiltered geometry and cannot be disabled by feature flags.
|
|
mapped, fidelity = m.VirtualToOriginalSpan(core.NewTextRange(0, 3))
|
|
assert.Equal(t, mapped, core.NewTextRange(10, 13))
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
}
|
|
|
|
func TestOriginalToVirtualSpanRoundTrip(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Original spans are out of order relative to virtual spans, exercising the reverse index.
|
|
m := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 200, OriginalEnd: 210, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
{VirtualStart: 10, VirtualEnd: 20, OriginalStart: 100, OriginalEnd: 110, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureAll},
|
|
})
|
|
|
|
for _, r := range []core.TextRange{core.NewTextRange(2, 8), core.NewTextRange(12, 18)} {
|
|
orig, fidelity := m.VirtualToOriginalSpan(r)
|
|
assert.Equal(t, fidelity, spanmap.FidelityExact)
|
|
back := m.OriginalToVirtualSpans(orig, spanmap.FeatureAll)
|
|
assert.Equal(t, len(back), 1)
|
|
assert.Equal(t, back[0].Fidelity, spanmap.FidelityExact)
|
|
assert.Equal(t, back[0].Span.Pos(), r.Pos())
|
|
assert.Equal(t, back[0].Span.End(), r.End())
|
|
}
|
|
}
|
|
|
|
func TestMarshalRoundTrip(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
original := spanmap.New([]spanmap.Segment{
|
|
{VirtualStart: 3, VirtualEnd: 14, OriginalStart: 60, OriginalEnd: 71, Kind: spanmap.KindAtom},
|
|
{VirtualStart: 14, VirtualEnd: 24, OriginalStart: 71, OriginalEnd: 81, Kind: spanmap.KindVerbatim},
|
|
})
|
|
|
|
data, err := original.Marshal()
|
|
assert.NilError(t, err)
|
|
decoded, err := spanmap.Unmarshal(data)
|
|
assert.NilError(t, err)
|
|
|
|
for _, r := range []core.TextRange{core.NewTextRange(1, 2), core.NewTextRange(4, 10), core.NewTextRange(16, 20)} {
|
|
wantRange, wantFidelity := original.VirtualToOriginalSpan(r)
|
|
gotRange, gotFidelity := decoded.VirtualToOriginalSpan(r)
|
|
assert.Equal(t, gotRange, wantRange)
|
|
assert.Equal(t, gotFidelity, wantFidelity)
|
|
}
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const transformed = "const greeting = 1;\n"
|
|
const original = "<x>const greeting = 1;\n</x>"
|
|
scriptStart := 3 // index of "const" in original
|
|
|
|
testCases := []struct {
|
|
name string
|
|
segs []spanmap.Segment
|
|
wantKind spanmap.MappingErrorKind
|
|
wantOK bool
|
|
}{
|
|
{
|
|
name: "valid verbatim",
|
|
segs: []spanmap.Segment{{VirtualStart: 0, VirtualEnd: core.TextPos(len(transformed)), OriginalStart: core.TextPos(scriptStart), OriginalEnd: core.TextPos(scriptStart + len(transformed)), Kind: spanmap.KindVerbatim}},
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "empty is valid",
|
|
segs: nil,
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "gap is allowed",
|
|
segs: []spanmap.Segment{{VirtualStart: 3, VirtualEnd: core.TextPos(len(transformed)), OriginalStart: 0, OriginalEnd: 0, Kind: spanmap.KindAtom}},
|
|
wantOK: true,
|
|
},
|
|
{
|
|
name: "overlap",
|
|
segs: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 10, OriginalStart: 0, OriginalEnd: 0, Kind: spanmap.KindAtom},
|
|
{VirtualStart: 5, VirtualEnd: core.TextPos(len(transformed)), OriginalStart: 0, OriginalEnd: 0, Kind: spanmap.KindAtom},
|
|
},
|
|
wantKind: spanmap.MappingErrorKindOverlap,
|
|
},
|
|
{
|
|
name: "original out of bounds",
|
|
segs: []spanmap.Segment{{VirtualStart: 0, VirtualEnd: core.TextPos(len(transformed)), OriginalStart: 0, OriginalEnd: core.TextPos(len(original) + 10), Kind: spanmap.KindAtom}},
|
|
wantKind: spanmap.MappingErrorKindOutOfBounds,
|
|
},
|
|
{
|
|
name: "verbatim text mismatch",
|
|
segs: []spanmap.Segment{{VirtualStart: 0, VirtualEnd: core.TextPos(len(transformed)), OriginalStart: 0, OriginalEnd: core.TextPos(len(transformed)), Kind: spanmap.KindVerbatim}},
|
|
wantKind: spanmap.MappingErrorKindVerbatimMismatch,
|
|
},
|
|
{
|
|
name: "unknown kind",
|
|
segs: []spanmap.Segment{{VirtualStart: 0, VirtualEnd: 1, OriginalStart: 0, OriginalEnd: 1, Kind: 3}},
|
|
wantKind: spanmap.MappingErrorKindKind,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
problem := spanmap.New(tc.segs).Validate(transformed, original)
|
|
if tc.wantOK {
|
|
assert.Assert(t, problem == nil, "expected valid, got %+v", problem)
|
|
return
|
|
}
|
|
assert.Assert(t, problem != nil, "expected a problem")
|
|
assert.Equal(t, problem.Kind, tc.wantKind)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateOriginalOverlapAndFeatures(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
segments []spanmap.Segment
|
|
wantKind spanmap.MappingErrorKind
|
|
valid bool
|
|
}{
|
|
{
|
|
name: "identical duplicate group",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureDefinition},
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindVerbatim, Features: spanmap.FeatureHover},
|
|
},
|
|
valid: true,
|
|
},
|
|
{
|
|
name: "partial original overlap",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom},
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 2, OriginalEnd: 5, Kind: spanmap.KindAtom},
|
|
},
|
|
wantKind: spanmap.MappingErrorKindOriginalOverlap,
|
|
},
|
|
{
|
|
name: "nested original overlap",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 5, OriginalStart: 0, OriginalEnd: 5, Kind: spanmap.KindAtom},
|
|
{VirtualStart: 5, VirtualEnd: 6, OriginalStart: 1, OriginalEnd: 4, Kind: spanmap.KindAtom},
|
|
},
|
|
wantKind: spanmap.MappingErrorKindOriginalOverlap,
|
|
},
|
|
{
|
|
name: "duplicate without explicit features is tolerant",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom},
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom, Features: spanmap.FeatureDefinition},
|
|
},
|
|
valid: true,
|
|
},
|
|
{
|
|
name: "duplicate with shared feature members is tolerant",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom, Features: spanmap.FeatureHover},
|
|
{VirtualStart: 3, VirtualEnd: 6, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom, Features: spanmap.FeatureHover | spanmap.FeatureDefinition},
|
|
},
|
|
valid: true,
|
|
},
|
|
{
|
|
name: "features on sole cover are valid",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom, Features: spanmap.FeatureDefinition},
|
|
},
|
|
valid: true,
|
|
},
|
|
{
|
|
name: "unknown feature flag",
|
|
segments: []spanmap.Segment{
|
|
{VirtualStart: 0, VirtualEnd: 3, OriginalStart: 0, OriginalEnd: 3, Kind: spanmap.KindAtom, Features: 1 << 22},
|
|
},
|
|
wantKind: spanmap.MappingErrorKindFeature,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
problem := spanmap.New(test.segments).Validate("abcabc", "abcdef")
|
|
if test.valid {
|
|
assert.Assert(t, problem == nil, "expected valid, got %+v", problem)
|
|
return
|
|
}
|
|
assert.Assert(t, problem != nil)
|
|
assert.Equal(t, problem.Kind, test.wantKind)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateNilIsValid(t *testing.T) {
|
|
t.Parallel()
|
|
var m *spanmap.SpanMap
|
|
assert.Assert(t, m.Validate("abc", "abc") == nil)
|
|
}
|