col_test.go

package xlsx

import (
		"testing"

		qt "github.com/frankban/quicktest"
)

var notNil = qt.Not(qt.IsNil)

func TestNewColForRange(t *testing.T) {
		c := qt.New(t)
		col := NewColForRange(30, 45)
		c.Assert(col, notNil)
		c.Assert(col.Min, qt.Equals, 30)
		c.Assert(col.Max, qt.Equals, 45)

		// Auto fix the min/max
		col = NewColForRange(45, 30)
		c.Assert(col, notNil)
		c.Assert(col.Min, qt.Equals, 30)
		c.Assert(col.Max, qt.Equals, 45)

		// Min cannot be less than 1
		c.Assert(func() {NewColForRange(0, 1)}, qt.PanicMatches, "min col must be >= 1")
}

func TestCol(t *testing.T) {
		c := qt.New(t)
		c.Run("SetType", func(c *qt.C) {
				expectations := map[CellType]string{
						CellTypeString:        builtInNumFmt[builtInNumFmtIndex_STRING],
						CellTypeNumeric:       builtInNumFmt[builtInNumFmtIndex_INT],
						CellTypeBool:          builtInNumFmt[builtInNumFmtIndex_GENERAL],
						CellTypeInline:        builtInNumFmt[builtInNumFmtIndex_STRING],
						CellTypeError:         builtInNumFmt[builtInNumFmtIndex_GENERAL],
						CellTypeDate:          builtInNumFmt[builtInNumFmtIndex_GENERAL],
						CellTypeStringFormula: builtInNumFmt[builtInNumFmtIndex_STRING],
				}

				assertSetType := func(cellType CellType, expectation string) {
						col := &Col{}
						col.SetType(cellType)
						c.Assert(col.numFmt, qt.Equals, expectation)
				}
				for k, v := range expectations {
						assertSetType(k, v)
				}
		})
		c.Run("SetWidth", func(c *qt.C) {
				col := &Col{}
				col.SetWidth(20.2)
				c.Assert(*col.Width, qt.Equals, 20.2)
				c.Assert(*col.CustomWidth, qt.Equals, true)
		})

		c.Run("copyToRange", func(c *qt.C) {
				nf := &parsedNumberFormat{}
				s := &Style{}
				c1 := &Col{
						Min:          1,
						Max:          11,
						Hidden:       bPtr(true),
						Width:        fPtr(300.4),
						Collapsed:    bPtr(true),
						OutlineLevel: u8Ptr(2),
						numFmt:       "-0.00",
						parsedNumFmt: nf,
						style:        s,
				}

				c2 := c1.copyToRange(4, 10)
				c.Assert(c2.Min, qt.Equals, 4)
				c.Assert(c2.Max, qt.Equals, 10)
				c.Assert(c2.Hidden, qt.Equals, c1.Hidden)
				c.Assert(c2.Width, qt.Equals, c1.Width)
				c.Assert(c2.Collapsed, qt.Equals, c1.Collapsed)
				c.Assert(c2.OutlineLevel, qt.Equals, c1.OutlineLevel)
				c.Assert(c2.numFmt, qt.Equals, c1.numFmt)
				c.Assert(c2.parsedNumFmt, qt.Equals, c1.parsedNumFmt)
				c.Assert(c2.style, qt.Equals, c1.style)
		})

}

type ColStoreSuite struct{}

func TestAddRootNode(t *testing.T) {
		col := &Col{Min: 1, Max: 1}
		cs := ColStore{}
		cs.Add(col)
		c := qt.New(t)
		c.Assert(cs.Len, qt.Equals, 1)
		c.Assert(cs.Root.Col, qt.Equals, col)
}

