API update for stream cell creation

stream_cell.go

@@ -0,0 +1,41 @@
+package xlsx
+
+import "strconv"
+
+// StreamCell holds the data, style and type of cell for streaming
+type StreamCell struct {
+	cellData  string
+	cellStyle StreamStyle
+	cellType  CellType
+}
+
+// NewStreamCell creates a new StreamCell
+func NewStreamCell(cellData string, cellStyle StreamStyle, cellType CellType) StreamCell{
+	return StreamCell{
+		cellData:  cellData,
+		cellStyle: cellStyle,
+		cellType:  cellType,
+	}
+}
+
+// MakeStringStreamCell creates a new cell that holds string data, is of type string and uses general formatting
+func MakeStringStreamCell(cellData string) StreamCell{
+	return NewStreamCell(cellData, Strings, CellTypeString)
+}
+
+// MakeStyledStringStreamCell creates a new cell that holds a string and is styled according to the given style
+func MakeStyledStringStreamCell(cellData string, cellStyle StreamStyle) StreamCell {
+	return NewStreamCell(cellData, cellStyle, CellTypeString)
+}
+
+// MakeIntegerStreamCell creates a new cell that holds an integer value (represented as string),
+// is formatted as a standard integer and is of type numeric.
+func MakeIntegerStreamCell(cellData int) StreamCell {
+	return NewStreamCell(strconv.Itoa(cellData), Integers, CellTypeNumeric)
+}
+
+// MakeStyledIntegerStreamCell created a new cell that holds an integer value (represented as string)
+// and is styled according to the given style.
+func MakeStyledIntegerStreamCell(cellData int, cellStyle StreamStyle) StreamCell {
+	return NewStreamCell(strconv.Itoa(cellData), cellStyle, CellTypeNumeric)
+}

stream_file.go

