`${value / 1_000_000}M`}
+ />,
+ )
+ expect(screen.getByTestId('chart-y-ticks')).toHaveTextContent('1M')
+ expect(screen.getByTestId('chart-x-labels')).toHaveTextContent('2M')
+ })
+})
+
+describe('ChartLegend', () => {
+ it('renders each series as a labelled list item', () => {
+ render(
+
+
pan left
+
+ pan right
+
reset
@@ -130,6 +133,73 @@ describe('useGenomeBrowser', () => {
fireEvent.click(screen.getByTestId('reset'))
expect(screen.getByTestId('viewport').textContent).toBe('chr1:1-100')
})
+
+ it('pans right and returns to the initial viewport on reset', () => {
+ render(
+
+ {browser.viewport.chromosome}:{browser.viewport.start}-{browser.viewport.end}
+
+ browser.navigateTo({ chromosome: 'chr1', start: -50, end: 50 })}
+ >
+ go
+
+
+ )
+ }
+ render(
+
+ {browser.viewport.chromosome}:{browser.viewport.start}-{browser.viewport.end}
+
+ browser.navigateTo({ chromosome: 'chr2', start: 300, end: 400 })}
+ >
+ go
+
+
+ )
+ }
+ render(
+ {track.status}
+
+ zoom in
+
+
+ )
+ }
+
+ render((() => undefined)
+ })
+ const definition: GenomeTrackDefinition = {
+ id: 'genes',
+ label: 'Genes',
+ kind: 'genes',
+ loader: loadGenes,
+ }
+
+ function BrowserWithTrack() {
+ const browser = useGenomeBrowser({
+ initialViewport: { chromosome: 'chr1', start: 1, end: 100 },
+ debounceMs: 200,
+ })
+ const track = useGenomeTrack(definition, browser.debouncedViewport)
+ return (
+
+ {track.status}
+
+ zoom in
+
+
+ )
+ }
+
+ render((viewport: V, delta: number
}
if (endLimit !== undefined && end > endLimit) {
end = endLimit
- start = end - span + 1
+ start = Math.max(1, end - span + 1)
}
return { ...viewport, start, end, bounds: viewport.bounds } as V
diff --git a/apps/web/src/lib/scientific/advancedApi.test.ts b/apps/web/src/lib/scientific/advancedApi.test.ts
index 03e91a4..a41a9f4 100644
--- a/apps/web/src/lib/scientific/advancedApi.test.ts
+++ b/apps/web/src/lib/scientific/advancedApi.test.ts
@@ -1,9 +1,15 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
+import { API_BASE_URL, GenomeApiError } from '@/lib/genome/api'
+
import { TP53_PATHWAY_HEATMAP_FIXTURE } from './advanced.fixtures'
import {
coverageFromRecords,
distributionFromRecords,
+ fetchCoverageDataset,
+ fetchDistributionDataset,
+ fetchHeatmapDataset,
+ fetchVolcanoDataset,
heatmapFromRecords,
toCoverageBin,
toDistributionValue,
@@ -11,7 +17,18 @@ import {
volcanoFromRecords,
} from './advancedApi'
+const rawFetch = globalThis.fetch
+
+function jsonResponse(payload: unknown) {
+ return {
+ ok: true,
+ status: 200,
+ json: () => Promise.resolve(payload),
+ } as Response
+}
+
afterEach(() => {
+ globalThis.fetch = rawFetch
vi.restoreAllMocks()
})
@@ -141,3 +158,88 @@ describe('toDistributionValue / distributionFromRecords', () => {
expect(distribution?.values.map((value) => value.group)).toEqual(['Normal', 'Tumor'])
})
})
+
+describe('fetch*Dataset adapters', () => {
+ it('fetches and normalizes a heatmap dataset', async () => {
+ const fetchMock = vi.fn().mockResolvedValue(
+ jsonResponse({
+ id: 'h-live',
+ title: 'Live',
+ rows: ['b', 'a'],
+ columns: ['y', 'x'],
+ values: [
+ [1, 2],
+ [3, 4],
+ ],
+ }),
+ )
+ globalThis.fetch = fetchMock as unknown as typeof fetch
+
+ const dataset = await fetchHeatmapDataset('h-live', new AbortController().signal)
+ expect(dataset.rows).toEqual(['a', 'b'])
+ expect(dataset.columns).toEqual(['x', 'y'])
+
+ const [url] = fetchMock.mock.calls[0] as [string]
+ expect(url).toBe(`${API_BASE_URL}/advanced/heatmaps/h-live`)
+ })
+
+ it('throws a typed GenomeApiError on non-2xx responses', async () => {
+ globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 } as unknown as Response)
+
+ await expect(fetchHeatmapDataset('missing')).rejects.toMatchObject({
+ name: 'GenomeApiError',
+ status: 404,
+ })
+ })
+
+ it('rethrows an AbortError from an unreadable response', async () => {
+ globalThis.fetch = vi.fn().mockResolvedValue({
+ ok: true,
+ status: 200,
+ json: () => Promise.reject(new DOMException('aborted', 'AbortError')),
+ } as unknown as Response)
+
+ await expect(fetchVolcanoDataset('v')).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('throws a GenomeApiError when the payload is invalid', async () => {
+ globalThis.fetch = vi.fn().mockResolvedValue(jsonResponse({ items: [] }))
+
+ await expect(fetchDistributionDataset('d-bad')).rejects.toBeInstanceOf(GenomeApiError)
+ })
+
+ it('normalizes volcano, coverage, and distribution payloads', async () => {
+ globalThis.fetch = vi
+ .fn()
+ .mockResolvedValueOnce(
+ jsonResponse({
+ id: 'v-live',
+ title: 'V',
+ points: [{ identifier: 'g1', effect_size: 1.5, significance: 4 }],
+ }),
+ )
+ .mockResolvedValueOnce(
+ jsonResponse({
+ id: 'c-live',
+ title: 'C',
+ bins: [{ chromosome: 'chr1', start: 1, end: 10, coverage: 3 }],
+ }),
+ )
+ .mockResolvedValueOnce(
+ jsonResponse({
+ id: 'd-live',
+ title: 'D',
+ values: [{ group: 'Tumor', value: 2 }],
+ }),
+ )
+
+ const volcano = await fetchVolcanoDataset('v-live')
+ expect(volcano.points[0]?.effectSize).toBe(1.5)
+
+ const coverage = await fetchCoverageDataset('c-live')
+ expect(coverage.bins[0]?.coverage).toBe(3)
+
+ const distribution = await fetchDistributionDataset('d-live')
+ expect(distribution.values[0]?.value).toBe(2)
+ })
+})
diff --git a/apps/web/src/lib/scientific/downsample.test.ts b/apps/web/src/lib/scientific/downsample.test.ts
index 4c82a02..ff7a947 100644
--- a/apps/web/src/lib/scientific/downsample.test.ts
+++ b/apps/web/src/lib/scientific/downsample.test.ts
@@ -36,6 +36,39 @@ describe('decimateItems', () => {
expect(sampled.length).toBeLessThan(items.length)
expect(sampled).toEqual([...sampled].sort((a, b) => a - b))
})
+
+ it('returns the same array when the length exactly matches the limit', () => {
+ const items = [1, 2, 3, 4, 5]
+ expect(decimateItems(items, 5)).toBe(items)
+ })
+
+ it('returns the same (empty) array for an empty input', () => {
+ const items: number[] = []
+ expect(decimateItems(items, 5)).toBe(items)
+ })
+
+ it('returns an empty sample for a negative limit', () => {
+ expect(decimateItems([1, 2, 3], -2)).toEqual([])
+ })
+
+ it('returns exactly the first element when the limit is one', () => {
+ const sampled = decimateItems([1, 2, 3, 4], 1)
+ expect([...sampled]).toEqual([1])
+ })
+
+ it('returns exactly the first and last elements when the limit is two', () => {
+ const sampled = decimateItems([1, 2, 3, 4, 5, 6, 7], 2)
+ expect([...sampled]).toEqual([1, 7])
+ })
+
+ it('samples odd-sized inputs deterministically with first and last preserved', () => {
+ const items = [0, 1, 2, 3, 4, 5, 6]
+ const sampled = [...decimateItems(items, 3)]
+ expect(sampled[0]).toBe(0)
+ expect(sampled[sampled.length - 1]).toBe(6)
+ expect(sampled.length).toBeLessThanOrEqual(3)
+ expect(sampled).toEqual([...sampled].sort((a, b) => a - b))
+ })
})
describe('coverageColumns', () => {
@@ -96,6 +129,78 @@ describe('coverageColumns', () => {
}))
expect(coverageColumns(bins, toX, 300, 80)).toEqual(coverageColumns(bins, toX, 300, 80))
})
+
+ it('returns the same bins for a non-positive column limit or plot width', () => {
+ const bins: CoverageBin[] = [
+ { chromosome: 'chr1', start: 1, end: 10, coverage: 5 },
+ { chromosome: 'chr1', start: 11, end: 20, coverage: 8 },
+ ]
+ expect(coverageColumns(bins, toX, 100, 0)).toBe(bins)
+ expect(coverageColumns(bins, toX, 0, 50)).toBe(bins)
+ expect(coverageColumns(bins, toX, -1, 50)).toBe(bins)
+ })
+
+ it('returns the same bins when the count exactly matches the column limit', () => {
+ const bins: CoverageBin[] = [
+ { chromosome: 'chr1', start: 1, end: 10, coverage: 5 },
+ { chromosome: 'chr1', start: 11, end: 20, coverage: 8 },
+ ]
+ expect(coverageColumns(bins, toX, 100, 2)).toBe(bins)
+ })
+
+ it('collapses the whole track into one column carrying the global peak when the limit is one', () => {
+ const bins: CoverageBin[] = Array.from({ length: 100 }, (_, index) => ({
+ chromosome: 'chr1',
+ start: index * 10 + 1,
+ end: index * 10 + 10,
+ coverage: index % 7,
+ }))
+ const columns = coverageColumns(bins, toX, 200, 1)
+ expect(columns).toHaveLength(1)
+ expect(columns[0]?.coverage).toBe(6)
+ expect(columns[0]?.start).toBe(1)
+ expect(columns[0]?.end).toBe(1000)
+ })
+
+ it('merges bins into the span of the whole bucket and keeps the first chromosome', () => {
+ const bins: CoverageBin[] = [
+ { chromosome: 'chr1', start: 10, end: 20, coverage: 1 },
+ { chromosome: 'chr2', start: 30, end: 40, coverage: 5 },
+ { chromosome: 'chr1', start: 50, end: 60, coverage: 2 },
+ ]
+ const columns = coverageColumns(bins, toX, 10, 1)
+ expect(columns).toHaveLength(1)
+ expect(columns[0]?.start).toBe(10)
+ expect(columns[0]?.end).toBe(60)
+ expect(columns[0]?.chromosome).toBe('chr1')
+ })
+
+ it('returns columns sorted ascending by start', () => {
+ const bins: CoverageBin[] = Array.from({ length: 500 }, (_, index) => ({
+ chromosome: 'chr1',
+ start: index * 5 + 1,
+ end: index * 5 + 5,
+ coverage: 1,
+ }))
+ const columns = coverageColumns(bins, toX, 50, 10)
+ const starts = columns.map((column) => column.start)
+ expect(starts).toEqual([...starts].sort((a, b) => a - b))
+ })
+
+ it('clamps bins mapped to negative pixels into the first bucket', () => {
+ const toNegative = () => -5
+ const bins: CoverageBin[] = Array.from({ length: 8 }, (_, index) => ({
+ chromosome: 'chr1',
+ start: index * 10 + 1,
+ end: index * 10 + 10,
+ coverage: index % 4,
+ }))
+ const columns = coverageColumns(bins, toNegative, 100, 5)
+ expect(columns).toHaveLength(1)
+ expect(columns[0]?.coverage).toBe(3)
+ expect(columns[0]?.start).toBe(1)
+ expect(columns[0]?.end).toBe(80)
+ })
})
describe('aggregateHeatmap', () => {
@@ -163,4 +268,123 @@ describe('aggregateHeatmap', () => {
// Whole matrix collapses to one block; finite values are 1 and 3.
expect(aggregated.values[0]?.[0]).toBe(2)
})
+
+ it('collapses a whole matrix to one block for non-positive limits', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h',
+ title: 'All',
+ rows: ['r1', 'r2', 'r3'],
+ columns: ['c1', 'c2', 'c3'],
+ values: [
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 9],
+ ],
+ }
+ for (const maxRows of [0, -1]) {
+ for (const maxCols of [0, -1]) {
+ const aggregated = aggregateHeatmap(dataset, maxRows, maxCols)
+ expect(aggregated.rows).toEqual(['r1'])
+ expect(aggregated.columns).toEqual(['c1'])
+ expect(aggregated.values[0]).toEqual([5])
+ }
+ }
+ })
+
+ it('aggregates along a single axis when only the other is oversized', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h',
+ title: 'ColumnsOnly',
+ rows: ['r1', 'r2'],
+ columns: ['c1', 'c2', 'c3', 'c4'],
+ values: [
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ ],
+ }
+ const rowsOnly = aggregateHeatmap(dataset, 1, 100)
+ expect(rowsOnly.rows).toEqual(['r1'])
+ expect(rowsOnly.columns).toEqual(['c1', 'c2', 'c3', 'c4'])
+ expect(rowsOnly.values[0]).toEqual([3, 4, 5, 6])
+
+ const colsOnly = aggregateHeatmap(dataset, 100, 2)
+ expect(colsOnly.rows).toEqual(['r1', 'r2'])
+ expect(colsOnly.columns).toEqual(['c1', 'c3'])
+ expect(colsOnly.values[0]).toEqual([1.5, 3.5])
+ expect(colsOnly.values[1]).toEqual([5.5, 7.5])
+ })
+
+ it('skips NaN and Infinity values when averaging a block', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h',
+ title: 'NonFinite',
+ rows: ['r1', 'r2'],
+ columns: ['c1'],
+ values: [[Number.NaN], [6]],
+ }
+ const aggregated = aggregateHeatmap(dataset, 1, 1)
+ expect(aggregated.values[0]?.[0]).toBe(6)
+
+ const infinite: HeatmapDataset = {
+ id: 'h2',
+ title: 'Infinite',
+ rows: ['r1', 'r2'],
+ columns: ['c1'],
+ values: [[Number.POSITIVE_INFINITY], [undefined]],
+ }
+ const aggregatedInfinite = aggregateHeatmap(infinite, 1, 1)
+ expect(aggregatedInfinite.values[0]?.[0]).toBeUndefined()
+ })
+
+ it('averages ragged boundary blocks', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h',
+ title: 'Ragged',
+ rows: ['r1', 'r2', 'r3', 'r4', 'r5'],
+ columns: ['c1', 'c2', 'c3', 'c4', 'c5'],
+ values: Array.from({ length: 5 }, (_, r) =>
+ Array.from({ length: 5 }, (_, c) => r * 5 + c + 1),
+ ),
+ }
+ const aggregated = aggregateHeatmap(dataset, 2, 2)
+ // Block size ceil(5/2) = 3, so rows/columns sample at indices 0 and 3.
+ expect(aggregated.rows).toEqual(['r1', 'r4'])
+ expect(aggregated.columns).toEqual(['c1', 'c4'])
+ // Bottom-right block spans rows r4..r5, columns c4..c5: mean(19,20,24,25) = 22.
+ expect(aggregated.values[1]?.[1]).toBe(22)
+ })
+
+ it('tolerates ragged rows with missing value arrays', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h',
+ title: 'MissingRow',
+ rows: ['r1', 'r2'],
+ columns: ['c1', 'c2'],
+ values: [[1, 2], undefined],
+ } as HeatmapDataset
+ const aggregated = aggregateHeatmap(dataset, 1, 1)
+ expect(aggregated.values[0]?.[0]).toBe(1.5)
+ })
+
+ it('propagates id, title, labels, and metadata through aggregation', () => {
+ const dataset: HeatmapDataset = {
+ id: 'h-id',
+ title: 'Named',
+ rows: ['r1', 'r2'],
+ columns: ['c1', 'c2'],
+ values: [
+ [1, 2],
+ [3, 4],
+ ],
+ rowLabels: { r1: 'Row One' },
+ columnLabels: { c1: 'Col One' },
+ metadata: { source: 'fixture' },
+ }
+ const aggregated = aggregateHeatmap(dataset, 1, 1)
+ expect(aggregated.id).toBe('h-id')
+ expect(aggregated.title).toBe('Named')
+ expect(aggregated.rowLabels).toEqual({ r1: 'Row One' })
+ expect(aggregated.columnLabels).toEqual({ c1: 'Col One' })
+ expect(aggregated.metadata).toEqual({ source: 'fixture' })
+ })
})
diff --git a/apps/web/src/lib/scientific/statistics.test.ts b/apps/web/src/lib/scientific/statistics.test.ts
index 4559a94..1bb5d48 100644
--- a/apps/web/src/lib/scientific/statistics.test.ts
+++ b/apps/web/src/lib/scientific/statistics.test.ts
@@ -28,6 +28,13 @@ describe('quantile', () => {
expect(quantile([1, 2, 3, 4], 0.5)).toBe(2.5)
})
+ it('interpolates at fractional ranks (R-7 convention)', () => {
+ // position = 0.25 * 3 = 0.75 → 1 + (2 - 1) * 0.75 = 1.75
+ expect(quantile([1, 2, 3, 4], 0.25)).toBe(1.75)
+ // position = 0.75 * 3 = 2.25 → 3 + (4 - 3) * 0.25 = 3.25
+ expect(quantile([1, 2, 3, 4], 0.75)).toBe(3.25)
+ })
+
it('returns min/max for q=0 and q=1', () => {
expect(quantile([1, 2, 3], 0)).toBe(1)
expect(quantile([1, 2, 3], 1)).toBe(3)
@@ -61,6 +68,24 @@ describe('summarize', () => {
it('returns undefined for an empty sample', () => {
expect(summarize([])).toBeUndefined()
})
+
+ it('summarizes a single-element sample with a zero IQR', () => {
+ const summary = summarize([7])
+ expect(summary).toEqual({
+ count: 1,
+ mean: 7,
+ min: 7,
+ max: 7,
+ q1: 7,
+ q2: 7,
+ q3: 7,
+ iqr: 0,
+ })
+ })
+
+ it('ignores non-finite values while summarizing', () => {
+ expect(summarize([1, Number.NaN, Number.POSITIVE_INFINITY, 3])?.count).toBe(2)
+ })
})
describe('boxPlotWhiskers', () => {
@@ -82,4 +107,17 @@ describe('boxPlotWhiskers', () => {
it('returns undefined for an empty sample', () => {
expect(boxPlotWhiskers([])).toBeUndefined()
})
+
+ it('reports low-side outliers below the lower whisker', () => {
+ const whiskers = boxPlotWhiskers([-100, 1, 2, 3, 4, 5, 6, 7, 8])
+ expect(whiskers?.lower).toBe(1)
+ expect(whiskers?.outliers).toEqual([-100])
+ })
+
+ it('collapses whiskers when every value is identical', () => {
+ const whiskers = boxPlotWhiskers([5, 5, 5, 5])
+ expect(whiskers?.lower).toBe(5)
+ expect(whiskers?.upper).toBe(5)
+ expect(whiskers?.outliers).toEqual([])
+ })
})
diff --git a/apps/web/src/lib/scientific/useChartSize.test.tsx b/apps/web/src/lib/scientific/useChartSize.test.tsx
new file mode 100644
index 0000000..98bc7ba
--- /dev/null
+++ b/apps/web/src/lib/scientific/useChartSize.test.tsx
@@ -0,0 +1,109 @@
+import { act, cleanup, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { DEFAULT_CHART_WIDTH } from './geometry'
+import { useChartSize } from './useChartSize'
+
+function Probe({ height, fallbackWidth }: { height: number; fallbackWidth?: number }) {
+ const size = useChartSize(height, fallbackWidth)
+ return (
+ <>
+
+ {size.width}
+
+ {size.height}
+
+ )
+}
+
+class FakeResizeObserver {
+ static instances: FakeResizeObserver[] = []
+ callback: ResizeObserverCallback
+ observed: Element[] = []
+ disconnected = false
+
+ constructor(callback: ResizeObserverCallback) {
+ this.callback = callback
+ FakeResizeObserver.instances.push(this)
+ }
+
+ observe(target: Element) {
+ this.observed.push(target)
+ }
+
+ unobserve() {}
+
+ disconnect() {
+ this.disconnected = true
+ }
+}
+
+const realResizeObserver = globalThis.ResizeObserver
+
+afterEach(() => {
+ cleanup()
+ globalThis.ResizeObserver = realResizeObserver
+ FakeResizeObserver.instances = []
+ vi.restoreAllMocks()
+})
+
+describe('useChartSize', () => {
+ it('uses the default fallback width and fixed height before measurement', () => {
+ render(()
+ const second = deferred()
+ let callCount = 0
+ const loader = () => (callCount++ === 0 ? first.promise : second.promise)
+
+ render( Promise.reject('plain string failure')} />)
+ await waitFor(() => expect(statusText()).toBe('error'))
+ expect(screen.getByTestId('error').textContent).toBe('plain string failure')
+ cleanup()
+
+ render( Promise.reject({ message: 'object failure' })} />)
+ await waitFor(() => expect(statusText()).toBe('error'))
+ expect(screen.getByTestId('error').textContent).toBe('object failure')
+ })
+
+ it('clears the previous data while a refetch is loading', async () => {
+ const first = deferred()
+ const second = deferred()
+ let callCount = 0
+ const loader = () => (callCount++ === 0 ? first.promise : second.promise)
+
+ render(` from
+ `apps/web`.
+- Full project: `make test` (web + backend pytest).
+
+## Intentional gaps
+
+- **No timing-based performance benchmarks**: Phase 6.10 coverage is
+ deterministic (downsampling output is asserted, not timed).
+- **Per-pixel / visual-regression tests** are out of scope for now; SVG
+ geometry is asserted through the pure `lib/*/geometry` modules instead.
+- Future visualization milestones should keep the per-module testing
+ convention documented here (pure modules unit-tested, components exercised
+ through Testing Library with role/name queries, a11y semantics asserted).
\ No newline at end of file
diff --git a/docs/visualization/variant.md b/docs/visualization/variant.md
index 2bdb728..f273798 100644
--- a/docs/visualization/variant.md
+++ b/docs/visualization/variant.md
@@ -45,7 +45,7 @@ Implemented on branch `feat/visualization-variant`.
- D3.js / Three.js / Cytoscape.js / WebAssembly / WebGPU / C++ (see
[README](README.md) technology notes)
- Dense variant-call / histogram density rendering at population scale
- (deferred to 6.9 performance work)
+ (measured future option; see [Performance](performance.md))
- Protein / network / chart views (6.5–6.7)
## Architecture and data flow
diff --git a/docs/visualization/workspace.md b/docs/visualization/workspace.md
index 741b352..0b15e31 100644
--- a/docs/visualization/workspace.md
+++ b/docs/visualization/workspace.md
@@ -169,10 +169,12 @@ Every panel routes through the shared lifecycle (`useVisualizationData` /
| `lib/workspace/dataSources.test.ts` | `resolveFixture` contract (resolve / abort / no cache) |
| `components/workspace/fixtureDataSources.test.ts` | interval filtering, abort handling, fixture resolution for every loader |
| `components/workspace/ResearchContextSelector.test.tsx` | labeled select, aria-live output, preset change, valid/invalid custom region, alert |
-| `components/workspace/ResearchWorkspace.test.tsx` | panel rendering, context→browser sync, custom-region navigation, gene empty state, panel error + retry, controls a11y |
+| `components/workspace/ResearchWorkspace.test.tsx` | panel rendering, context→browser sync, custom-region navigation, gene empty state, panel error + retry, loading state, whole-dataset panel independence, controls a11y |
-Existing tests are unchanged; the full suite must stay green (see
-`Makefile` targets `lint` / `typecheck` / `test` / `build`).
+Phase 6.11 added the loading-state, panel error, and context-change
+independence tests (30 workspace tests today). Existing tests are unchanged;
+the full suite must stay green (see `Makefile` targets `lint` / `typecheck` /
+`test` / `build`).
## Limitations