How to use NewWriter method of internal Package

...9		name    string10		w       *Writer11		wantErr bool12	}{13		{"base", NewWriter(&bytes.Buffer{}), false},14	}15	for _, tt := range tests {16		t.Run(tt.name, func(t *testing.T) {17			if err := tt.w.Flush(); (err != nil) != tt.wantErr {18				t.Errorf("Writer.Flush() error = %v, wantErr %v", err, tt.wantErr)19			}20		})21	}22}23func TestWriter_Close(t *testing.T) {24	p := newPackage()25	p.contentTypes.add("/a.xml", "a/b")26	p.contentTypes.add("/b.xml", "c/d")27	pCore := newPackage()28	pCore.parts["/PROPS/CORE.XML"] = struct{}{}29	pRel := newPackage()30	pRel.parts["/_RELS/.RELS"] = struct{}{}31	tests := []struct {32		name    string33		w       *Writer34		wantErr bool35	}{36		{"base", NewWriter(&bytes.Buffer{}), false},37		{"withCt", &Writer{p: p, w: zip.NewWriter(&bytes.Buffer{})}, false},38		{"invalidPartRel", &Writer{p: newPackage(), w: zip.NewWriter(&bytes.Buffer{}), last: &Part{Name: "/b.xml", Relationships: []*Relationship{{}}}}, true},39		{"invalidOwnRel", &Writer{p: newPackage(), w: zip.NewWriter(&bytes.Buffer{}), Relationships: []*Relationship{{}}}, true},40		{"withDuplicatedCoreProps", &Writer{p: pCore, w: zip.NewWriter(&bytes.Buffer{}), Properties: CoreProperties{Title: "Song"}}, true},41		{"withDuplicatedRels", &Writer{p: pRel, w: zip.NewWriter(&bytes.Buffer{}), Properties: CoreProperties{Title: "Song"}}, true},42		{"withCoreProps", &Writer{p: newPackage(), w: zip.NewWriter(&bytes.Buffer{}), Properties: CoreProperties{Title: "Song"}}, false},43		{"withCorePropsWithName", &Writer{p: newPackage(), w: zip.NewWriter(&bytes.Buffer{}), Relationships: []*Relationship{44			{TargetURI: "props.xml", Type: corePropsRel},45		}, Properties: CoreProperties{Title: "Song", PartName: "props.xml"}}, false},46		{"withCorePropsWithNameAndId", &Writer{p: newPackage(), w: zip.NewWriter(&bytes.Buffer{}), Properties: CoreProperties{Title: "Song", PartName: "/docProps/props.xml", RelationshipID: "rId1"}}, false},47	}48	for _, tt := range tests {49		t.Run(tt.name, func(t *testing.T) {50			if err := tt.w.Close(); (err != nil) != tt.wantErr {51				t.Errorf("Writer.Close() error = %v, wantErr %v", err, tt.wantErr)52			}53		})54	}55}56func TestWriter_setCompressor(t *testing.T) {57	type args struct {58		fh          *zip.FileHeader59		compression CompressionOption60	}61	tests := []struct {62		name     string63		w        *Writer64		args     args65		wantFlag uint1666	}{67		{"none", NewWriter(nil), args{&zip.FileHeader{}, CompressionNone}, 0x0},68		{"normal", NewWriter(nil), args{&zip.FileHeader{}, CompressionNormal}, 0x0},69		{"max", NewWriter(nil), args{&zip.FileHeader{}, CompressionMaximum}, 0x2},70		{"fast", NewWriter(nil), args{&zip.FileHeader{}, CompressionFast}, 0x4},71		{"sfast", NewWriter(nil), args{&zip.FileHeader{}, CompressionSuperFast}, 0x6},72	}73	for _, tt := range tests {74		t.Run(tt.name, func(t *testing.T) {75			tt.w.setCompressor(tt.args.fh, tt.args.compression)76			if tt.args.fh.Method != zip.Deflate {77				t.Error("Writer.setCompressor() should have set the method flag the deflate")78			}79		})80	}81}82func Test_compressionFunc(t *testing.T) {83	type args struct {84		comp int85	}86	tests := []struct {87		name string88		args args89	}{90		{"base", args{1}},91	}92	for _, tt := range tests {93		t.Run(tt.name, func(t *testing.T) {94			compressionFunc(tt.args.comp)(&bytes.Buffer{})95		})96	}97}98func TestWriter_Create(t *testing.T) {99	type args struct {100		uri         string101		contentType string102	}103	tests := []struct {104		name    string105		w       *Writer106		args    args107		wantErr bool108	}{109		{"base", NewWriter(&bytes.Buffer{}), args{"/a.xml", "application/xml"}, false},110		{"nameErr", NewWriter(&bytes.Buffer{}), args{"a.xml", "a/b"}, true},111	}112	for _, tt := range tests {113		t.Run(tt.name, func(t *testing.T) {114			got, err := tt.w.Create(tt.args.uri, tt.args.contentType)115			if (err != nil) != tt.wantErr {116				t.Errorf("Writer.Create() error = %v, wantErr %v", err, tt.wantErr)117				return118			}119			if !tt.wantErr && got == nil {120				t.Error("Writer.Create() want writer")121			}122		})123	}124}125func TestWriter_CreatePart(t *testing.T) {126	rel := &Relationship{ID: "fakeId", Type: "asd", TargetURI: "/fakeTarget", TargetMode: ModeInternal}127	w := NewWriter(&bytes.Buffer{})128	pRel := newPackage()129	pRel.parts["/_RELS/A.XML.RELS"] = struct{}{}130	type args struct {131		part        *Part132		compression CompressionOption133	}134	tests := []struct {135		name    string136		w       *Writer137		args    args138		wantErr bool139	}{140		{"unicode", NewWriter(&bytes.Buffer{}), args{&Part{"/a/ц.xml", "a/b", nil}, CompressionNone}, false},141		{"fhErr", NewWriter(&bytes.Buffer{}), args{&Part{"/a.xml", "a/b", nil}, -3}, true},142		{"nameErr", NewWriter(&bytes.Buffer{}), args{&Part{"a.xml", "a/b", nil}, CompressionNone}, true},143		{"failRel", &Writer{w: zip.NewWriter(nil), last: &Part{Name: "/b.xml", Relationships: []*Relationship{{}}}}, args{&Part{"/a.xml", "a/b", nil}, CompressionNone}, true},144		{"failRel2", &Writer{p: pRel, w: zip.NewWriter(nil), last: &Part{Name: "/a.xml", Relationships: []*Relationship{rel}}}, args{&Part{"/b.xml", "a/b", nil}, CompressionNone}, true},145		{"base", w, args{&Part{"/a.xml", "a/b", nil}, CompressionNone}, false},146		{"multipleDiffName", w, args{&Part{"/b.xml", "a/b", nil}, CompressionNone}, false},147		{"multipleDiffContentType", w, args{&Part{"/c.xml", "c/d", nil}, CompressionNone}, false},148		{"duplicated", w, args{&Part{"/c.xml", "c/d", nil}, CompressionNone}, true},149	}150	for _, tt := range tests {151		t.Run(tt.name, func(t *testing.T) {152			got, err := tt.w.CreatePart(tt.args.part, tt.args.compression)153			if (err != nil) != tt.wantErr {154				t.Errorf("Writer.CreatePart() error = %v, wantErr %v", err, tt.wantErr)155				return156			}157			if !tt.wantErr && got == nil {158				t.Error("Writer.CreatePart want a valid writer")159			}160		})161	}162}163func TestWriter_createLastPartRelationships(t *testing.T) {164	rel := &Relationship{ID: "fakeId", Type: "asd", TargetURI: "/fakeTarget", TargetMode: ModeInternal}165	w := NewWriter(&bytes.Buffer{})166	w.last = &Part{Name: "/a.xml", Relationships: []*Relationship{rel}}167	tests := []struct {168		name    string169		w       *Writer170		wantErr bool171	}{172		{"base", &Writer{p: newPackage(), w: zip.NewWriter(nil), last: &Part{Name: "/a.xml", Relationships: []*Relationship{rel}}}, false},173		{"base2", &Writer{p: newPackage(), w: zip.NewWriter(nil), last: &Part{Name: "/b/a.xml", Relationships: []*Relationship{rel}}}, false},174		{"hasSome", w, false},175		{"duplicated", &Writer{w: zip.NewWriter(nil), last: &Part{Name: "/a.xml", Relationships: []*Relationship{rel, rel}}}, true},176		{"invalidRelation", &Writer{w: zip.NewWriter(nil), last: &Part{Name: "/a.xml", Relationships: []*Relationship{{}}}}, true},177		{"empty", NewWriter(&bytes.Buffer{}), false},178	}179	for _, tt := range tests {180		t.Run(tt.name, func(t *testing.T) {181			if err := tt.w.createLastPartRelationships(); (err != nil) != tt.wantErr {182				t.Errorf("Writer.createLastPartRelationships() error = %v, wantErr %v", err, tt.wantErr)183			}184		})185	}186}187func TestNewWriterFromReader(t *testing.T) {188	r, err := OpenReader("testdata/office.docx")189	if err != nil {190		t.Fatalf("failed to open test file: %v", err)191	}192	var buf bytes.Buffer193	w, err := NewWriterFromReader(&buf, r.Reader)194	if err != nil {195		t.Fatalf("NewWriterFromReader() error: %v", err)196	}197	if w.Properties != r.Properties {198		t.Error("NewWriterFromReader() haven't copied core properties")199	}200	if len(w.Relationships) != len(r.Relationships) {201		t.Error("NewWriterFromReader() haven't copied package relationships")202	}203	if err = w.Close(); err != nil {204		t.Errorf("NewWriterFromReader() created package that cannot be closed: %v", err)205	}206}...

