554 lines
13 KiB
Go
554 lines
13 KiB
Go
package wpdf
|
|
|
|
import (
|
|
"bytes"
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
func TestTableBuilderInitialState(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
tb := b.Table()
|
|
|
|
if tb == nil {
|
|
t.Fatal("Table() returned nil")
|
|
}
|
|
if tb.builder != b {
|
|
t.Error("builder back-reference not set")
|
|
}
|
|
if tb.padx != 2 {
|
|
t.Errorf("default padx = %v, want 2", tb.padx)
|
|
}
|
|
if tb.pady != 2 {
|
|
t.Errorf("default pady = %v, want 2", tb.pady)
|
|
}
|
|
if tb.defaultCellStyle == nil {
|
|
t.Error("default cell style is nil")
|
|
}
|
|
if tb.RowCount() != 0 {
|
|
t.Errorf("RowCount = %v, want 0", tb.RowCount())
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderConfig(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := NewTableCellStyleOpt()
|
|
tb := b.Table().
|
|
PadX(5).
|
|
PadY(7).
|
|
Widths("10", "20", "auto").
|
|
DefaultStyle(style).
|
|
Debug(true)
|
|
|
|
if tb.padx != 5 {
|
|
t.Errorf("padx = %v, want 5", tb.padx)
|
|
}
|
|
if tb.pady != 7 {
|
|
t.Errorf("pady = %v, want 7", tb.pady)
|
|
}
|
|
if tb.columnWidths == nil || len(*tb.columnWidths) != 3 {
|
|
t.Errorf("columnWidths not set correctly: %v", tb.columnWidths)
|
|
}
|
|
if tb.defaultCellStyle != style {
|
|
t.Error("defaultCellStyle not set")
|
|
}
|
|
if tb.debug == nil || !*tb.debug {
|
|
t.Error("debug not set")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderAddRowDefault(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
tb := b.Table().AddRowDefaultStyle("a", "b", "c")
|
|
if tb.RowCount() != 1 {
|
|
t.Errorf("RowCount = %v, want 1", tb.RowCount())
|
|
}
|
|
if len(tb.rows[0].cells) != 3 {
|
|
t.Errorf("cells = %v, want 3", len(tb.rows[0].cells))
|
|
}
|
|
if tb.rows[0].cells[0].Content != "a" {
|
|
t.Errorf("cell[0].Content = %q, want %q", tb.rows[0].cells[0].Content, "a")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderAddRowWithStyle(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := NewTableCellStyleOpt().Bold().FontSize(10)
|
|
|
|
tb := b.Table().AddRowWithStyle(style, "x", "y")
|
|
if tb.RowCount() != 1 {
|
|
t.Fatalf("RowCount = %v, want 1", tb.RowCount())
|
|
}
|
|
if len(tb.rows[0].cells) != 2 {
|
|
t.Fatalf("cells = %v, want 2", len(tb.rows[0].cells))
|
|
}
|
|
for i, c := range tb.rows[0].cells {
|
|
if c.Style.fontStyleOverride == nil || *c.Style.fontStyleOverride != Bold {
|
|
t.Errorf("cell[%d] style not Bold", i)
|
|
}
|
|
if c.Style.fontSizeOverride == nil || *c.Style.fontSizeOverride != 10 {
|
|
t.Errorf("cell[%d] fontSize not 10", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderAddRow(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
tc := TableCell{Content: "hello", Style: TableCellStyleOpt{}}
|
|
tb := b.Table().AddRow(tc, tc)
|
|
if tb.RowCount() != 1 || len(tb.rows[0].cells) != 2 {
|
|
t.Errorf("AddRow did not add expected cells")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderBuildRowFlow(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
|
|
tb := b.Table().
|
|
BuildRow().Cell("a").Cell("b").Cell("c").BuildRow().
|
|
BuildRow().Cells("d", "e", "f").BuildRow()
|
|
|
|
if tb.RowCount() != 2 {
|
|
t.Errorf("RowCount = %v, want 2", tb.RowCount())
|
|
}
|
|
if len(tb.rows[0].cells) != 3 || len(tb.rows[1].cells) != 3 {
|
|
t.Errorf("each row should have 3 cells; got %d and %d",
|
|
len(tb.rows[0].cells), len(tb.rows[1].cells))
|
|
}
|
|
if tb.rows[0].cells[0].Content != "a" || tb.rows[1].cells[2].Content != "f" {
|
|
t.Error("cell content mismatch")
|
|
}
|
|
}
|
|
|
|
func TestTableRowBuilderCellWithStyle(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := NewTableCellStyleOpt().Bold()
|
|
tb := b.Table().BuildRow().CellWithStyle("x", style).BuildRow()
|
|
|
|
if tb.rows[0].cells[0].Style.fontStyleOverride == nil ||
|
|
*tb.rows[0].cells[0].Style.fontStyleOverride != Bold {
|
|
t.Error("cell style not applied")
|
|
}
|
|
}
|
|
|
|
func TestTableRowBuilderCellObjects(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
c1 := TableCell{Content: "alpha"}
|
|
c2 := TableCell{Content: "beta"}
|
|
|
|
tb := b.Table().BuildRow().CellObject(c1).CellObjects(c2).BuildRow()
|
|
if len(tb.rows[0].cells) != 2 {
|
|
t.Fatalf("cells = %v, want 2", len(tb.rows[0].cells))
|
|
}
|
|
if tb.rows[0].cells[0].Content != "alpha" || tb.rows[0].cells[1].Content != "beta" {
|
|
t.Error("cell objects not added")
|
|
}
|
|
}
|
|
|
|
func TestTableRowBuilderRowStyle(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
rowStyle := NewTableCellStyleOpt().Italic()
|
|
|
|
tb := b.Table().BuildRow().RowStyle(rowStyle).Cell("x").Cell("y").BuildRow()
|
|
|
|
for i, c := range tb.rows[0].cells {
|
|
if c.Style.fontStyleOverride == nil || *c.Style.fontStyleOverride != Italic {
|
|
t.Errorf("cell[%d] should use row style (Italic)", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTableMaxFontSize(t *testing.T) {
|
|
row := tableRow{
|
|
cells: []TableCell{
|
|
{Style: *NewTableCellStyleOpt().FontSize(10)},
|
|
{Style: *NewTableCellStyleOpt().FontSize(20)},
|
|
{Style: *NewTableCellStyleOpt().FontSize(15)},
|
|
},
|
|
}
|
|
got := row.maxFontSize(8)
|
|
if got != 20 {
|
|
t.Errorf("maxFontSize = %v, want 20", got)
|
|
}
|
|
|
|
rowEmpty := tableRow{cells: []TableCell{{Style: TableCellStyleOpt{}}}}
|
|
got = rowEmpty.maxFontSize(12)
|
|
if got != 12 {
|
|
t.Errorf("maxFontSize default = %v, want 12", got)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderBuildEmpty(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
// Should not panic when no rows
|
|
b.Table().Build()
|
|
}
|
|
|
|
func TestTableBuilderBuildNumeric(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("30", "30", "30").
|
|
AddRowDefaultStyle("a", "b", "c").
|
|
AddRowDefaultStyle("d", "e", "f").
|
|
Build()
|
|
|
|
bin, err := b.Build()
|
|
if err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
if !bytes.HasPrefix(bin, []byte("%PDF-")) {
|
|
t.Error("output not a PDF")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderBuildAuto(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("auto", "auto", "auto").
|
|
AddRowDefaultStyle("a", "b", "c").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderBuildFr(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("1fr", "2fr", "*").
|
|
AddRowDefaultStyle("a", "b", "c").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderMixedColumnSpecs(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("auto", "30", "1fr", "*").
|
|
AddRowDefaultStyle("a", "b", "c", "d").
|
|
AddRowDefaultStyle("longer text here", "x", "y", "z").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderNoColumnsDefined(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
// When Widths not specified, table uses "*" for each cell of first row
|
|
b.Table().
|
|
AddRowDefaultStyle("a", "b").
|
|
AddRowDefaultStyle("c", "d").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderMismatchedColumnCount(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("10", "10").
|
|
AddRowDefaultStyle("a", "b", "c"). // wrong column count
|
|
Build()
|
|
|
|
// Should produce an error in the underlying gofpdf, surfaced by Build()
|
|
_, err := b.Build()
|
|
if err == nil {
|
|
t.Error("expected error for mismatched column count, got nil")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderInvalidColumnWidth(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.Table().
|
|
Widths("not-a-number").
|
|
AddRowDefaultStyle("a").
|
|
Build()
|
|
|
|
_, err := b.Build()
|
|
if err == nil {
|
|
t.Error("expected error for invalid column width, got nil")
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderMultiCellRow(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := NewTableCellStyleOpt().MultiCell(true)
|
|
b.Table().
|
|
Widths("auto", "1fr").
|
|
AddRowWithStyle(style, "a", "Multi line\ntext content").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderEllipsizeRow(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := NewTableCellStyleOpt().MultiCell(false).Ellipsize(true)
|
|
b.Table().
|
|
Widths("20").
|
|
AddRowWithStyle(style, "this is a very long text that should be ellipsized").
|
|
Build()
|
|
|
|
if _, err := b.Build(); err != nil {
|
|
t.Fatalf("Build error: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTableBuilderDefaultTableStyle(t *testing.T) {
|
|
s := defaultTableStyle()
|
|
if s == nil {
|
|
t.Fatal("defaultTableStyle returned nil")
|
|
}
|
|
if s.minWidth == nil || *s.minWidth != 5 {
|
|
t.Errorf("default minWidth = %v, want 5", s.minWidth)
|
|
}
|
|
if s.ellipsize == nil || !*s.ellipsize {
|
|
t.Errorf("default ellipsize should be true")
|
|
}
|
|
if s.multiCell == nil || *s.multiCell {
|
|
t.Errorf("default multiCell should be false")
|
|
}
|
|
if s.fontSizeOverride == nil || *s.fontSizeOverride != 8 {
|
|
t.Errorf("default font size = %v, want 8", s.fontSizeOverride)
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptBuilders(t *testing.T) {
|
|
o := NewTableCellStyleOpt().
|
|
MultiCell(true).
|
|
Ellipsize(false).
|
|
PaddingHorz(3).
|
|
MinWidth(7).
|
|
FillHeight(true)
|
|
|
|
if !*o.multiCell {
|
|
t.Error("multiCell")
|
|
}
|
|
if *o.ellipsize {
|
|
t.Error("ellipsize")
|
|
}
|
|
if *o.paddingHorz != 3 {
|
|
t.Error("paddingHorz")
|
|
}
|
|
if *o.minWidth != 7 {
|
|
t.Error("minWidth")
|
|
}
|
|
if !*o.fillHeight {
|
|
t.Error("fillHeight")
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptCellStyle(t *testing.T) {
|
|
cell := *NewPDFCellOpt().Width(50).Bold()
|
|
o := NewTableCellStyleOpt().CellStyle(cell)
|
|
|
|
if o.PDFCellOpt.width == nil || *o.PDFCellOpt.width != 50 {
|
|
t.Error("CellStyle did not transfer width")
|
|
}
|
|
if o.PDFCellOpt.fontStyleOverride == nil || *o.PDFCellOpt.fontStyleOverride != Bold {
|
|
t.Error("CellStyle did not transfer style")
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptDelegates(t *testing.T) {
|
|
o := NewTableCellStyleOpt().
|
|
Width(10).
|
|
Height(20).
|
|
Border(BorderFull).
|
|
LnPos(BreakToBelow).
|
|
Align(AlignRight).
|
|
FillBackground(true).
|
|
Link(5).
|
|
LinkStr("link").
|
|
Font(FontTimes, Bold, 11).
|
|
LnAfter(2).
|
|
X(3).
|
|
AutoWidth().
|
|
AutoWidthPaddingX(1).
|
|
TextColor(1, 2, 3).
|
|
BorderColor(4, 5, 6).
|
|
FillColor(7, 8, 9).
|
|
Alpha(0.5, BlendNormal).
|
|
Debug(true)
|
|
|
|
if *o.PDFCellOpt.width != 10 {
|
|
t.Error("width")
|
|
}
|
|
if *o.PDFCellOpt.height != 20 {
|
|
t.Error("height")
|
|
}
|
|
if *o.PDFCellOpt.border != BorderFull {
|
|
t.Error("border")
|
|
}
|
|
if *o.PDFCellOpt.ln != BreakToBelow {
|
|
t.Error("ln")
|
|
}
|
|
if *o.PDFCellOpt.align != AlignRight {
|
|
t.Error("align")
|
|
}
|
|
if !*o.PDFCellOpt.fill {
|
|
t.Error("fill")
|
|
}
|
|
if *o.PDFCellOpt.link != 5 {
|
|
t.Error("link")
|
|
}
|
|
if *o.PDFCellOpt.linkStr != "link" {
|
|
t.Error("linkStr")
|
|
}
|
|
if *o.PDFCellOpt.fontNameOverride != FontTimes {
|
|
t.Error("fontName")
|
|
}
|
|
if *o.PDFCellOpt.fontStyleOverride != Bold {
|
|
t.Error("fontStyle")
|
|
}
|
|
if *o.PDFCellOpt.fontSizeOverride != 11 {
|
|
t.Error("fontSize")
|
|
}
|
|
if *o.PDFCellOpt.extraLn != 2 {
|
|
t.Error("extraLn")
|
|
}
|
|
if *o.PDFCellOpt.x != 3 {
|
|
t.Error("x")
|
|
}
|
|
if !*o.PDFCellOpt.autoWidth {
|
|
t.Error("autoWidth")
|
|
}
|
|
if *o.PDFCellOpt.autoWidthPaddingX != 1 {
|
|
t.Error("autoWidthPaddingX")
|
|
}
|
|
if *o.PDFCellOpt.textColor != (PDFColor{R: 1, G: 2, B: 3}) {
|
|
t.Error("textColor")
|
|
}
|
|
if *o.PDFCellOpt.borderColor != (PDFColor{R: 4, G: 5, B: 6}) {
|
|
t.Error("borderColor")
|
|
}
|
|
if *o.PDFCellOpt.fillColor != (PDFColor{R: 7, G: 8, B: 9}) {
|
|
t.Error("fillColor")
|
|
}
|
|
if o.PDFCellOpt.alphaOverride.V1 != 0.5 || o.PDFCellOpt.alphaOverride.V2 != BlendNormal {
|
|
t.Error("alpha")
|
|
}
|
|
if !*o.PDFCellOpt.debug {
|
|
t.Error("debug")
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptBoldItalic(t *testing.T) {
|
|
if *NewTableCellStyleOpt().Bold().PDFCellOpt.fontStyleOverride != Bold {
|
|
t.Error("Bold")
|
|
}
|
|
if *NewTableCellStyleOpt().Italic().PDFCellOpt.fontStyleOverride != Italic {
|
|
t.Error("Italic")
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptHexColors(t *testing.T) {
|
|
o := NewTableCellStyleOpt().
|
|
TextColorHex(0x010203).
|
|
BorderColorHex(0x040506).
|
|
FillColorHex(0x070809)
|
|
|
|
if *o.PDFCellOpt.textColor != (PDFColor{R: 1, G: 2, B: 3}) {
|
|
t.Error("text hex")
|
|
}
|
|
if *o.PDFCellOpt.borderColor != (PDFColor{R: 4, G: 5, B: 6}) {
|
|
t.Error("border hex")
|
|
}
|
|
if *o.PDFCellOpt.fillColor != (PDFColor{R: 7, G: 8, B: 9}) {
|
|
t.Error("fill hex")
|
|
}
|
|
}
|
|
|
|
func TestTableCellStyleOptIndividualFontSetters(t *testing.T) {
|
|
o := NewTableCellStyleOpt().FontName(FontCourier).FontStyle(Italic).FontSize(9)
|
|
if *o.PDFCellOpt.fontNameOverride != FontCourier {
|
|
t.Error("FontName")
|
|
}
|
|
if *o.PDFCellOpt.fontStyleOverride != Italic {
|
|
t.Error("FontStyle")
|
|
}
|
|
if *o.PDFCellOpt.fontSizeOverride != 9 {
|
|
t.Error("FontSize")
|
|
}
|
|
}
|
|
|
|
func TestTableCalculateColumnsNumeric(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
tb := b.Table().
|
|
Widths("30", "20", "40").
|
|
AddRowDefaultStyle("a", "b", "c")
|
|
|
|
w := tb.calculateColumns()
|
|
if len(w) != 3 {
|
|
t.Fatalf("widths = %v, want 3", len(w))
|
|
}
|
|
if w[0] != 30 || w[1] != 20 || w[2] != 40 {
|
|
t.Errorf("widths = %v, want [30, 20, 40]", w)
|
|
}
|
|
}
|
|
|
|
func TestTableCalculateColumnsFrSplit(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
b.SetMargins(PDFMargins{Left: 0, Top: 0, Right: 0})
|
|
|
|
tb := b.Table().
|
|
PadX(0).
|
|
Widths("1fr", "1fr").
|
|
AddRowDefaultStyle("a", "b")
|
|
|
|
pageW := b.GetPageWidth()
|
|
w := tb.calculateColumns()
|
|
if len(w) != 2 {
|
|
t.Fatalf("widths = %v, want 2", len(w))
|
|
}
|
|
|
|
// fr columns are bounded by autoWidths (max content); since "a" and "b"
|
|
// are very narrow strings, both columns get the same auto-bounded width.
|
|
if math.Abs(w[0]-w[1]) > 0.01 {
|
|
t.Errorf("expected fr split widths roughly equal, got %v and %v", w[0], w[1])
|
|
}
|
|
|
|
// Total should not exceed available page width.
|
|
if w[0]+w[1] > pageW+0.01 {
|
|
t.Errorf("total width %v exceeds pageW %v", w[0]+w[1], pageW)
|
|
}
|
|
}
|
|
|
|
func TestTableCalculateColumnsAutoUsesMinWidth(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
style := *NewTableCellStyleOpt()
|
|
mw := 50.0
|
|
style.minWidth = &mw
|
|
|
|
tb := b.Table().
|
|
Widths("auto").
|
|
AddRowWithStyle(&style, "x")
|
|
|
|
w := tb.calculateColumns()
|
|
if len(w) != 1 {
|
|
t.Fatalf("widths = %v, want 1", len(w))
|
|
}
|
|
if w[0] < 50 {
|
|
t.Errorf("width %v should respect minWidth=50", w[0])
|
|
}
|
|
}
|
|
|
|
func TestTableCalculateColumnsNoRows(t *testing.T) {
|
|
b := newBuilderWithPage(t)
|
|
tb := b.Table()
|
|
w := tb.calculateColumns()
|
|
if len(w) != 0 {
|
|
t.Errorf("widths for empty table = %v, want []", w)
|
|
}
|
|
}
|