@@ -44,11 +44,11 @@ var (
 // same number of cells as the header provided when the sheet was created or an error will be returned. This function
 // will always trigger a flush on success. Currently the only supported data type is string data.
 // TODO update comment
-func (sf *StreamFile) Write(cells []string, cellTypes []CellType, cellStyles []StreamStyle) error {
+func (sf *StreamFile) Write(cells []StreamCell) error {
 	if sf.err != nil {
 		return sf.err
 	}
-	err := sf.write(cells, cellTypes, cellStyles)
+	err := sf.write(cells)
 	if err != nil {
 		sf.err = err
 		return err
@@ -57,12 +57,12 @@ func (sf *StreamFile) Write(cells []string, cellTypes []CellType, cellStyles []S
 }
 
 //TODO Add comment
-func (sf *StreamFile) WriteAll(records [][]string, cellTypes []CellType, cellStyles []StreamStyle) error {
+func (sf *StreamFile) WriteAll(records [][]StreamCell) error {
 	if sf.err != nil {
 		return sf.err
 	}
 	for _, row := range records {
-		err := sf.write(row, cellTypes, cellStyles)
+		err := sf.write(row)
 		if err != nil {
 			sf.err = err
 			return err
@@ -72,16 +72,17 @@ func (sf *StreamFile) WriteAll(records [][]string, cellTypes []CellType, cellSty
 }
 
 // TODO Add comment
-func (sf *StreamFile) write(cells []string, cellTypes []CellType, cellStyles []StreamStyle) error {
+func (sf *StreamFile) write(cells []StreamCell) error {
 	if sf.currentSheet == nil {
 		return NoCurrentSheetError
 	}
 	if len(cells) != sf.currentSheet.columnCount {
 		return WrongNumberOfRowsError
 	}
-	if len(cells) != len(cellTypes) {
-		return WrongNumberOfCellTypesError
-	}
+	//if len(cells) != len(cellTypes) {
+	//	return WrongNumberOfCellTypesError
+	//}
+
 	sf.currentSheet.rowCount++
 
 	// This is the XML row opening
@@ -90,12 +91,12 @@ func (sf *StreamFile) write(cells []string, cellTypes []CellType, cellStyles []S
 	}
 
 	// Add cells one by one
-	for colIndex, cellData := range cells {
+	for colIndex, cell := range cells {
 		// Get the cell reference (location)
 		cellCoordinate := GetCellIDStringFromCoords(colIndex, sf.currentSheet.rowCount-1)
 
 		// Get the cell type string
-		cellType, err := GetCellTypeAsString(cellTypes[colIndex])
+		cellType, err := GetCellTypeAsString(cell.cellType)
 		if err != nil {
 			return  err
 		}
@@ -103,12 +104,12 @@ func (sf *StreamFile) write(cells []string, cellTypes []CellType, cellStyles []S
 		// Build the XML cell opening
 		cellOpen := `<c r="` + cellCoordinate + `" t="` + cellType + `"`
 		// Add in the style id if the cell isn't using the default style
-		cellOpen += ` s="` + strconv.Itoa(sf.styleIdMap[cellStyles[colIndex]]) + `"`
+		cellOpen += ` s="` + strconv.Itoa(sf.styleIdMap[cell.cellStyle]) + `"`
 
 		cellOpen += `>`
 
 		// The XML cell contents
-		cellContentsOpen, cellContentsClose, err := GetCellContentOpenAncCloseTags(cellTypes[colIndex])
+		cellContentsOpen, cellContentsClose, err := GetCellContentOpenAncCloseTags(cell.cellType)
 		if err != nil {
 			return err
 		}
@@ -127,7 +128,7 @@ func (sf *StreamFile) write(cells []string, cellTypes []CellType, cellStyles []S
 		}
 
 		// Write cell contents
-		if err:= xml.EscapeText(sf.currentSheet.writer, []byte(cellData)); err != nil {
+		if err:= xml.EscapeText(sf.currentSheet.writer, []byte(cell.cellData)); err != nil {
 			return err
 		}
 

stream_file_builder.go

@@ -79,13 +79,14 @@ func NewStreamFileBuilderForPath(path string) (*StreamFileBuilder, error) {
 // AddSheet will add sheets with the given name with the provided headers. The headers cannot be edited later, and all
 // rows written to the sheet must contain the same number of cells as the header. Sheet names must be unique, or an
 // error will be thrown.
-func (sb *StreamFileBuilder) AddSheet(name string, headers []string, cellStyles []StreamStyle, cellTypes []CellType) error {
+func (sb *StreamFileBuilder) AddSheet(name string, cells []StreamCell) error {
 	if sb.built {
 		return BuiltStreamFileBuilderError
 	}
-	if len(cellTypes) > len(headers) {
-		return errors.New("cellTypes is longer than headers")
-	}
+	//if len(cellTypes) > len(headers) {
+	//	return errors.New("cellTypes is longer than headers")
+	//}
+
 	sheet, err := sb.xlsxFile.AddSheet(name)
 	if err != nil {
 		// Set built on error so that all subsequent calls to the builder will also fail.
@@ -94,14 +95,22 @@ func (sb *StreamFileBuilder) AddSheet(name string, headers []string, cellStyles
 	}
 	sb.styleIds = append(sb.styleIds, []int{})
 	row := sheet.AddRow()
+
+	// TODO WriteSlice does not write the correct styles/types to the headers yet
+	headers := []string{}
+	for _, cell := range cells {
+		headers = append(headers, cell.cellData)
+	}
+
 	if count := row.WriteSlice(&headers, -1); count != len(headers) {
 		// Set built on error so that all subsequent calls to the builder will also fail.
 		sb.built = true
 		return errors.New("failed to write headers")
 	}
-	for i, cellType := range cellTypes {
-		cellStyleIndex := sb.styleIdMap[cellStyles[i]]
-		sheet.Cols[i].SetType(cellType)
+
+	for i, cell := range cells {
+		cellStyleIndex := sb.styleIdMap[cell.cellStyle]
+		sheet.Cols[i].SetType(cell.cellType)
 		sb.styleIds[len(sb.styleIds)-1] = append(sb.styleIds[len(sb.styleIds)-1], cellStyleIndex)
 	}
 	return nil

stream_style.go

@@ -7,81 +7,82 @@ type StreamStyle struct {
 	style 		*Style
 }
 
-var DefaultStringStyle StreamStyle
-var DefaultStringBoldStyle StreamStyle
-var DefaultStringItalicStyle StreamStyle
-var DefaultStringUnderlinedStyle StreamStyle
+const (
+	GeneralFormat				= 0
+	IntegerFormat				= 1
+	DecimalFormat 				= 2
+	DateFormat_dd_mm_yy 		= 14
+	DateTimeFormat_d_m_yy_h_mm 	= 22
+)
 
-var DefaultNumericStyle StreamStyle
-var DefaultNumericBoldStyle StreamStyle
-var DefaultNumericItalicStyle StreamStyle
-var DefaultNumericUnderlinedStyle StreamStyle
+var Strings StreamStyle
+var BoldStrings StreamStyle
+var ItalicStrings StreamStyle
+var UnderlinedStrings StreamStyle
+
+var Integers StreamStyle
+var BoldIntegers StreamStyle
+var ItalicIntegers StreamStyle
+var UnderlinedIntegers StreamStyle
 
 var DefaultStyles []StreamStyle
 
+var Bold *Font
+var Italic *Font
+var Underlined *Font
+
+var GreenCell *Fill
+var RedCell *Fill
+var WhiteCel *Fill
+
 func init(){
-	// default string styles
-	DefaultStringStyle = StreamStyle{
-		xNumFmtId: 0,
-		style: NewStyle(),
-	}
-	DefaultStringBoldStyle = StreamStyle{
-		xNumFmtId: 0,
-		style: NewStyle(),
-	}
-	DefaultStringBoldStyle.style.Font.Bold = true
-	DefaultStringItalicStyle = StreamStyle{
-		xNumFmtId: 0,
-		style: NewStyle(),
-	}
-	DefaultStringItalicStyle.style.Font.Italic = true
-	DefaultStringUnderlinedStyle = StreamStyle{
-		xNumFmtId: 0,
-		style: NewStyle(),
-	}
-	DefaultStringUnderlinedStyle.style.Font.Underline = true
+	// Init Fonts
+	Bold = DefaultFont()
+	Bold.Bold = true
 
-	DefaultStyles = append(DefaultStyles, DefaultStringStyle)
-	DefaultStyles = append(DefaultStyles, DefaultStringBoldStyle)
-	DefaultStyles = append(DefaultStyles, DefaultStringItalicStyle)
-	DefaultStyles = append(DefaultStyles, DefaultStringUnderlinedStyle)
+	Italic = DefaultFont()
+	Italic.Italic = true
 
-	// default string styles
-	DefaultNumericStyle = StreamStyle{
-		xNumFmtId: 1,
-		style: NewStyle(),
-	}
-	DefaultNumericBoldStyle = StreamStyle{
-		xNumFmtId: 1,
-		style: NewStyle(),
-	}
-	DefaultNumericBoldStyle.style.Font.Bold = true
-	DefaultNumericItalicStyle = StreamStyle{
-		xNumFmtId: 1,
-		style: NewStyle(),
-	}
-	DefaultNumericItalicStyle.style.Font.Italic = true
-	DefaultNumericUnderlinedStyle = StreamStyle{
-		xNumFmtId: 1,
-		style: NewStyle(),
-	}
-	DefaultNumericUnderlinedStyle.style.Font.Underline = true
+	Underlined = DefaultFont()
+	Underlined.Underline = true
 
-	DefaultStyles = append(DefaultStyles, DefaultNumericStyle)
-	DefaultStyles = append(DefaultStyles, DefaultNumericBoldStyle)
-	DefaultStyles = append(DefaultStyles, DefaultNumericItalicStyle)
-	DefaultStyles = append(DefaultStyles, DefaultNumericUnderlinedStyle)
+	// Init Fills
+	GreenCell = NewFill(Solid_Cell_Fill, RGB_Light_Green, RGB_White)
+	RedCell = NewFill(Solid_Cell_Fill, RGB_Light_Red, RGB_White)
+	WhiteCel = DefaultFill()
+
+	// Init default string styles
+	Strings = MakeStringStyle(DefaultFont(), DefaultFill(), DefaultAlignment(), DefaultBorder())
+	BoldStrings = MakeStringStyle(Bold, DefaultFill(), DefaultAlignment(), DefaultBorder())
+	ItalicStrings = MakeStringStyle(Italic, DefaultFill(), DefaultAlignment(), DefaultBorder())
+	UnderlinedStrings = MakeStringStyle(Underlined, DefaultFill(), DefaultAlignment(), DefaultBorder())
+
+	DefaultStyles = append(DefaultStyles, Strings)
+	DefaultStyles = append(DefaultStyles, BoldStrings)
+	DefaultStyles = append(DefaultStyles, ItalicStrings)
+	DefaultStyles = append(DefaultStyles, UnderlinedStrings)
+
+	// Init default Integer styles
+	Integers = MakeIntegerStyle(DefaultFont(), DefaultFill(), DefaultAlignment(), DefaultBorder())
+	BoldIntegers = MakeIntegerStyle(Bold, DefaultFill(), DefaultAlignment(), DefaultBorder())
+	ItalicIntegers = MakeIntegerStyle(Italic, DefaultFill(), DefaultAlignment(), DefaultBorder())
+	UnderlinedIntegers = MakeIntegerStyle(Underlined, DefaultFill(), DefaultAlignment(), DefaultBorder())
+
+	DefaultStyles = append(DefaultStyles, Integers)
+	DefaultStyles = append(DefaultStyles, BoldIntegers)
+	DefaultStyles = append(DefaultStyles, ItalicIntegers)
+	DefaultStyles = append(DefaultStyles, UnderlinedIntegers)
 }
 
 // MakeStyle creates a new StreamStyle and add it to the styles that will be streamed
 // This function returns a reference to the created StreamStyle
-func MakeStyle(formatStyleId int, font Font, fill Fill, alignment Alignment, border Border) StreamStyle {
+func MakeStyle(formatStyleId int, font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle {
 	newStyle := NewStyle()
 
-	newStyle.Font = font
-	newStyle.Fill = fill
-	newStyle.Alignment = alignment
-	newStyle.Border = border
+	newStyle.Font = *font
+	newStyle.Fill = *fill
+	newStyle.Alignment = *alignment
+	newStyle.Border = *border
 
 	newStyle.ApplyFont = true
 	newStyle.ApplyFill = true
@@ -97,3 +98,27 @@ func MakeStyle(formatStyleId int, font Font, fill Fill, alignment Alignment, bor
 	return newStreamStyle
 }
 
+// MakeStringStyle creates a new style that can be used on cells with string data.
+// If used on other data the formatting might be wrong.
+func MakeStringStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle{
+	return MakeStyle(GeneralFormat, font, fill, alignment, border)
+}
+
+// MakeIntegerStyle creates a new style that can be used on cells with integer data.
+// If used on other data the formatting might be wrong.
+func MakeIntegerStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle{
+	return MakeStyle(IntegerFormat, font, fill, alignment, border)
+}
+
+// MakeDecimalStyle creates a new style that can be used on cells with decimal numeric data.
+// If used on other data the formatting might be wrong.
+func MakeDecimalStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle{
+	return MakeStyle(DecimalFormat, font, fill, alignment, border)
+}
+
+// MakeDateStyle creates a new style that can be used on cells with Date data.
+// The formatting used is: dd_mm_yy
+// If used on other data the formatting might be wrong.
+func MakeDateStyle(font *Font, fill *Fill, alignment *Alignment, border *Border) StreamStyle{
+	return MakeStyle(DateFormat_dd_mm_yy, font, fill, alignment, border)
+}

stream_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 const (
-	TestsShouldMakeRealFiles = false
+	TestsShouldMakeRealFiles = true
 )
 
 type StreamSuite struct{}
@@ -32,9 +32,7 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 	testCases := []struct {
 		testName      string
 		sheetNames    []string
-		workbookData  [][][]string
-		cellStyles    [][][]StreamStyle
-		cellTypes     [][][]CellType
+		workbookData  [][][]StreamCell
 		expectedError error
 	}{
 		{
@@ -42,22 +40,12 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"1", "25", "A", "B"},
-					{"1234", "98", "34", "26032019"},
-				},
-			},
-			cellStyles: [][][]StreamStyle{
-				{
-					{DefaultStringStyle,  DefaultStringBoldStyle,  DefaultStringItalicStyle,  DefaultStringUnderlinedStyle},
-					{DefaultNumericStyle, DefaultNumericBoldStyle, DefaultNumericItalicStyle, DefaultNumericUnderlinedStyle},
-				},
-			},
-			cellTypes: [][][]CellType{
-				{
-					{CellTypeString,  CellTypeString,  CellTypeString,  CellTypeString},
-					{CellTypeNumeric, CellTypeNumeric, CellTypeNumeric, CellTypeNumeric},
+					{MakeStringStreamCell("1"), MakeStringStreamCell("25"),
+						MakeStringStreamCell("A"), MakeStringStreamCell("B")},
+					{MakeIntegerStreamCell(1234), MakeStyledIntegerStreamCell(98, BoldIntegers),
+						MakeStyledIntegerStreamCell(34, ItalicIntegers), MakeStyledIntegerStreamCell(26, UnderlinedIntegers)},
 				},
 			},
 		},
@@ -66,16 +54,12 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet1",
 			},
-			workbookData: [][][]string{
-				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
-				},
-			},
-			cellTypes: [][][]CellType{
+			workbookData: [][][]StreamCell{
 				{
-					{CellTypeString,  CellTypeString,  CellTypeString,  CellTypeString},
-					{CellTypeNumeric, CellTypeString,  CellTypeNumeric, CellTypeString},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 			},
 		},
@@ -84,10 +68,10 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token"},
-					{"123"},
+					{MakeStringStreamCell("Token")},
+					{MakeIntegerStreamCell(123)},
 				},
 			},
 		},
@@ -96,20 +80,36 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1", "Sheet 2", "Sheet3",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 				{
-					{"Token", "Name", "Price", "SKU", "Stock"},
-					{"456", "Salsa", "200", "0346", "1"},
-					{"789", "Burritos", "400", "754", "3"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Stock")},
+
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(1)},
+
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(3)},
 				},
 				{
-					{"Token", "Name", "Price"},
-					{"9853", "Guacamole", "500"},
-					{"2357", "Margarita", "700"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price")},
+
+					{MakeIntegerStreamCell(9853), MakeStringStreamCell("Guacamole"),
+						MakeIntegerStreamCell(500)},
+
+					{MakeIntegerStreamCell(2357), MakeStringStreamCell("Margarita"),
+						MakeIntegerStreamCell(700)},
 				},
 			},
 		},
@@ -118,15 +118,26 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1", "Sheet 1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 				{
-					{"Token", "Name", "Price", "SKU", "Stock"},
-					{"456", "Salsa", "200", "0346", "1"},
-					{"789", "Burritos", "400", "754", "3"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Stock")},
+
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(1)},
+
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(3)},
 				},
 			},
 			expectedError: fmt.Errorf("duplicate sheet name '%s'.", "Sheet 1"),
@@ -136,14 +147,20 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"456", "Salsa", "200", "0346"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
 				},
 			},
 			expectedError: AlreadyOnLastSheetError,
@@ -153,10 +170,14 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123", "asdf"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeStringStreamCell("asdf")},
 				},
 			},
 			expectedError: WrongNumberOfRowsError,
@@ -166,10 +187,13 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300)},
 				},
 			},
 			expectedError: WrongNumberOfRowsError,
@@ -179,13 +203,16 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1", "Sheet 2", "Sheet 3", "Sheet 4", "Sheet 5", "Sheet 6",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 				{{}},
-				{{"Id", "Unit Cost"}},
+				{{MakeStringStreamCell("Id"), MakeStringStreamCell("Unit Cost")}},
 				{{}},
 				{{}},
 				{{}},
@@ -196,10 +223,13 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1", "Sheet 2",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 				{{}},
 			},
@@ -209,33 +239,308 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet 1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
-					{"Token", "Name", "Price", "SKU", "Token", "Name", "Price", "SKU", "Token", "Name", "Price", "SKU", "Token", "Name", "Price", "SKU", "Token", "Name", "Price", "SKU", "Token", "Name", "Price", "SKU"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
-					{"123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123", "123", "Taco", "300", "0000000123"},
-					{"456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346", "456", "Salsa", "200", "0346"},
-					{"789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754", "789", "Burritos", "400", "754"},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU"),
+						MakeStringStreamCell("Token"), MakeStringStreamCell("Name"),
+						MakeStringStreamCell("Price"), MakeStringStreamCell("SKU")},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),
+						MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123),},
+					{MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346),
+						MakeIntegerStreamCell(456), MakeStringStreamCell("Salsa"),
+						MakeIntegerStreamCell(200), MakeIntegerStreamCell(346)},
+					{MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754),
+						MakeIntegerStreamCell(789), MakeStringStreamCell("Burritos"),
+						MakeIntegerStreamCell(400), MakeIntegerStreamCell(754)},
 				},
 			},
 		},