...38	if err != nil {39		t.Fatal(err)40	}41	orcBuffer1 := &bytes.Buffer{}42	writer, _ := eorc.NewWriter(orcBuffer1,43		eorc.SetSchema(orcSchema))44	_ = writer.Write("eventName", 1, 1.0)45	_ = writer.Close()46	orcBuffer2 := &bytes.Buffer{}47	writer, _ = eorc.NewWriter(orcBuffer2,48		eorc.SetSchema(orcSchema))49	_ = writer.Write("eventName", 2, 2.0)50	_ = writer.Close()51	block1, err := block.FromOrcBy(orcBuffer1.Bytes(), "col0", nil)52	block2, err := block.FromOrcBy(orcBuffer2.Bytes(), "col0", nil)53	mergedBlocks := []block.Block{}54	for _, blk := range block1 {55		mergedBlocks = append(mergedBlocks, blk)56	}57	for _, blk := range block2 {58		mergedBlocks = append(mergedBlocks, blk)59	}60	fileName, mergedValue := flusher.Merge(mergedBlocks, schema)61	orcBuffer := &bytes.Buffer{}62	writer, _ = eorc.NewWriter(orcBuffer,63		eorc.SetSchema(orcSchema),64		eorc.SetCompression(eorc.CompressionZlib{Level: flate.DefaultCompression}))65	_ = writer.Write("eventName", 1, 1.0)66	_ = writer.Write("eventName", 2, 2.0)67	_ = writer.Close()68	if !bytes.Equal(orcBuffer.Bytes(), mergedValue) {69		t.Fatal("Merged orc value differ")70	}71	if !bytes.Equal([]byte("eventName-0"), fileName) {72		t.Fatal("File name differ")73	}74}75func TestMerge_DifferentSchema(t *testing.T) {76	fileNameFunc := func(row map[string]interface{}) (string, error) {77		lua, _ := column.NewComputed("fileName", typeof.String, `78		function main(row)79			current_time = 080			fileName = string.format("%s-%d",row["col0"],0)81			return fileName82		end`, script.NewLoader(nil))83		output, err := lua.Value(row)84		return output.(string), err85	}86	flusher := New(monitor.NewNoop(), writers.NewNoop(), fileNameFunc)87	schema := typeof.Schema{88		"col0": typeof.String,89		"col1": typeof.Int64,90		"col2": typeof.Float64,91	}92	schema2 := typeof.Schema{93		"col0": typeof.String,94		"col1": typeof.Int64,95		"col2": typeof.Float64,96		"col3": typeof.String,97	}98	orcSchema, err := orc.SchemaFor(schema)99	if err != nil {100		t.Fatal(err)101	}102	orcSchema2, err := orc.SchemaFor(schema2)103	if err != nil {104		t.Fatal(err)105	}106	orcBuffer1 := &bytes.Buffer{}107	writer, _ := eorc.NewWriter(orcBuffer1,108		eorc.SetSchema(orcSchema))109	_ = writer.Write("eventName", 1, 1.0)110	_ = writer.Close()111	orcBuffer2 := &bytes.Buffer{}112	writer, _ = eorc.NewWriter(orcBuffer2,113		eorc.SetSchema(orcSchema2))114	_ = writer.Write("eventName", 2, 2.0, "s")115	_ = writer.Close()116	block1, err := block.FromOrcBy(orcBuffer1.Bytes(), "col0", nil)117	block2, err := block.FromOrcBy(orcBuffer2.Bytes(), "col0", nil)118	mergedBlocks := []block.Block{}119	for _, blk := range block1 {120		mergedBlocks = append(mergedBlocks, blk)121	}122	for _, blk := range block2 {123		mergedBlocks = append(mergedBlocks, blk)124	}125	fileName, mergedValue := flusher.Merge(mergedBlocks, schema2)126	orcBuffer := &bytes.Buffer{}127	writer, _ = eorc.NewWriter(orcBuffer,128		eorc.SetSchema(orcSchema2),129		eorc.SetCompression(eorc.CompressionZlib{Level: flate.DefaultCompression}))130	_ = writer.Write("eventName", 1, 1.0, nil)131	_ = writer.Write("eventName", 2, 2.0, "s")132	_ = writer.Close()133	if !bytes.Equal(orcBuffer.Bytes(), mergedValue) {134		t.Fatal("Merged orc value differ")135	}136	if !bytes.Equal([]byte("eventName-0"), fileName) {137		t.Fatal("File name differ")138	}139}140// BenchmarkFlush runs a benchmark for a Merge function for flushing141// To run it, go in the directory and do 'go test -benchmem -bench=. -benchtime=1s'...