func TestMakeWay(t *testing.T) {
		c := qt.New(t)
		assertWayMade := func(cols []*Col, chainFunc func(*ColStore)) {

				cs := &ColStore{}
				for _, col := range cols {
						_ = cs.Add(col)
				}
				chainFunc(cs)
		}

		// Col1: |--|
		// Col2:    |--|
		assertWayMade([]*Col{{Min: 1, Max: 2}, {Min: 3, Max: 4}},
				func(cs *ColStore) {
						c.Assert(cs.Len, qt.Equals, 2)
						root := cs.Root
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, qt.IsNil)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 4)
				})

		// Col1:    |--|
		// Col2: |--|
		assertWayMade([]*Col{{Min: 3, Max: 4}, {Min: 1, Max: 2}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 2)
						c.Assert(root.Col.Min, qt.Equals, 3)
						c.Assert(root.Col.Max, qt.Equals, 4)
						c.Assert(root.Prev, notNil)
						c.Assert(root.Next, qt.IsNil)
						node2 := root.Prev
						c.Assert(node2.Next, qt.Equals, root)
						c.Assert(node2.Prev, qt.IsNil)
						c.Assert(node2.Col.Min, qt.Equals, 1)
						c.Assert(node2.Col.Max, qt.Equals, 2)
				})

		// Col1: |--x|
		// Col2:   |--|
		assertWayMade([]*Col{{Min: 1, Max: 3}, {Min: 3, Max: 4}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 2)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, qt.IsNil)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 4)
				})

		// Col1:  |x-|
		// Col2: |--|
		assertWayMade([]*Col{{Min: 2, Max: 3}, {Min: 1, Max: 2}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 2)
						c.Assert(root.Col.Min, qt.Equals, 3)
						c.Assert(root.Col.Max, qt.Equals, 3)
						c.Assert(root.Prev, notNil)
						c.Assert(root.Next, qt.IsNil)
						node2 := root.Prev
						c.Assert(node2.Next, qt.Equals, root)
						c.Assert(node2.Prev, qt.IsNil)
						c.Assert(node2.Col.Min, qt.Equals, 1)
						c.Assert(node2.Col.Max, qt.Equals, 2)
				})

		// Col1: |---xx---|
		// Col2:    |--|
		assertWayMade([]*Col{{Min: 1, Max: 8}, {Min: 4, Max: 5}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 3)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Col.Min, qt.Equals, 4)
						c.Assert(node2.Col.Max, qt.Equals, 5)
						c.Assert(node2.Next, notNil)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 6)
						c.Assert(node3.Col.Max, qt.Equals, 8)
				})

		// Col1: |xx|
		// Col2: |--|
		assertWayMade([]*Col{{Min: 1, Max: 2, Width: fPtr(40.1)}, {Min: 1, Max: 2, Width: fPtr(10.0)}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 1)
						c.Assert(root, notNil)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, qt.IsNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						// This is how we establish we have the new node, and not the old one
						c.Assert(*root.Col.Width, qt.Equals, 10.0)
				})

		// Col1:  |xx|
		// Col2: |----|
		assertWayMade([]*Col{{Min: 2, Max: 3, Width: fPtr(40.1)}, {Min: 1, Max: 4, Width: fPtr(10.0)}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 1)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, qt.IsNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 4)
						// This is how we establish we have the new node, and not the old one
						c.Assert(*root.Col.Width, qt.Equals, 10.0)
				})

		// Col1: |--|
		// Col2:    |--|
		// Col3:       |--|
		assertWayMade([]*Col{{Min: 1, Max: 2}, {Min: 3, Max: 4}, {Min: 5, Max: 6}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 4)
						c.Assert(node2.Next, notNil)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 5)
						c.Assert(node3.Col.Max, qt.Equals, 6)
				})

		// Col1:       |--|
		// Col2:    |--|
		// Col3: |--|
		assertWayMade([]*Col{{Min: 5, Max: 6}, {Min: 3, Max: 4}, {Min: 1, Max: 2}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, notNil)
						c.Assert(root.Next, qt.IsNil)
						c.Assert(root.Col.Min, qt.Equals, 5)
						c.Assert(root.Col.Max, qt.Equals, 6)
						node2 := root.Prev
						c.Assert(node2.Next, qt.Equals, root)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 4)
						c.Assert(node2.Prev, notNil)
						node3 := node2.Prev
						c.Assert(node3.Next, qt.Equals, node2)
						c.Assert(node3.Prev, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 1)
						c.Assert(node3.Col.Max, qt.Equals, 2)
				})

		// Col1: |--|
		// Col2:          |--|
		// Col3:     |--|
		assertWayMade([]*Col{{Min: 1, Max: 2}, {Min: 10, Max: 11}, {Min: 5, Max: 6}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Col.Min, qt.Equals, 5)
						c.Assert(node2.Col.Max, qt.Equals, 6)
						c.Assert(node2.Next, notNil)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 10)
						c.Assert(node3.Col.Max, qt.Equals, 11)
				})

		// Col1: |-x|
		// Col2:        |x-|
		// Col3:  |-------|
		assertWayMade([]*Col{
				{Min: 1, Max: 2}, {Min: 8, Max: 9}, {Min: 2, Max: 8}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 1)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, notNil)
						c.Assert(node2.Col.Min, qt.Equals, 2)
						c.Assert(node2.Col.Max, qt.Equals, 8)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 9)
						c.Assert(node3.Col.Max, qt.Equals, 9)
				})

		// Col1: |-x|
		// Col2:        |--|
		// Col3:  |-----|
		assertWayMade([]*Col{
				{Min: 1, Max: 2}, {Min: 8, Max: 9}, {Min: 2, Max: 7}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 1)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, notNil)
						c.Assert(node2.Col.Min, qt.Equals, 2)
						c.Assert(node2.Col.Max, qt.Equals, 7)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 8)
						c.Assert(node3.Col.Max, qt.Equals, 9)
				})

		// Col1: |--|
		// Col2:        |x-|
		// Col3:    |-----|
		assertWayMade([]*Col{
				{Min: 1, Max: 2}, {Min: 8, Max: 9}, {Min: 3, Max: 8}},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, notNil)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 8)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 9)
						c.Assert(node3.Col.Max, qt.Equals, 9)
				})

		// Col1: |--|
		// Col2:   |xx|
		// Col3:     |--|
		// Col4:   |--|
		assertWayMade(
				[]*Col{
						{Min: 1, Max: 2},
						{Min: 3, Max: 4, Width: fPtr(1.0)},
						{Min: 5, Max: 6},
						{Min: 3, Max: 4, Width: fPtr(2.0)},
				},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 2)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, notNil)
						c.Assert(node2.Col.Min, qt.Equals, 3)
						c.Assert(node2.Col.Max, qt.Equals, 4)
						c.Assert(*node2.Col.Width, qt.Equals, 2.0) // We have the later version
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 5)
						c.Assert(node3.Col.Max, qt.Equals, 6)
				})

		// Col1: |-x|
		// Col2:   |xx|
		// Col3:     |x-|
		// Col4:  |----|
		assertWayMade(
				[]*Col{
						{Min: 1, Max: 2, Width: fPtr(1.0)},
						{Min: 3, Max: 4, Width: fPtr(2.0)},
						{Min: 5, Max: 6, Width: fPtr(3.0)},
						{Min: 2, Max: 5, Width: fPtr(4.0)},
				},
				func(cs *ColStore) {
						root := cs.Root
						c.Assert(cs.Len, qt.Equals, 3)
						c.Assert(root.Prev, qt.IsNil)
						c.Assert(root.Next, notNil)
						c.Assert(root.Col.Min, qt.Equals, 1)
						c.Assert(root.Col.Max, qt.Equals, 1)
						c.Assert(*root.Col.Width, qt.Equals, 1.0)
						node2 := root.Next
						c.Assert(node2.Prev, qt.Equals, root)
						c.Assert(node2.Next, notNil)
						c.Assert(node2.Col.Min, qt.Equals, 2)
						c.Assert(node2.Col.Max, qt.Equals, 5)
						c.Assert(*node2.Col.Width, qt.Equals, 4.0)
						node3 := node2.Next
						c.Assert(node3.Prev, qt.Equals, node2)
						c.Assert(node3.Next, qt.IsNil)
						c.Assert(node3.Col.Min, qt.Equals, 6)
						c.Assert(node3.Col.Max, qt.Equals, 6)
						c.Assert(*node3.Col.Width, qt.Equals, 3.0)
				})

}