@@ -244,19 +549,23 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			sheetNames: []string{
 				"Sheet1",
 			},
-			workbookData: [][][]string{
+			workbookData: [][][]StreamCell{
 				{
 					// String courtesy of https://github.com/minimaxir/big-list-of-naughty-strings/
 					// Header row contains the tags that I am filtering on
-					{"Token", endSheetDataTag, "Price", fmt.Sprintf(dimensionTag, "A1:D1")},
+					{MakeStringStreamCell("Token"), MakeStringStreamCell(endSheetDataTag),
+						MakeStringStreamCell("Price"), MakeStringStreamCell(fmt.Sprintf(dimensionTag, "A1:D1"))},
 					// Japanese and emojis
-					{"123", "パーティーへ行かないか", "300", "🍕🐵 🙈 🙉 🙊"},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("パーティーへ行かないか"),
+						MakeIntegerStreamCell(300), MakeStringStreamCell("🍕🐵 🙈 🙉 🙊")},
 					// XML encoder/parser test strings
-					{"123", `<?xml version="1.0" encoding="ISO-8859-1"?>`, "300", `<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY ><!ENTITY xxe SYSTEM "file:///etc/passwd" >]><foo>&xxe;</foo>`},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell(`<?xml version="1.0" encoding="ISO-8859-1"?>`),
+						MakeIntegerStreamCell(300), MakeStringStreamCell(`<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY ><!ENTITY xxe SYSTEM "file:///etc/passwd" >]><foo>&xxe;</foo>`)},
 					// Upside down text and Right to Left Arabic text
-					{"123", `˙ɐnbᴉlɐ ɐuƃɐɯ ǝɹolop ʇǝ ǝɹoqɐl ʇn ʇunpᴉpᴉɔuᴉ ɹodɯǝʇ poɯsnᴉǝ op pǝs 'ʇᴉlǝ ƃuᴉɔsᴉdᴉpɐ ɹnʇǝʇɔǝsuoɔ 'ʇǝɯɐ ʇᴉs ɹolop ɯnsdᴉ ɯǝɹo˥
-					00˙Ɩ$-`, "300", `ﷺ`},
-					{"123", "Taco", "300", "0000000123"},
+					{MakeIntegerStreamCell(123), MakeStringStreamCell(`˙ɐnbᴉlɐ ɐuƃɐɯ ǝɹolop ʇǝ ǝɹoqɐl ʇn ʇunpᴉpᴉɔuᴉ ɹodɯǝʇ poɯsnᴉǝ op pǝs 'ʇᴉlǝ ƃuᴉɔsᴉdᴉpɐ ɹnʇǝʇɔǝsuoɔ 'ʇǝɯɐ ʇᴉs ɹolop ɯnsdᴉ ɯǝɹo˥
+					00˙Ɩ$-`), MakeIntegerStreamCell(300), MakeStringStreamCell(`ﷺ`)} ,
+					{MakeIntegerStreamCell(123), MakeStringStreamCell("Taco"),
+						MakeIntegerStreamCell(300), MakeIntegerStreamCell(123)},
 				},
 			},
 		},
