forked from p30928647/excelize
470 lines
14 KiB
Go
470 lines
14 KiB
Go
package excelize_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/mohae/deepcopy"
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/360EntSecGroup-Skylar/excelize/v2"
|
|
)
|
|
|
|
var _ = []excelize.SheetPrOption{
|
|
excelize.CodeName("hello"),
|
|
excelize.EnableFormatConditionsCalculation(false),
|
|
excelize.Published(false),
|
|
excelize.FitToPage(true),
|
|
excelize.AutoPageBreaks(true),
|
|
excelize.OutlineSummaryBelow(true),
|
|
}
|
|
|
|
var _ = []excelize.SheetPrOptionPtr{
|
|
(*excelize.CodeName)(nil),
|
|
(*excelize.EnableFormatConditionsCalculation)(nil),
|
|
(*excelize.Published)(nil),
|
|
(*excelize.FitToPage)(nil),
|
|
(*excelize.AutoPageBreaks)(nil),
|
|
(*excelize.OutlineSummaryBelow)(nil),
|
|
}
|
|
|
|
func ExampleFile_SetSheetPrOptions() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
if err := f.SetSheetPrOptions(sheet,
|
|
excelize.CodeName("code"),
|
|
excelize.EnableFormatConditionsCalculation(false),
|
|
excelize.Published(false),
|
|
excelize.FitToPage(true),
|
|
excelize.AutoPageBreaks(true),
|
|
excelize.OutlineSummaryBelow(false),
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
// Output:
|
|
}
|
|
|
|
func ExampleFile_GetSheetPrOptions() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
var (
|
|
codeName excelize.CodeName
|
|
enableFormatConditionsCalculation excelize.EnableFormatConditionsCalculation
|
|
published excelize.Published
|
|
fitToPage excelize.FitToPage
|
|
autoPageBreaks excelize.AutoPageBreaks
|
|
outlineSummaryBelow excelize.OutlineSummaryBelow
|
|
)
|
|
|
|
if err := f.GetSheetPrOptions(sheet,
|
|
&codeName,
|
|
&enableFormatConditionsCalculation,
|
|
&published,
|
|
&fitToPage,
|
|
&autoPageBreaks,
|
|
&outlineSummaryBelow,
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println("Defaults:")
|
|
fmt.Printf("- codeName: %q\n", codeName)
|
|
fmt.Println("- enableFormatConditionsCalculation:", enableFormatConditionsCalculation)
|
|
fmt.Println("- published:", published)
|
|
fmt.Println("- fitToPage:", fitToPage)
|
|
fmt.Println("- autoPageBreaks:", autoPageBreaks)
|
|
fmt.Println("- outlineSummaryBelow:", outlineSummaryBelow)
|
|
// Output:
|
|
// Defaults:
|
|
// - codeName: ""
|
|
// - enableFormatConditionsCalculation: true
|
|
// - published: true
|
|
// - fitToPage: false
|
|
// - autoPageBreaks: false
|
|
// - outlineSummaryBelow: true
|
|
}
|
|
|
|
func TestSheetPrOptions(t *testing.T) {
|
|
const sheet = "Sheet1"
|
|
|
|
testData := []struct {
|
|
container excelize.SheetPrOptionPtr
|
|
nonDefault excelize.SheetPrOption
|
|
}{
|
|
{new(excelize.CodeName), excelize.CodeName("xx")},
|
|
{new(excelize.EnableFormatConditionsCalculation), excelize.EnableFormatConditionsCalculation(false)},
|
|
{new(excelize.Published), excelize.Published(false)},
|
|
{new(excelize.FitToPage), excelize.FitToPage(true)},
|
|
{new(excelize.AutoPageBreaks), excelize.AutoPageBreaks(true)},
|
|
{new(excelize.OutlineSummaryBelow), excelize.OutlineSummaryBelow(false)},
|
|
}
|
|
|
|
for i, test := range testData {
|
|
t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
|
|
|
|
opt := test.nonDefault
|
|
t.Logf("option %T", opt)
|
|
|
|
def := deepcopy.Copy(test.container).(excelize.SheetPrOptionPtr)
|
|
val1 := deepcopy.Copy(def).(excelize.SheetPrOptionPtr)
|
|
val2 := deepcopy.Copy(def).(excelize.SheetPrOptionPtr)
|
|
|
|
f := excelize.NewFile()
|
|
// Get the default value
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, def), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set the same value
|
|
assert.NoError(t, f.SetSheetPrOptions(sheet, val1), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set a different value
|
|
assert.NoError(t, f.SetSheetPrOptions(sheet, test.nonDefault), opt)
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opt)
|
|
// Get again and compare
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, val2), opt)
|
|
if !assert.Equal(t, val1, val2, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Value should not be the same as the default
|
|
if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Restore the default value
|
|
assert.NoError(t, f.SetSheetPrOptions(sheet, def), opt)
|
|
assert.NoError(t, f.GetSheetPrOptions(sheet, val1), opt)
|
|
if !assert.Equal(t, def, val1) {
|
|
t.FailNow()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSetSheetrOptions(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
// Test SetSheetrOptions on not exists worksheet.
|
|
assert.EqualError(t, f.SetSheetPrOptions("SheetN"), "sheet SheetN is not exist")
|
|
}
|
|
|
|
func TestGetSheetPrOptions(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
// Test GetSheetPrOptions on not exists worksheet.
|
|
assert.EqualError(t, f.GetSheetPrOptions("SheetN"), "sheet SheetN is not exist")
|
|
}
|
|
|
|
var _ = []excelize.PageMarginsOptions{
|
|
excelize.PageMarginBottom(1.0),
|
|
excelize.PageMarginFooter(1.0),
|
|
excelize.PageMarginHeader(1.0),
|
|
excelize.PageMarginLeft(1.0),
|
|
excelize.PageMarginRight(1.0),
|
|
excelize.PageMarginTop(1.0),
|
|
}
|
|
|
|
var _ = []excelize.PageMarginsOptionsPtr{
|
|
(*excelize.PageMarginBottom)(nil),
|
|
(*excelize.PageMarginFooter)(nil),
|
|
(*excelize.PageMarginHeader)(nil),
|
|
(*excelize.PageMarginLeft)(nil),
|
|
(*excelize.PageMarginRight)(nil),
|
|
(*excelize.PageMarginTop)(nil),
|
|
}
|
|
|
|
func ExampleFile_SetPageMargins() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
if err := f.SetPageMargins(sheet,
|
|
excelize.PageMarginBottom(1.0),
|
|
excelize.PageMarginFooter(1.0),
|
|
excelize.PageMarginHeader(1.0),
|
|
excelize.PageMarginLeft(1.0),
|
|
excelize.PageMarginRight(1.0),
|
|
excelize.PageMarginTop(1.0),
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
// Output:
|
|
}
|
|
|
|
func ExampleFile_GetPageMargins() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
var (
|
|
marginBottom excelize.PageMarginBottom
|
|
marginFooter excelize.PageMarginFooter
|
|
marginHeader excelize.PageMarginHeader
|
|
marginLeft excelize.PageMarginLeft
|
|
marginRight excelize.PageMarginRight
|
|
marginTop excelize.PageMarginTop
|
|
)
|
|
|
|
if err := f.GetPageMargins(sheet,
|
|
&marginBottom,
|
|
&marginFooter,
|
|
&marginHeader,
|
|
&marginLeft,
|
|
&marginRight,
|
|
&marginTop,
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println("Defaults:")
|
|
fmt.Println("- marginBottom:", marginBottom)
|
|
fmt.Println("- marginFooter:", marginFooter)
|
|
fmt.Println("- marginHeader:", marginHeader)
|
|
fmt.Println("- marginLeft:", marginLeft)
|
|
fmt.Println("- marginRight:", marginRight)
|
|
fmt.Println("- marginTop:", marginTop)
|
|
// Output:
|
|
// Defaults:
|
|
// - marginBottom: 0.75
|
|
// - marginFooter: 0.3
|
|
// - marginHeader: 0.3
|
|
// - marginLeft: 0.7
|
|
// - marginRight: 0.7
|
|
// - marginTop: 0.75
|
|
}
|
|
|
|
func TestPageMarginsOption(t *testing.T) {
|
|
const sheet = "Sheet1"
|
|
|
|
testData := []struct {
|
|
container excelize.PageMarginsOptionsPtr
|
|
nonDefault excelize.PageMarginsOptions
|
|
}{
|
|
{new(excelize.PageMarginTop), excelize.PageMarginTop(1.0)},
|
|
{new(excelize.PageMarginBottom), excelize.PageMarginBottom(1.0)},
|
|
{new(excelize.PageMarginLeft), excelize.PageMarginLeft(1.0)},
|
|
{new(excelize.PageMarginRight), excelize.PageMarginRight(1.0)},
|
|
{new(excelize.PageMarginHeader), excelize.PageMarginHeader(1.0)},
|
|
{new(excelize.PageMarginFooter), excelize.PageMarginFooter(1.0)},
|
|
}
|
|
|
|
for i, test := range testData {
|
|
t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
|
|
|
|
opt := test.nonDefault
|
|
t.Logf("option %T", opt)
|
|
|
|
def := deepcopy.Copy(test.container).(excelize.PageMarginsOptionsPtr)
|
|
val1 := deepcopy.Copy(def).(excelize.PageMarginsOptionsPtr)
|
|
val2 := deepcopy.Copy(def).(excelize.PageMarginsOptionsPtr)
|
|
|
|
f := excelize.NewFile()
|
|
// Get the default value
|
|
assert.NoError(t, f.GetPageMargins(sheet, def), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetPageMargins(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set the same value
|
|
assert.NoError(t, f.SetPageMargins(sheet, val1), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetPageMargins(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set a different value
|
|
assert.NoError(t, f.SetPageMargins(sheet, test.nonDefault), opt)
|
|
assert.NoError(t, f.GetPageMargins(sheet, val1), opt)
|
|
// Get again and compare
|
|
assert.NoError(t, f.GetPageMargins(sheet, val2), opt)
|
|
if !assert.Equal(t, val1, val2, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Value should not be the same as the default
|
|
if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Restore the default value
|
|
assert.NoError(t, f.SetPageMargins(sheet, def), opt)
|
|
assert.NoError(t, f.GetPageMargins(sheet, val1), opt)
|
|
if !assert.Equal(t, def, val1) {
|
|
t.FailNow()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSetPageMargins(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
// Test set page margins on not exists worksheet.
|
|
assert.EqualError(t, f.SetPageMargins("SheetN"), "sheet SheetN is not exist")
|
|
}
|
|
|
|
func TestGetPageMargins(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
// Test get page margins on not exists worksheet.
|
|
assert.EqualError(t, f.GetPageMargins("SheetN"), "sheet SheetN is not exist")
|
|
}
|
|
|
|
func ExampleFile_SetSheetFormatPr() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
if err := f.SetSheetFormatPr(sheet,
|
|
excelize.BaseColWidth(1.0),
|
|
excelize.DefaultColWidth(1.0),
|
|
excelize.DefaultRowHeight(1.0),
|
|
excelize.CustomHeight(true),
|
|
excelize.ZeroHeight(true),
|
|
excelize.ThickTop(true),
|
|
excelize.ThickBottom(true),
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
// Output:
|
|
}
|
|
|
|
func ExampleFile_GetSheetFormatPr() {
|
|
f := excelize.NewFile()
|
|
const sheet = "Sheet1"
|
|
|
|
var (
|
|
baseColWidth excelize.BaseColWidth
|
|
defaultColWidth excelize.DefaultColWidth
|
|
defaultRowHeight excelize.DefaultRowHeight
|
|
customHeight excelize.CustomHeight
|
|
zeroHeight excelize.ZeroHeight
|
|
thickTop excelize.ThickTop
|
|
thickBottom excelize.ThickBottom
|
|
)
|
|
|
|
if err := f.GetSheetFormatPr(sheet,
|
|
&baseColWidth,
|
|
&defaultColWidth,
|
|
&defaultRowHeight,
|
|
&customHeight,
|
|
&zeroHeight,
|
|
&thickTop,
|
|
&thickBottom,
|
|
); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println("Defaults:")
|
|
fmt.Println("- baseColWidth:", baseColWidth)
|
|
fmt.Println("- defaultColWidth:", defaultColWidth)
|
|
fmt.Println("- defaultRowHeight:", defaultRowHeight)
|
|
fmt.Println("- customHeight:", customHeight)
|
|
fmt.Println("- zeroHeight:", zeroHeight)
|
|
fmt.Println("- thickTop:", thickTop)
|
|
fmt.Println("- thickBottom:", thickBottom)
|
|
// Output:
|
|
// Defaults:
|
|
// - baseColWidth: 0
|
|
// - defaultColWidth: 0
|
|
// - defaultRowHeight: 15
|
|
// - customHeight: false
|
|
// - zeroHeight: false
|
|
// - thickTop: false
|
|
// - thickBottom: false
|
|
}
|
|
|
|
func TestSheetFormatPrOptions(t *testing.T) {
|
|
const sheet = "Sheet1"
|
|
|
|
testData := []struct {
|
|
container excelize.SheetFormatPrOptionsPtr
|
|
nonDefault excelize.SheetFormatPrOptions
|
|
}{
|
|
{new(excelize.BaseColWidth), excelize.BaseColWidth(1.0)},
|
|
{new(excelize.DefaultColWidth), excelize.DefaultColWidth(1.0)},
|
|
{new(excelize.DefaultRowHeight), excelize.DefaultRowHeight(1.0)},
|
|
{new(excelize.CustomHeight), excelize.CustomHeight(true)},
|
|
{new(excelize.ZeroHeight), excelize.ZeroHeight(true)},
|
|
{new(excelize.ThickTop), excelize.ThickTop(true)},
|
|
{new(excelize.ThickBottom), excelize.ThickBottom(true)},
|
|
}
|
|
|
|
for i, test := range testData {
|
|
t.Run(fmt.Sprintf("TestData%d", i), func(t *testing.T) {
|
|
|
|
opt := test.nonDefault
|
|
t.Logf("option %T", opt)
|
|
|
|
def := deepcopy.Copy(test.container).(excelize.SheetFormatPrOptionsPtr)
|
|
val1 := deepcopy.Copy(def).(excelize.SheetFormatPrOptionsPtr)
|
|
val2 := deepcopy.Copy(def).(excelize.SheetFormatPrOptionsPtr)
|
|
|
|
f := excelize.NewFile()
|
|
// Get the default value
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, def), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set the same value
|
|
assert.NoError(t, f.SetSheetFormatPr(sheet, val1), opt)
|
|
// Get again and check
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opt)
|
|
if !assert.Equal(t, val1, def, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Set a different value
|
|
assert.NoError(t, f.SetSheetFormatPr(sheet, test.nonDefault), opt)
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opt)
|
|
// Get again and compare
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, val2), opt)
|
|
if !assert.Equal(t, val1, val2, "%T: value should not have changed", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Value should not be the same as the default
|
|
if !assert.NotEqual(t, def, val1, "%T: value should have changed from default", opt) {
|
|
t.FailNow()
|
|
}
|
|
// Restore the default value
|
|
assert.NoError(t, f.SetSheetFormatPr(sheet, def), opt)
|
|
assert.NoError(t, f.GetSheetFormatPr(sheet, val1), opt)
|
|
if !assert.Equal(t, def, val1) {
|
|
t.FailNow()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSetSheetFormatPr(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
assert.NoError(t, f.GetSheetFormatPr("Sheet1"))
|
|
f.Sheet["xl/worksheets/sheet1.xml"].SheetFormatPr = nil
|
|
assert.NoError(t, f.SetSheetFormatPr("Sheet1", excelize.BaseColWidth(1.0)))
|
|
// Test set formatting properties on not exists worksheet.
|
|
assert.EqualError(t, f.SetSheetFormatPr("SheetN"), "sheet SheetN is not exist")
|
|
}
|
|
|
|
func TestGetSheetFormatPr(t *testing.T) {
|
|
f := excelize.NewFile()
|
|
assert.NoError(t, f.GetSheetFormatPr("Sheet1"))
|
|
f.Sheet["xl/worksheets/sheet1.xml"].SheetFormatPr = nil
|
|
var (
|
|
baseColWidth excelize.BaseColWidth
|
|
defaultColWidth excelize.DefaultColWidth
|
|
defaultRowHeight excelize.DefaultRowHeight
|
|
customHeight excelize.CustomHeight
|
|
zeroHeight excelize.ZeroHeight
|
|
thickTop excelize.ThickTop
|
|
thickBottom excelize.ThickBottom
|
|
)
|
|
assert.NoError(t, f.GetSheetFormatPr("Sheet1",
|
|
&baseColWidth,
|
|
&defaultColWidth,
|
|
&defaultRowHeight,
|
|
&customHeight,
|
|
&zeroHeight,
|
|
&thickTop,
|
|
&thickBottom,
|
|
))
|
|
// Test get formatting properties on not exists worksheet.
|
|
assert.EqualError(t, f.GetSheetFormatPr("SheetN"), "sheet SheetN is not exist")
|
|
}
|