mirror of
https://github.com/mum4k/termdash.git
synced 2025-04-25 13:48:50 +08:00
596 lines
12 KiB
Go
596 lines
12 KiB
Go
// Copyright 2019 Google Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package table
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/kylelemons/godebug/pretty"
|
|
"github.com/mum4k/termdash/linestyle"
|
|
)
|
|
|
|
func TestColumnWidths(t *testing.T) {
|
|
tests := []struct {
|
|
desc string
|
|
columns Columns
|
|
rows []*Row
|
|
opts []ContentOption
|
|
cvsWidth int
|
|
want []columnWidth
|
|
wantErr bool
|
|
}{
|
|
{
|
|
desc: "single column, wide enough",
|
|
columns: Columns(1),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
),
|
|
},
|
|
cvsWidth: 2,
|
|
want: []columnWidth{2},
|
|
},
|
|
{
|
|
desc: "single column, not wide enough",
|
|
columns: Columns(1),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
),
|
|
},
|
|
cvsWidth: 1,
|
|
want: []columnWidth{1},
|
|
},
|
|
{
|
|
desc: "plenty of width, prefers equal split",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{3, 3},
|
|
},
|
|
{
|
|
desc: "accounts for space needed for the border",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
Border(linestyle.Light),
|
|
},
|
|
cvsWidth: 7,
|
|
want: []columnWidth{2, 4},
|
|
},
|
|
{
|
|
desc: "horizontal padding at content level trims",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
HorizontalPadding(1),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{1, 5},
|
|
},
|
|
{
|
|
desc: "padding larger than width",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
HorizontalPadding(7),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{1, 5},
|
|
},
|
|
{
|
|
desc: "horizontal padding at row level trims",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRowWithOpts(
|
|
[]*Cell{
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
},
|
|
RowHorizontalPadding(1),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{1, 5},
|
|
},
|
|
{
|
|
desc: "horizontal padding at cell level trims",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCellWithOpts(
|
|
[]*Data{
|
|
NewData("cde"),
|
|
},
|
|
CellHorizontalPadding(1),
|
|
),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{1, 5},
|
|
},
|
|
{
|
|
desc: "two columns, canvas wide enough, no trimming",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 5,
|
|
want: []columnWidth{2, 3},
|
|
},
|
|
{
|
|
desc: "two columns, canvas not wide enough, user specified widths",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
ColumnWidthsPercent(99, 1),
|
|
},
|
|
cvsWidth: 4,
|
|
want: []columnWidth{3, 1},
|
|
},
|
|
{
|
|
desc: "fails when canvas width not enough for user specified widths",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
ColumnWidthsPercent(99, 1),
|
|
},
|
|
cvsWidth: 1,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
desc: "fails when canvas width not enough for optimized widths",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 1,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
desc: "two columns, canvas not wide enough, optimal to trim first",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 4,
|
|
want: []columnWidth{1, 3},
|
|
},
|
|
{
|
|
desc: "cells that wrap aren't accounted for, wrap configured at cell level",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCellWithOpts(
|
|
[]*Data{
|
|
NewData("cde"),
|
|
},
|
|
CellWrapAtWords(),
|
|
),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCellWithOpts(
|
|
[]*Data{
|
|
NewData("cde"),
|
|
},
|
|
CellWrapAtWords(),
|
|
),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCellWithOpts(
|
|
[]*Data{
|
|
NewData("cde"),
|
|
},
|
|
CellWrapAtWords(),
|
|
),
|
|
),
|
|
},
|
|
cvsWidth: 4,
|
|
want: []columnWidth{2, 2},
|
|
},
|
|
{
|
|
desc: "cells that wrap aren't accounted for, wrap configured at content level",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("cde"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
opts: []ContentOption{
|
|
WrapAtWords(),
|
|
},
|
|
cvsWidth: 4,
|
|
want: []columnWidth{2, 2},
|
|
},
|
|
{
|
|
desc: "two columns, canvas not wide enough, optimal to trim second",
|
|
columns: Columns(2),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("c"),
|
|
),
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("c"),
|
|
),
|
|
NewRow(
|
|
NewCell(""),
|
|
NewCell("cde"),
|
|
),
|
|
},
|
|
cvsWidth: 4,
|
|
want: []columnWidth{2, 2},
|
|
},
|
|
{
|
|
desc: "three columns, canvas wide enough, no trimming",
|
|
columns: Columns(3),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
NewCell("fg"),
|
|
),
|
|
NewRow(
|
|
NewCell("a"),
|
|
NewCell("c"),
|
|
NewCell("f"),
|
|
),
|
|
NewRow(
|
|
NewCell("ab"),
|
|
NewCell("cde"),
|
|
NewCell("fg"),
|
|
),
|
|
},
|
|
cvsWidth: 7,
|
|
want: []columnWidth{2, 3, 2},
|
|
},
|
|
{
|
|
desc: "three columns, canvas not wide enough, one very long cell",
|
|
columns: Columns(3),
|
|
rows: []*Row{
|
|
NewRow(
|
|
NewCell("00"),
|
|
NewCell("11111111"),
|
|
NewCell("22"),
|
|
),
|
|
NewRow(
|
|
NewCell("00"),
|
|
NewCell("11"),
|
|
NewCell("22"),
|
|
),
|
|
NewRow(
|
|
NewCell("00"),
|
|
NewCell("111"),
|
|
NewCell("22"),
|
|
),
|
|
},
|
|
cvsWidth: 6,
|
|
want: []columnWidth{2, 2, 2},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.desc, func(t *testing.T) {
|
|
content, err := NewContent(tc.columns, tc.rows, tc.opts...)
|
|
if err != nil {
|
|
t.Fatalf("NewContent => unexpected error: %v", err)
|
|
}
|
|
|
|
got, err := columnWidths(content, tc.cvsWidth)
|
|
if (err != nil) != tc.wantErr {
|
|
t.Errorf("columnWidths => unexpected error: %v, wantErr: %v", err, tc.wantErr)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
if diff := pretty.Compare(tc.want, got); diff != "" {
|
|
t.Errorf("columnWidths => unexpected diff (-want, +got):\n%s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkColumnWidths(b *testing.B) {
|
|
for n := 0; n < b.N; n++ {
|
|
content, err := NewContent(Columns(10), nil)
|
|
if err != nil {
|
|
b.Fatalf("NewContent => unexpected error: %v", err)
|
|
}
|
|
content.AddRows([]*Row{
|
|
NewRow(NewCell("00")),
|
|
NewRow(NewCell("11")),
|
|
NewRow(NewCell("2222")),
|
|
NewRow(NewCell("33")),
|
|
NewRow(NewCell("44")),
|
|
NewRow(NewCell("555")),
|
|
NewRow(NewCell("6666")),
|
|
NewRow(NewCell("7")),
|
|
NewRow(NewCell("88888")),
|
|
NewRow(NewCell("999999")),
|
|
})
|
|
content.AddRows([]*Row{
|
|
NewRow(NewCell("00000")),
|
|
NewRow(NewCell("11")),
|
|
NewRow(NewCell("2222")),
|
|
NewRow(NewCell("33")),
|
|
NewRow(NewCell("444")),
|
|
NewRow(NewCell("555")),
|
|
NewRow(NewCell("66")),
|
|
NewRow(NewCell("7")),
|
|
NewRow(NewCell("888")),
|
|
NewRow(NewCell("999")),
|
|
})
|
|
content.AddRows([]*Row{
|
|
NewRow(NewCell("000000")),
|
|
NewRow(NewCell("11")),
|
|
NewRow(NewCell("2222")),
|
|
NewRow(NewCell("3333333")),
|
|
NewRow(NewCell("44")),
|
|
NewRow(NewCell("555555555555555")),
|
|
NewRow(NewCell("6")),
|
|
NewRow(NewCell("7")),
|
|
NewRow(NewCell("8")),
|
|
NewRow(NewCell("999999")),
|
|
})
|
|
columnWidths(content, 30)
|
|
}
|
|
}
|
|
|
|
func TestSplitToPercent(t *testing.T) {
|
|
tests := []struct {
|
|
desc string
|
|
cvsWidth int
|
|
widthsPercent []int
|
|
want []columnWidth
|
|
wantErr bool
|
|
}{
|
|
{
|
|
desc: "fails for zero canvas width",
|
|
wantErr: true,
|
|
},
|
|
{
|
|
desc: "fails when no widths provided",
|
|
cvsWidth: 10,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
desc: "fails when we don't have at least one cell per column",
|
|
cvsWidth: 2,
|
|
widthsPercent: []int{10, 50, 20},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
desc: "single column",
|
|
cvsWidth: 15,
|
|
widthsPercent: []int{100},
|
|
want: []columnWidth{15},
|
|
},
|
|
{
|
|
desc: "divides evenly into the percentages",
|
|
cvsWidth: 10,
|
|
widthsPercent: []int{10, 50, 20, 10, 10},
|
|
want: []columnWidth{1, 5, 2, 1, 1},
|
|
},
|
|
{
|
|
desc: "divides unevenly into the percentages, last is the largest",
|
|
cvsWidth: 3,
|
|
widthsPercent: []int{10, 90},
|
|
want: []columnWidth{1, 2},
|
|
},
|
|
{
|
|
desc: "divides unevenly into the percentages, first is the largest",
|
|
cvsWidth: 3,
|
|
widthsPercent: []int{90, 10},
|
|
want: []columnWidth{2, 1},
|
|
},
|
|
{
|
|
desc: "each column is given at least one cell",
|
|
cvsWidth: 3,
|
|
widthsPercent: []int{10, 80, 10},
|
|
want: []columnWidth{1, 1, 1},
|
|
},
|
|
{
|
|
desc: "leaves at least one cell for each remaining column",
|
|
cvsWidth: 6,
|
|
widthsPercent: []int{99, 1, 1, 1, 1},
|
|
want: []columnWidth{2, 1, 1, 1, 1},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.desc, func(t *testing.T) {
|
|
got, err := splitToPercent(tc.cvsWidth, tc.widthsPercent)
|
|
if (err != nil) != tc.wantErr {
|
|
t.Errorf("splitToPercent => unexpected error: %v, wantErr: %v", err, tc.wantErr)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
if diff := pretty.Compare(tc.want, got); diff != "" {
|
|
t.Errorf("splitToPercent => unexpected diff (-want, +got):\n%s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSplitEqually(t *testing.T) {
|
|
tests := []struct {
|
|
desc string
|
|
cvsWidth int
|
|
columns int
|
|
want []columnWidth
|
|
}{
|
|
{
|
|
desc: "single column",
|
|
cvsWidth: 9,
|
|
columns: 1,
|
|
want: []columnWidth{9},
|
|
},
|
|
{
|
|
desc: "splits evenly",
|
|
cvsWidth: 9,
|
|
columns: 3,
|
|
want: []columnWidth{3, 3, 3},
|
|
},
|
|
{
|
|
desc: "splits unevenly",
|
|
cvsWidth: 10,
|
|
columns: 3,
|
|
want: []columnWidth{3, 3, 4},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.desc, func(t *testing.T) {
|
|
got := splitEqually(tc.cvsWidth, tc.columns)
|
|
if diff := pretty.Compare(tc.want, got); diff != "" {
|
|
t.Errorf("splitEqually => unexpected diff (-want, +got):\n%s", diff)
|
|
}
|
|
|
|
})
|
|
}
|
|
}
|