@@ -268,34 +577,7 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 			filePath = fmt.Sprintf("Workbook%d.xlsx", i)
 		}
 
-		if testCase.cellStyles == nil {
-			testCase.cellStyles = [][][]StreamStyle{}
-			for j,_ := range testCase.workbookData{
-				testCase.cellStyles = append(testCase.cellStyles, [][]StreamStyle{})
-				for k,_ := range testCase.workbookData[j]{
-					testCase.cellStyles[j] = append(testCase.cellStyles[j], []StreamStyle{})
-					for  _,_ = range testCase.workbookData[j][k]{
-						testCase.cellStyles[j][k] = append(testCase.cellStyles[j][k], DefaultStringStyle)
-					}
-				}
-			}
-		}
-
-		if testCase.cellTypes == nil {
-			testCase.cellTypes = [][][]CellType{}
-			//testCase.cellTypes = append(testCase.cellTypes, [][]*CellType{})
-			for j,_ := range testCase.workbookData{
-				testCase.cellTypes = append(testCase.cellTypes, [][]CellType{})
-				for k,_ := range testCase.workbookData[j]{
-					testCase.cellTypes[j] = append(testCase.cellTypes[j], []CellType{})
-					for  _,_ = range testCase.workbookData[j][k]{
-						testCase.cellTypes[j][k] = append(testCase.cellTypes[j][k], CellTypeString)
-					}
-				}
-			}
-		}
-
-		err := writeStreamFile(filePath, &buffer, testCase.sheetNames, testCase.workbookData, testCase.cellStyles, testCase.cellTypes, TestsShouldMakeRealFiles)
+		err := writeStreamFile(filePath, &buffer, testCase.sheetNames, testCase.workbookData, TestsShouldMakeRealFiles)
 		if err != testCase.expectedError && err.Error() != testCase.expectedError.Error() {
 			t.Fatalf("Error differs from expected error. Error: %v, Expected Error: %v ", err, testCase.expectedError)
 		}