1package internal_test2import (3	"github.com/gschier/wyp/internal"4	"github.com/stretchr/testify/assert"5	"testing"6)7func TestPrefixedWriter_Write(t *testing.T) {8	t.Run("works with single line", func(t *testing.T) {9		w := newWriter()10		pw := internal.NewPrefixedWriter(w, "name", nil)11		_, _ = pw.Write([]byte("Hello"))12		assert.Contains(t, w.s, "[name] ")13	})14	t.Run("works with multiple lines", func(t *testing.T) {15		w := newWriter()16		pw := internal.NewPrefixedWriter(w, "name", nil)17		_, _ = pw.Write([]byte("First line\nSecond line\n"))18		assert.Equal(t, "[name] First line\n[name] Second line\n", w.s)19	})20	t.Run("doesn't prefix if last line didn't end in newline", func(t *testing.T) {21		w := newWriter()22		pw := internal.NewPrefixedWriter(w, "name", nil)23		_, _ = pw.Write([]byte("First line "))24		_, _ = pw.Write([]byte("More stuff"))25		assert.Equal(t, "[name] First line More stuff", w.s)26	})27	t.Run("should prefix carriage returns", func(t *testing.T) {28		w := newWriter()29		pw := internal.NewPrefixedWriter(w, "name", nil)30		_, _ = pw.Write([]byte("First line\r"))31		_, _ = pw.Write([]byte("Overwrite first line"))32		assert.Equal(t, "[name] First line\r[name] Overwrite first line", w.s)33	})34	t.Run("should prefix carriage returns same line", func(t *testing.T) {35		w := newWriter()36		pw := internal.NewPrefixedWriter(w, "name", nil)37		_, _ = pw.Write([]byte("First line\rOverwrite\n"))38		assert.Equal(t, "[name] First line\r[name] Overwrite\n", w.s)39	})40}41type writer struct {42	s string43}44func newWriter() *writer {45	return &writer{s: ""}46}47func (w *writer) Write(p []byte) (n int, err error) {48	w.s += string(p)49	return len(p), nil50}...

