waveform-analysis 0.1.62 → 0.1.64

package/src/components/core/yAxisNice.test.ts

@@ -1,174 +0,0 @@
-import { zoomIdentity } from 'd3'
-import { describe, expect, it } from 'vitest'
-
-import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
-import type { WaveformData } from '../../types'
-import { buildTrackLayouts } from './trackLayoutBuilder'
-import type { DisplaySeries, DisplayTrack } from './types'
-import { prepareWaveformSeries } from './useWaveformData'
-
-function displaySeries(id: string, domain: [number, number]): DisplaySeries {
-  return {
-    id,
-    name: id,
-    color: '#1677ff',
-    lineType: 'linear',
-    lineStyle: 'solid',
-    pointType: 'none',
-    errorBar: { visible: false, width: 1.5, capWidth: 8 },
-    points: [
-      { x: 0, y: domain[0] },
-      { x: 1, y: domain[1] },
-    ],
-    xDomain: [0, 1],
-    yDomain: domain,
-    hasErrorPoints: false,
-  }
-}
-
-function layout(
-  series: DisplaySeries[],
-  options: { overlayMode?: 'single-axis' | 'multi-axis'; fixedYDomain?: [number, number] } = {},
-) {
-  const track: DisplayTrack = {
-    id: 'track',
-    series,
-    visibleSeries: series,
-    xDomain: [0, 1],
-    yDomain: [
-      Math.min(...series.map((item) => item.yDomain[0])),
-      Math.max(...series.map((item) => item.yDomain[1])),
-    ],
-  }
-  return buildTrackLayouts({
-    cells: [
-      {
-        slotIndex: 0,
-        row: 0,
-        column: 0,
-        left: 0,
-        top: 0,
-        width: 120,
-        height: 100,
-        plotHeight: 100,
-        cellHeight: 130,
-        xAxisBand: 30,
-        series: track,
-      },
-    ],
-    grid: {
-      rowCount: 1,
-      columnCount: 1,
-      showPagination: false,
-      fillIncompleteLastRow: false,
-      trackLines: {},
-    },
-    displayMode: 'independent',
-    overlayMode: options.overlayMode ?? 'single-axis',
-    independentTransforms: [zoomIdentity],
-    sharedZoomDomain: [0, 1],
-    fixedYDomain: options.fixedYDomain,
-    timeUnit: 'ms',
-    rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-    hideSecondaryLabels: false,
-    yAxisLabelX: -50,
-    yAxisNice: false,
-    showCompactEmptyTracks: false,
-  })[0]!
-}
-
-describe('Y-axis nice domains', () => {
-  it('defaults to a nice domain and can preserve the actual data endpoints', () => {
-    const source = displaySeries('source', [3, 97])
-    const track: DisplayTrack = {
-      id: 'track',
-      series: [source],
-      visibleSeries: [source],
-      xDomain: [0, 1],
-      yDomain: [3, 97],
-    }
-    const defaults = buildTrackLayouts({
-      cells: [
-        {
-          slotIndex: 0,
-          row: 0,
-          column: 0,
-          left: 0,
-          top: 0,
-          width: 120,
-          height: 100,
-          plotHeight: 100,
-          cellHeight: 130,
-          xAxisBand: 30,
-          series: track,
-        },
-      ],
-      grid: {
-        rowCount: 1,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'single-axis',
-      independentTransforms: [zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: -50,
-      showCompactEmptyTracks: false,
-    })[0]!
-
-    expect(defaults.yScale.domain()).toEqual([0, 100])
-    expect(layout([source]).yScale.domain()).toEqual([3, 97])
-  })
-
-  it('merges visible single-axis series but keeps multi-axis series independent', () => {
-    const first = displaySeries('first', [3, 40])
-    const second = displaySeries('second', [10, 97])
-
-    expect(layout([first, second]).yScale.domain()).toEqual([3, 97])
-    expect(
-      layout([first, second], { overlayMode: 'multi-axis' }).yAxes.map((axis) =>
-        axis.scale.domain(),
-      ),
-    ).toEqual([
-      [3, 40],
-      [10, 97],
-    ])
-  })
-
-  it('keeps explicit domains and constant-data safety ranges unchanged', () => {
-    expect(
-      layout([displaySeries('source', [3, 97])], { fixedYDomain: [3, 97] }).yScale.domain(),
-    ).toEqual([3, 97])
-    expect(layout([displaySeries('constant', [9.5, 10.5])]).yScale.domain()).toEqual([9.5, 10.5])
-  })
-
-  it('continues to include visible error-bar bounds in the preserved domain', () => {
-    const input: WaveformData = {
-      kind: 'series',
-      series: [
-        {
-          id: 'error-series',
-          name: 'error series',
-          errorBar: { visible: true },
-          data: {
-            kind: 'points',
-            points: [
-              { x: 0, y: 3, lowerError: 2 },
-              { x: 1, y: 7, upperError: 4 },
-            ],
-          },
-        },
-      ],
-    }
-    const [prepared] = prepareWaveformSeries(input)
-    const errorSeries: DisplaySeries = { ...prepared!, color: prepared!.color ?? '#1677ff' }
-
-    expect(prepared?.yDomain).toEqual([1, 11])
-    expect(layout([errorSeries]).yScale.domain()).toEqual([1, 11])
-  })
-})

package/src/components/core/yAxisSlotLayout.test.ts

@@ -1,165 +0,0 @@
-import { zoomIdentity } from 'd3'
-import { describe, expect, it } from 'vitest'
-
-import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
-import { buildTrackLayouts, buildYAxisSlots, resolveRenderedYAxisSeriesGroups } from './layout'
-import type { DisplaySeries, DisplayTrack } from './types'
-import { Y_AXIS_RIGHT_LABEL_OFFSET } from './yAxisConstants'
-
-function series(id: string, minimum: number, maximum: number): DisplaySeries {
-  return {
-    id,
-    name: id,
-    color: '#1677ff',
-    lineType: 'linear',
-    lineStyle: 'solid',
-    pointType: 'none',
-    errorBar: { visible: false, width: 1.5, capWidth: 8 },
-    points: [
-      { x: 0, y: minimum },
-      { x: 1, y: maximum },
-    ],
-    xDomain: [0, 1],
-    yDomain: [minimum, maximum],
-    hasErrorPoints: false,
-  }
-}
-
-function track(seriesList: DisplaySeries[]): DisplayTrack {
-  return {
-    id: seriesList[0]!.id,
-    series: seriesList,
-    visibleSeries: seriesList,
-    xDomain: [0, 1],
-    yDomain: [0, 1],
-  }
-}
-
-describe('Y-axis slots', () => {
-  it('aligns matching slots across single and multi-axis tracks', () => {
-    const tracks = [
-      track([series('single', -1e120, 1e120)]),
-      track([series('left', 0, 1), series('right', 1000, 3000)]),
-      track([series('left-two', 0, 1), series('right-two', 1000, 3000)]),
-    ]
-    const yAxisSlots = buildYAxisSlots(tracks, 'multi-axis')
-    const layouts = buildTrackLayouts({
-      cells: tracks.map((series, index) => ({
-        slotIndex: index,
-        row: index,
-        column: 0,
-        left: 0,
-        top: index * 100,
-        width: 600,
-        height: 100,
-        plotHeight: 100,
-        cellHeight: 130,
-        xAxisBand: 30,
-        series,
-      })),
-      grid: {
-        rowCount: 3,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'multi-axis',
-      independentTransforms: [zoomIdentity, zoomIdentity, zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: yAxisSlots.slots.find((slot) => slot.side === 'left')!.labelOffset,
-      yAxisSlots: yAxisSlots.slots,
-      showCompactEmptyTracks: false,
-    })
-
-    expect(layouts.map((layout) => layout.yAxes[0]?.labelX)).toEqual([
-      layouts[0]?.yAxes[0]?.labelX,
-      layouts[0]?.yAxes[0]?.labelX,
-      layouts[0]?.yAxes[0]?.labelX,
-    ])
-    expect(layouts[1]?.yAxes[1]?.labelX).toBe(layouts[2]?.yAxes[1]?.labelX)
-    expect(layouts[1]?.yAxes[1]?.labelX).toBe(
-      600 +
-        yAxisSlots.slots.find((slot) => slot.side === 'right')!.labelOffset -
-        Y_AXIS_RIGHT_LABEL_OFFSET,
-    )
-    expect(yAxisSlots.slots).toMatchObject([
-      { side: 'left', sideIndex: 0, axisOffset: 0 },
-      { side: 'right', sideIndex: 0, axisOffset: 0 },
-    ])
-    expect(yAxisSlots.clearance.left).toBeGreaterThan(yAxisSlots.clearance.right)
-  })
-
-  it('reserves outward second slots for three and four value axes', () => {
-    const threeAxisSlots = buildYAxisSlots(
-      [track([series('left', 0, 1), series('right-one', 10, 20), series('right-two', 30, 40)])],
-      'multi-axis',
-    )
-    const fourAxisSlots = buildYAxisSlots(
-      [
-        track([
-          series('left-one', 0, 1),
-          series('left-two', 10, 20),
-          series('right-one', 30, 40),
-          series('right-two', 50, 60),
-        ]),
-      ],
-      'multi-axis',
-    )
-
-    expect(threeAxisSlots.slots).toMatchObject([
-      { side: 'left', sideIndex: 0, axisOffset: 0 },
-      { side: 'right', sideIndex: 0, axisOffset: 0 },
-      { side: 'right', sideIndex: 1 },
-    ])
-    expect(threeAxisSlots.slots[2]!.axisOffset).toBeGreaterThan(0)
-    expect(fourAxisSlots.slots).toMatchObject([
-      { side: 'left', sideIndex: 0, axisOffset: 0 },
-      { side: 'left', sideIndex: 1 },
-      { side: 'right', sideIndex: 0, axisOffset: 0 },
-      { side: 'right', sideIndex: 1 },
-    ])
-    expect(fourAxisSlots.slots[1]!.axisOffset).toBeLessThan(0)
-    expect(fourAxisSlots.slots[3]!.axisOffset).toBeGreaterThan(0)
-  })
-
-  it('uses dynamic Y domains when measuring multi-axis slots', () => {
-    const negativeVoltage = series('negative-voltage', 0, 1)
-    negativeVoltage.unit = 'V'
-    const longUnit = series('long-unit', 0, 1)
-    longUnit.unit = 'volt-amperes-per-phase'
-    const sourceTrack = track([negativeVoltage, longUnit])
-    const viewportYDomains = { [sourceTrack.id]: [-0.7434, -0.3434] as [number, number] }
-
-    expect(
-      resolveRenderedYAxisSeriesGroups(
-        sourceTrack,
-        'multi-axis',
-        undefined,
-        undefined,
-        viewportYDomains,
-      ).map((group) => group.domain),
-    ).toEqual([
-      [-0.7434, -0.3434],
-      [-0.7434, -0.3434],
-    ])
-
-    const slots = buildYAxisSlots(
-      [sourceTrack],
-      'multi-axis',
-      undefined,
-      undefined,
-      5,
-      false,
-      false,
-      viewportYDomains,
-    )
-
-    expect(slots.clearance.left).toBe(100)
-    expect(slots.clearance.right).toBeGreaterThan(180)
-  })
-})

package/src/components/core/yDomain.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { DisplayTrack } from './types'
-import { hasFixedYDomainForTrack, mergeYDomains, normalizeYDomain } from './yDomain'
-
-const track: DisplayTrack = {
-  id: 'shared-track',
-  series: [],
-  visibleSeries: [
-    {
-      id: 'channel-a',
-      name: 'A',
-      color: '#1677ff',
-      lineType: 'linear',
-      lineStyle: 'solid',
-      pointType: 'none',
-      errorBar: { visible: false, width: 1.5, capWidth: 8 },
-      points: [],
-      xDomain: [0, 1],
-      yDomain: [0, 1],
-      hasErrorPoints: false,
-    },
-  ],
-  xDomain: [0, 1],
-  yDomain: [0, 1],
-}
-
-describe('fixed Y domains', () => {
-  it('normalizes valid reversed domains', () => {
-    expect(normalizeYDomain([97, 3])).toEqual([3, 97])
-    expect(normalizeYDomain([-10, 10])).toEqual([-10, 10])
-  })
-
-  it.each([undefined, [1, 1], [Number.NaN, 1], [0, Number.POSITIVE_INFINITY]])(
-    'rejects an invalid domain: %j',
-    (domain) => {
-      expect(normalizeYDomain(domain as [number, number] | undefined)).toBeUndefined()
-    },
-  )
-
-  it('detects valid track, series, and global configuration only', () => {
-    expect(hasFixedYDomainForTrack(track, [-1, 1])).toBe(true)
-    expect(hasFixedYDomainForTrack(track, undefined, { 'shared-track': [-2, 2] })).toBe(true)
-    expect(hasFixedYDomainForTrack(track, undefined, { 'channel-a': [-3, 3] })).toBe(true)
-    expect(hasFixedYDomainForTrack(track, [0, 0], { 'channel-a': [1, 1] })).toBe(false)
-  })
-
-  it('merges configured and automatic series domains without padding', () => {
-    expect(
-      mergeYDomains([
-        [3, 97],
-        [-20, 40],
-      ]),
-    ).toEqual([-20, 97])
-  })
-})

package/src/components/interaction/WaveformTooltip.test.ts

@@ -1,276 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick } from 'vue'
-import { resizeObservers } from '../../test/setup'
-
-import WaveformTooltip from './WaveformTooltip.vue'
-
-describe('WaveformTooltip', () => {
-  const point = { x: 1, y: 12 }
-  let measuredWidth = 238
-  let measuredHeight = 40
-
-  beforeEach(() => {
-    measuredWidth = 238
-    measuredHeight = 40
-    vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (
-      this: HTMLElement,
-    ) {
-      return {
-        width: Math.min(measuredWidth, Number.parseFloat(this.style.maxWidth) || measuredWidth),
-        height: measuredHeight,
-      } as DOMRect
-    })
-  })
-  afterEach(() => vi.restoreAllMocks())
-
-  function mountTooltip(positionX: number, containerWidth = 400) {
-    return mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: positionX, y: 100 },
-        timeUnit: 's',
-        hoveredPoint: point,
-        seriesPoints: [{ trackIndex: 0, name: 'Temperature', color: '#f00', point }],
-        containerWidth,
-        containerHeight: 300,
-      },
-    })
-  }
-
-  it('positions the tooltip to the right when enough space remains', async () => {
-    const wrapper = mountTooltip(100)
-    await nextTick()
-    const tooltip = wrapper.get('.waveform-tooltip')
-
-    expect(tooltip.attributes('style')).toContain('left: 112px')
-    expect(tooltip.attributes('style')).not.toContain('right:')
-  })
-
-  it('flips the tooltip to the left near the right boundary', async () => {
-    const wrapper = mountTooltip(370)
-    await nextTick()
-    const tooltip = wrapper.get('.waveform-tooltip')
-
-    expect(tooltip.attributes('style')).toContain('right: 42px')
-    expect(tooltip.attributes('style')).not.toContain('left:')
-  })
-
-  it('keeps the tooltip inside the left boundary when neither side has enough space', async () => {
-    const wrapper = mountTooltip(100, 200)
-    await nextTick()
-    const tooltip = wrapper.get('.waveform-tooltip')
-
-    expect(tooltip.attributes('style')).toContain('left: 8px')
-    expect(tooltip.attributes('style')).toContain('max-width: 184px')
-    expect(tooltip.attributes('style')).not.toContain('right:')
-  })
-
-  it('keeps short content content-sized while exposing the available width cap', async () => {
-    const wrapper = mountTooltip(100)
-    await nextTick()
-    const tooltip = wrapper.get('.waveform-tooltip')
-
-    expect(tooltip.attributes('style')).toContain('left: 112px')
-    expect(tooltip.attributes('style')).toContain('max-width: 384px')
-  })
-
-  it('keeps long series content in a wrapping content container', () => {
-    const longName = 'ENG8KJXAc-very-long-series-name-10001'
-    const pointWithErrors = { x: 1, y: 12, error: 1, upperError: 2 }
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 100, y: 100 },
-        timeUnit: 'ms',
-        hoveredPoint: pointWithErrors,
-        seriesPoints: [
-          {
-            trackIndex: 0,
-            name: longName,
-            color: '#f00',
-            unit: 'very-long-unit',
-            point: pointWithErrors,
-          },
-        ],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    const tooltip = wrapper.get('.waveform-tooltip')
-    expect(tooltip.get('.waveform-tooltip__series-content').text()).toContain(longName)
-    expect(tooltip.get('.waveform-tooltip__series-content').classes()).toContain(
-      'waveform-tooltip__series-content',
-    )
-    expect(tooltip.attributes('style')).toContain('max-width: 384px')
-  })
-
-  it('flips before long content is squeezed and restores the right side when moving back', async () => {
-    measuredWidth = 420
-    const wrapper = mountTooltip(500, 800)
-    await nextTick()
-    const tooltip = wrapper.get('.waveform-tooltip')
-    expect(tooltip.attributes('style')).toContain('right: 312px')
-    expect(tooltip.attributes('style')).toContain('max-width: 560px')
-    await wrapper.setProps({ position: { x: 100, y: 100 } })
-    expect(tooltip.attributes('style')).toContain('left: 112px')
-    expect(tooltip.attributes('style')).toContain('max-width: 560px')
-  })
-
-  it('remeasures changing series, formatted values, container size and visibility', async () => {
-    const wrapper = mountTooltip(500, 800)
-    await nextTick()
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('left: 512px')
-    measuredWidth = 450
-    measuredHeight = 90
-    await wrapper.setProps({
-      timeUnit: 'ms',
-      position: { x: 500, y: 290 },
-      seriesPoints: [
-        { trackIndex: 0, name: 'very-long-channel-name', color: '#f00', point },
-        { trackIndex: 1, name: 'second-channel', color: '#0f0', point: { x: 100, y: 123456 } },
-      ],
-    })
-    await nextTick()
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('right: 312px')
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('top: 202px')
-    await wrapper.setProps({ containerWidth: 200, position: { x: 100, y: 290 } })
-    await nextTick()
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('left: 8px')
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('max-width: 184px')
-    const observer = resizeObservers.at(-1)!
-    await wrapper.setProps({ visible: false })
-    expect(observer.disconnect).toHaveBeenCalled()
-    measuredWidth = 100
-    await wrapper.setProps({ visible: true, containerWidth: 800 })
-    await nextTick()
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('left: 112px')
-    wrapper.unmount()
-    expect(resizeObservers.at(-1)!.disconnect).toHaveBeenCalled()
-  })
-
-  it('updates placement when rendered dimensions change without a prop update', async () => {
-    const wrapper = mountTooltip(500, 800)
-    await nextTick()
-    measuredWidth = 420
-    measuredHeight = 250
-    resizeObservers.at(-1)!.resize(420, 250)
-    await nextTick()
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('right: 312px')
-    expect(wrapper.get('.waveform-tooltip').attributes('style')).toContain('top: 42px')
-    wrapper.unmount()
-  })
-
-  it('omits units and errors from the strict x/y value format', () => {
-    const pointWithErrors = { x: 1, y: 12, error: 1, upperError: 2 }
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 10, y: 10 },
-        timeUnit: 's',
-        hoveredPoint: pointWithErrors,
-        seriesPoints: [
-          {
-            trackIndex: 0,
-            name: '温度',
-            color: '#f00',
-            unit: 'C',
-            point: pointWithErrors,
-          },
-        ],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    expect(wrapper.get('.waveform-tooltip__value').text()).toBe('(x:1 y:12)')
-    expect(wrapper.get('.waveform-tooltip__value').text()).not.toContain('C')
-    expect(wrapper.get('.waveform-tooltip__value').text()).not.toContain('+2')
-  })
-
-  it('renders the configured shot number, channel, and formatted coordinates', () => {
-    const hoveredPoint = { x: 1, y: -1405.4932 }
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 10, y: 10 },
-        timeUnit: 'ms',
-        hoveredPoint,
-        seriesPoints: [
-          {
-            trackIndex: 0,
-            name: 'ENG8KJXAc(10001)',
-            shotNo: '炮 7',
-            color: '#ffb43b',
-            unit: 'A',
-            point: hoveredPoint,
-          },
-        ],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    expect(wrapper.get('.waveform-tooltip__series-label').text()).toBe('炮 7： ENG8KJXAc(10001)(A)')
-    expect(wrapper.get('.waveform-tooltip__value').text()).toBe('(x:1,000 y:-1,405.4932)')
-  })
-
-  it('renders each series row with the formatted x coordinate and series label', () => {
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 10, y: 10 },
-        timeUnit: 's',
-        hoveredPoint: { x: 1.234567, y: 12 },
-        seriesPoints: [
-          { trackIndex: 0, name: '温度', color: '#f00', point: { x: 1.234567, y: 12 } },
-        ],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    expect(wrapper.find('.waveform-tooltip__time').exists()).toBe(false)
-    expect(wrapper.get('.waveform-tooltip__series-label').text()).toBe('未配置炮号： 温度')
-    expect(wrapper.get('.waveform-tooltip__value').text()).toBe('(x:1.2346 y:12)')
-  })
-
-  it('uses the fallback shot number when shotNo is blank', () => {
-    const point = { x: 1, y: 12 }
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 10, y: 10 },
-        timeUnit: 's',
-        hoveredPoint: point,
-        seriesPoints: [{ trackIndex: 0, name: '温度', color: '#f00', point }],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    expect(wrapper.get('.waveform-tooltip__series-label').text()).toBe('未配置炮号： 温度')
-  })
-
-  it('uses each series sample time and marks unavailable series without synthesizing values', () => {
-    const wrapper = mount(WaveformTooltip, {
-      props: {
-        visible: true,
-        position: { x: 10, y: 10 },
-        timeUnit: 's',
-        hoveredPoint: { x: 1, y: 12 },
-        seriesPoints: [
-          { trackIndex: 0, name: '完整数据', color: '#f00', point: { x: 1, y: 12 } },
-          { trackIndex: 1, name: '异步采样', color: '#0a0', point: { x: 1.25, y: 8 } },
-          { trackIndex: 2, name: '缺失数据', color: '#00f', point: null },
-        ],
-        containerWidth: 400,
-        containerHeight: 300,
-      },
-    })
-
-    const values = wrapper.findAll('.waveform-tooltip__value').map((value) => value.text())
-    expect(values).toEqual(['(x:1 y:12)', '(x:1.25 y:8)', '无数据'])
-  })
-})