@@ -314,7 +596,19 @@ func (s *StreamSuite) TestXlsxStreamWrite(t *C) {
 		if !reflect.DeepEqual(actualSheetNames, testCase.sheetNames) {
 			t.Fatal("Expected sheet names to be equal")
 		}
-		if !reflect.DeepEqual(actualWorkbookData, testCase.workbookData) {
+
+		expectedWorkbookDataStrings := [][][]string{}
+		for j,_ := range testCase.workbookData {
+			expectedWorkbookDataStrings = append(expectedWorkbookDataStrings, [][]string{})
+			for k,_ := range testCase.workbookData[j]{
+				expectedWorkbookDataStrings[j] = append(expectedWorkbookDataStrings[j], []string{})
+				for _, cell := range testCase.workbookData[j][k] {
+					expectedWorkbookDataStrings[j][k] = append(expectedWorkbookDataStrings[j][k], cell.cellData)
+				}
+			}
+
+		}
+		if !reflect.DeepEqual(actualWorkbookData, expectedWorkbookDataStrings) {
 			t.Fatal("Expected workbook data to be equal")
 		}
 	}
@@ -373,7 +667,7 @@ func (s *StreamSuite) TestXlsxStyleBehavior(t *C) {
 }
 
 // writeStreamFile will write the file using this stream package
-func writeStreamFile(filePath string, fileBuffer io.Writer, sheetNames []string, workbookData [][][]string, cellStyles [][][]StreamStyle, cellTypes [][][]CellType, shouldMakeRealFiles bool) error {
+func writeStreamFile(filePath string, fileBuffer io.Writer, sheetNames []string, workbookData [][][]StreamCell, shouldMakeRealFiles bool) error {
 	var file *StreamFileBuilder
 	var err error
 	if shouldMakeRealFiles {
@@ -387,12 +681,7 @@ func writeStreamFile(filePath string, fileBuffer io.Writer, sheetNames []string,
 
 	for i, sheetName := range sheetNames {
 		header := workbookData[i][0]
-		headerCellStyles := cellStyles[i][0]
-		var sheetHeaderTypes []CellType
-		if i < len(cellTypes) {
-			sheetHeaderTypes = cellTypes[i][0]
-		}
-		err := file.AddSheet(sheetName, header, headerCellStyles, sheetHeaderTypes)
+		err := file.AddSheet(sheetName, header)
 		if err != nil {
 			return err
 		}
@@ -403,8 +692,6 @@ func writeStreamFile(filePath string, fileBuffer io.Writer, sheetNames []string,
 	}
 	for i, sheetData := range workbookData {
 
-		currentSheetCellTypes := cellTypes[i]
-		currentSheetCellStyles := cellStyles[i]
 		if i != 0 {
 			err = streamFile.NextSheet()
 			if err != nil {
@@ -415,9 +702,7 @@ func writeStreamFile(filePath string, fileBuffer io.Writer, sheetNames []string,
 			if i == 0 {
 				continue
 			}
-			currentCellStyles := currentSheetCellStyles[i]
-			currentCellTypes := currentSheetCellTypes[i]
-			err = streamFile.Write(row, currentCellTypes, currentCellStyles)
+			err = streamFile.Write(row)
 			if err != nil {
 				return err
 			}
@@ -469,11 +754,11 @@ func readXLSXFile(t *C, filePath string, fileBuffer io.ReaderAt, size int64, sho
 func (s *StreamSuite) TestAddSheetErrorsAfterBuild(t *C) {
 	file := NewStreamFileBuilder(bytes.NewBuffer(nil))
 
-	err := file.AddSheet("Sheet1", []string{"Header"}, []StreamStyle{DefaultStringStyle}, nil)
+	err := file.AddSheet("Sheet1", []StreamCell{MakeStringStreamCell("Header")})
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = file.AddSheet("Sheet2", []string{"Header2"}, []StreamStyle{DefaultStringStyle}, nil)
+	err = file.AddSheet("Sheet2", []StreamCell{MakeStringStreamCell("Header2")})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -482,7 +767,7 @@ func (s *StreamSuite) TestAddSheetErrorsAfterBuild(t *C) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = file.AddSheet("Sheet3", []string{"Header3"}, []StreamStyle{DefaultStringStyle}, nil)
+	err = file.AddSheet("Sheet3", []StreamCell{MakeStringStreamCell("Header3")})
 	if err != BuiltStreamFileBuilderError {
 		t.Fatal(err)
 	}
@@ -491,11 +776,11 @@ func (s *StreamSuite) TestAddSheetErrorsAfterBuild(t *C) {
 func (s *StreamSuite) TestBuildErrorsAfterBuild(t *C) {
 	file := NewStreamFileBuilder(bytes.NewBuffer(nil))
 
-	err := file.AddSheet("Sheet1", []string{"Header"}, []StreamStyle{DefaultStringStyle}, nil)
+	err := file.AddSheet("Sheet1", []StreamCell{MakeStringStreamCell("Header")})
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = file.AddSheet("Sheet2", []string{"Header2"}, []StreamStyle{DefaultStringStyle}, nil)
+	err = file.AddSheet("Sheet2", []StreamCell{MakeStringStreamCell("Header")})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -515,23 +800,15 @@ func (s *StreamSuite) TestCloseWithNothingWrittenToSheets(t *C) {
 	file := NewStreamFileBuilder(buffer)
 
 	sheetNames := []string{"Sheet1", "Sheet2"}
-	workbookData := [][][]string{
-		{{"Header1", "Header2"}},
-		{{"Header3", "Header4"}},
-	}
-	cellStyles := [][][]StreamStyle{
-		{{DefaultStringStyle, DefaultStringStyle}},
-		{{DefaultStringStyle, DefaultStringStyle}},
-	}
-	cellTypes := [][][]CellType{
-		{{CellTypeString, CellTypeString}},
-		{{CellTypeString, CellTypeString}},
+	workbookData := [][][]StreamCell{
+		{{MakeStringStreamCell("Header1"), MakeStringStreamCell("Header2")}},
+		{{MakeStringStreamCell("Header3"), MakeStringStreamCell("Header4")}},
 	}
-	err := file.AddSheet(sheetNames[0], workbookData[0][0], cellStyles[0][0], cellTypes[0][0])
+	err := file.AddSheet(sheetNames[0], workbookData[0][0])
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = file.AddSheet(sheetNames[1], workbookData[1][0], cellStyles[1][0], cellTypes[1][0])
+	err = file.AddSheet(sheetNames[1], workbookData[1][0])
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -552,7 +829,18 @@ func (s *StreamSuite) TestCloseWithNothingWrittenToSheets(t *C) {
 	if !reflect.DeepEqual(actualSheetNames, sheetNames) {
 		t.Fatal("Expected sheet names to be equal")
 	}
-	if !reflect.DeepEqual(actualWorkbookData, workbookData) {
+	expectedWorkbookDataStrings := [][][]string{}
+	for j,_ := range workbookData {
+		expectedWorkbookDataStrings = append(expectedWorkbookDataStrings, [][]string{})
+		for k,_ := range workbookData[j]{
+			expectedWorkbookDataStrings[j] = append(expectedWorkbookDataStrings[j], []string{})
+			for _, cell := range workbookData[j][k] {
+				expectedWorkbookDataStrings[j][k] = append(expectedWorkbookDataStrings[j][k], cell.cellData)
+			}
+		}
+
+	}
+	if !reflect.DeepEqual(actualWorkbookData, expectedWorkbookDataStrings) {
 		t.Fatal("Expected workbook data to be equal")
 	}
 }
@@ -572,30 +860,18 @@ func (s *StreamSuite) TestMakeNewStyleAndUseIt(t *C){
 	greenFill := NewFill(Solid_Cell_Fill, RGB_Light_Green, RGB_White)
 	redFill   := NewFill(Solid_Cell_Fill, RGB_Light_Red,   RGB_White)
 
-	greenStyle := MakeStyle(0, *timesNewRoman12, *greenFill, *DefaultAlignment() , *DefaultBorder())
-	redStyle :=   MakeStyle(0, *courier20, *redFill, *DefaultAlignment(), *DefaultBorder())
+	greenStyle := MakeStyle(0, timesNewRoman12, greenFill, DefaultAlignment(), DefaultBorder())
+	redStyle :=   MakeStyle(0, courier20, redFill, DefaultAlignment(), DefaultBorder())
 
 	sheetNames := []string{"Sheet1"}
-	workbookData := [][][]string{
-		{
-			{"Header1", "Header2"},
-			{"Good", "Bad"},
-		},
-	}
-	cellStyles := [][][]StreamStyle{
-		{
-			{DefaultStringStyle, DefaultStringStyle},
-			{greenStyle,         redStyle},
-		},
-	}
-	cellTypes := [][][]CellType{
+	workbookData := [][][]StreamCell{
 		{
-			{CellTypeString, CellTypeString},
-			{CellTypeString, CellTypeString},
+			{MakeStringStreamCell("Header1"), MakeStringStreamCell("Header2")},
+			{MakeStyledStringStreamCell("Good", greenStyle), MakeStyledStringStreamCell("Bad", redStyle)},
 		},
 	}
 
-	err := writeStreamFile(filePath, &buffer, sheetNames, workbookData, cellStyles, cellTypes, TestsShouldMakeRealFiles)
+	err := writeStreamFile(filePath, &buffer, sheetNames, workbookData, TestsShouldMakeRealFiles)
 
 	if err != nil {
 		t.Fatal("Error during writing")
@@ -613,7 +889,20 @@ func (s *StreamSuite) TestMakeNewStyleAndUseIt(t *C){
 	if !reflect.DeepEqual(actualSheetNames, sheetNames) {
 		t.Fatal("Expected sheet names to be equal")
 	}
-	if !reflect.DeepEqual(actualWorkbookData, workbookData) {
+
+	expectedWorkbookDataStrings := [][][]string{}
+	for j,_ := range workbookData {
+		expectedWorkbookDataStrings = append(expectedWorkbookDataStrings, [][]string{})
+		for k,_ := range workbookData[j]{
+			expectedWorkbookDataStrings[j] = append(expectedWorkbookDataStrings[j], []string{})
+			for _, cell := range workbookData[j][k] {
+				expectedWorkbookDataStrings[j][k] = append(expectedWorkbookDataStrings[j][k], cell.cellData)
+			}
+		}
+
+	}
+
+	if !reflect.DeepEqual(actualWorkbookData, expectedWorkbookDataStrings) {
 		t.Fatal("Expected workbook data to be equal")
 	}
 }