func TestFindNodeForCol(t *testing.T) {
		c := qt.New(t)

		assertNodeFound := func(cs *ColStore, num int, col *Col) {
				node := cs.findNodeForColNum(num)
				if col == nil {
						c.Assert(node, qt.IsNil)
						return
				}
				c.Assert(node, qt.IsNotNil)
				c.Assert(node.Col, qt.Equals, col)
		}

		cs := &ColStore{}
		col0 := &Col{Min: 1, Max: 1}
		cs.Add(col0)
		col1 := &Col{Min: 2, Max: 2}
		cs.Add(col1)
		col2 := &Col{Min: 3, Max: 3}
		cs.Add(col2)
		col3 := &Col{Min: 4, Max: 4}
		cs.Add(col3)
		col4 := &Col{Min: 5, Max: 5}
		cs.Add(col4)
		col5 := &Col{Min: 100, Max: 125}
		cs.Add(col5)

		assertNodeFound(cs, 0, nil)
		assertNodeFound(cs, 1, col0)
		assertNodeFound(cs, 2, col1)
		assertNodeFound(cs, 3, col2)
		assertNodeFound(cs, 4, col3)
		assertNodeFound(cs, 5, col4)
		assertNodeFound(cs, 6, nil)
		assertNodeFound(cs, 99, nil)
		assertNodeFound(cs, 100, col5)
		assertNodeFound(cs, 110, col5)
		assertNodeFound(cs, 125, col5)
		assertNodeFound(cs, 126, nil)
}