1import (2func main() {3    f, err := os.Create("test.txt")4    if err != nil {5        fmt.Println(err)6    }7    defer f.Close()8    w := io.NewWriter(f)9    w.Write([]byte("hello"))10}

1import (2func main() {3	f, err := os.Create("test.txt")4	if err != nil {5		fmt.Println(err)6	}7	defer f.Close()8	w := io.NewWriter(f)9	w.Write([]byte("Hello World"))10}11import (12func main() {13	f, err := os.Create("test.txt")14	if err != nil {15		fmt.Println(err)16	}17	defer f.Close()18	w := io.NewWriter(f)19	w.Write([]byte("Hello World"))20}21import (22func main() {23	f, err := os.Create("test.txt")24	if err != nil {25		fmt.Println(err)26	}27	defer f.Close()28	w := io.NewWriter(f)29	w.Write([]byte("Hello World"))30}31import (32func main() {33	f, err := os.Create("test.txt")34	if err != nil {35		fmt.Println(err)36	}37	defer f.Close()38	w := io.NewWriter(f)39	w.Write([]byte("Hello World"))40}41import (42func main() {43	f, err := os.Create("test.txt")44	if err != nil {45		fmt.Println(err)46	}47	defer f.Close()48	w := io.NewWriter(f)49	w.Write([]byte("Hello World"))50}51import (52func main() {53	f, err := os.Create("test.txt")54	if err != nil {55		fmt.Println(err)56	}57	defer f.Close()58	w := io.NewWriter(f)59	w.Write([]byte("Hello World"))60}61import (

1import (2func main() {3	file, err := os.OpenFile("test.txt", os.O_WRONLY|os.O_CREATE, 0644)4	if err != nil {5		fmt.Printf("Error: %v6	}7	defer file.Close()8	writer := bufio.NewWriter(file)9	writer.WriteString("Hello World!")10	writer.Flush()11}12Write() method13import (14func main() {15	file, err := os.OpenFile("test.txt", os.O_WRONLY|os.O_CREATE, 0644)16	if err != nil {17		fmt.Printf("Error: %v18	}19	defer file.Close()20	writer := bufio.NewWriter(file)21	writer.Write([]byte("Hello World!"))22	writer.Flush()23}24ReadString() method25import (26func main() {27	file, err := os.OpenFile("test.txt", os.O_RDONLY, 0644)28	if err != nil {29		fmt.Printf("Error: %v30	}31	defer file.Close()32	reader := bufio.NewReader(file)33	str, err := reader.ReadString('!')34	if err != nil {35		fmt.Printf("Error: %v36	}37	fmt.Printf("String read: %v38}

1import (2func main() {3	file, err := os.OpenFile("file.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)4	if err != nil {5		fmt.Println("Error in opening file")6	}7	defer file.Close()8	writer := bufio.NewWriter(file)9	_, err = writer.WriteString("This is the new line")10	if err != nil {11		fmt.Println("Error in writing to file")12	}13	writer.Flush()14}

1import (2func main() {3    file, err := os.Create("file.txt")4    if err != nil {5        fmt.Println(err)6    }7    defer file.Close()8    writer := io.NewWriter(file)9    writer.Write([]byte("Hello world"))10}11import (12func main() {13    file, err := os.Create("file.txt")14    if err != nil {15        fmt.Println(err)16    }17    defer file.Close()18    writer := ioutil.NewWriter(file)19    writer.Write([]byte("Hello world"))20}21import (22func main() {23    file, err := os.Create("file.txt")24    if err != nil {25        fmt.Println(err)26    }27    defer file.Close()28    writer := ioutil.NewWriter(file)29    writer.Write([]byte("Hello world"))30}31import (32func main() {33    file, err := os.Create("file.txt")34    if err != nil {35        fmt.Println(err)36    }37    defer file.Close()38    writer := ioutil.NewWriter(file)39    writer.Write([]byte("Hello world"))40}41import (42func main() {43    file, err := os.Create("file.txt")

1import (2func main() {3	fmt.Println("Enter text: ")4	reader := bufio.NewReader(os.Stdin)5	input, _ := reader.ReadString('6	fmt.Println(input)7}

1import (2func NewWriter(w io.Writer) io.Writer {3	return &writer{w}4}5type writer struct {6}7func (w *writer) Write(p []byte) (n int, err error) {8	return w.w.Write(p)9}10func main() {11	w := NewWriter(os.Stdout)12	fmt.Fprintln(w, "Hello, playground")13}14import (15func main() {16	w := io.NewWriter(os.Stdout)17	fmt.Fprintln(w, "Hello, playground")18}19./2.go:9: cannot use os.Stdout (type *os.File) as type io.Writer in argument to io.NewWriter:20	*os.File does not implement io.Writer (missing Write method)

1import (2func main() {3	writer := bufio.NewWriter(os.Stdout)4	writer.WriteString("Hello, ")5	writer.WriteString("World!")6	writer.Flush()7	fmt.Println()8}9import (10func main() {11	reader := bufio.NewReader(os.Stdin)12	writer := bufio.NewWriter(os.Stdout)13	writer.WriteString("Enter text: ")14	writer.Flush()15	text, _ := reader.ReadString('16	writer.WriteString(text)17	writer.Flush()18}19import (20func main() {21	scanner := bufio.NewScanner(os.Stdin)22	scanner.Scan()23	fmt.Println(scanner.Text())24}25import (26func main() {27	writer := bufio.NewWriterSize(os.Stdout, 16)28	writer.WriteString("Hello, ")29	writer.WriteString("World!")30	writer.Flush()31	fmt.Println()32}33import (34func main() {35	reader := bufio.NewReader(os.Stdin)36	writer := bufio.NewWriter(os.Stdout)37	writer.WriteString("Enter text: ")38	writer.Flush()39	text, _ := reader.ReadString('40	writer.WriteString(text)41	writer.Flush()42}43import (44func main() {45	scanner := bufio.NewScanner(os.Stdin)46	scanner.Scan()47	fmt.Println(scanner.Text())48}49import (50func main() {51	writer := bufio.NewWriterSize(os.Stdout, 16)52	writer.WriteString("Hello, ")53	writer.WriteString("World!")54	writer.Flush()

1import (2func main() {3	w = mylib.NewWriter()4	fmt.Println(w)5}6import "fmt"7type Writer struct{}8func NewWriter() Writer {9	fmt.Println("NewWriter method of internal class")10	return Writer{}11}12type Writer struct{}13func NewWriter() Writer {14	return Writer{}15}16./1.go:8: cannot use mylib.NewWriter() (type Writer) as type internal.Writer in assignment:17import (18func main() {19    w = internal.NewWriter()20    fmt.Println(w)21}22import "fmt"23type Writer struct{}24func NewWriter() Writer {25    fmt.Println("NewWriter method of internal class")26    return Writer{}27}