func TestRemoveNode(t *testing.T) {
		c := qt.New(t)

		assertChain := func(cs *ColStore, chain []*Col) {
				node := cs.Root
				for _, col := range chain {
						c.Assert(node, qt.IsNotNil)
						c.Assert(node.Col.Min, qt.Equals, col.Min)
						c.Assert(node.Col.Max, qt.Equals, col.Max)
						node = node.Next
				}
				c.Assert(node, qt.IsNil)
		}

		cs := &ColStore{}
		col0 := &Col{Min: 1, Max: 1}
		cs.Add(col0)
		col1 := &Col{Min: 2, Max: 2}
		cs.Add(col1)
		col2 := &Col{Min: 3, Max: 3}
		cs.Add(col2)
		col3 := &Col{Min: 4, Max: 4}
		cs.Add(col3)
		col4 := &Col{Min: 5, Max: 5}
		cs.Add(col4)
		c.Assert(cs.Len, qt.Equals, 5)

		cs.removeNode(cs.findNodeForColNum(5))
		c.Assert(cs.Len, qt.Equals, 4)
		assertChain(cs, []*Col{col0, col1, col2, col3})

		cs.removeNode(cs.findNodeForColNum(1))
		c.Assert(cs.Len, qt.Equals, 3)
		assertChain(cs, []*Col{col1, col2, col3})
}

func TestForEach(t *testing.T) {
		c := qt.New(t)
		cs := &ColStore{}
		col0 := &Col{Min: 1, Max: 1, Hidden: bPtr(true)}
		cs.Add(col0)
		col1 := &Col{Min: 2, Max: 2}
		cs.Add(col1)
		col2 := &Col{Min: 3, Max: 3}
		cs.Add(col2)
		col3 := &Col{Min: 4, Max: 4}
		cs.Add(col3)
		col4 := &Col{Min: 5, Max: 5}
		cs.Add(col4)
		cs.ForEach(func(index int, col *Col) {
				col.Phonetic = bPtr(true)
		})

		c.Assert(*col0.Phonetic, qt.Equals, true)
		c.Assert(*col1.Phonetic, qt.Equals, true)
		c.Assert(*col2.Phonetic, qt.Equals, true)
		c.Assert(*col3.Phonetic, qt.Equals, true)
		c.Assert(*col4.Phonetic, qt.Equals, true)
}

func TestGetOrMakeColsForRange(t *testing.T) {
		c := qt.New(t)
		assertCols := func(min, max int, initalCols, expectedCols []*Col) {
				cs := &ColStore{}
				for _, col := range initalCols {
						cs.Add(col)
				}
				result := cs.getOrMakeColsForRange(cs.Root, min, max)
				c.Assert(result, qt.HasLen, len(expectedCols))
				for i := 0; i < len(expectedCols); i++ {
						got := result[i]
						expected := expectedCols[i]
						c.Assert(got.Min, qt.Equals, expected.Min)
						c.Assert(got.Max, qt.Equals, expected.Max)
				}
		}

		// make everything
		assertCols(1, 11, nil, []*Col{{Min: 1, Max: 11}})

		// get everything, one col
		assertCols(1, 11, []*Col{{Min: 1, Max: 11}}, []*Col{{Min: 1, Max: 11}})

		// get everything, many cols
		assertCols(1, 11,
				[]*Col{
						{Min: 1, Max: 4},
						{Min: 5, Max: 8},
						{Min: 9, Max: 11},
				},
				[]*Col{
						{Min: 1, Max: 4},
						{Min: 5, Max: 8},
						{Min: 9, Max: 11},
				},
		)

		// make missing col
		assertCols(1, 11,
				[]*Col{
						{Min: 1, Max: 4},
						{Min: 9, Max: 11},
				},
				[]*Col{
						{Min: 1, Max: 4},
						{Min: 5, Max: 8},
						{Min: 9, Max: 11},
				},
		)

}