after`},
},
{
name: "non-breaking and soft hyphens",
body: `
abc`,
want: []string{"a\u2011b\u00adc"},
},
}
for _, tc := range tests {
doc := parseTestDocx(t, tc.body, nil)
for _, w := range tc.want {
if !strings.Contains(doc.HTML, w) {
t.Errorf("%s: want %q in %s", tc.name, w, doc.HTML)
}
}
for _, d := range tc.dont {
if strings.Contains(doc.HTML, d) {
t.Errorf("%s: did not want %q in %s", tc.name, d, doc.HTML)
}
}
}
}
func TestDocxReaderFootnotes(t *testing.T) {
body := `
text`
notes := `
` +
`` +
` the note`
doc := parseTestDocx(t, body, map[string]string{"word/footnotes.xml": notes})
if !strings.Contains(doc.HTML, `
1`) {
t.Errorf("footnote reference not imported: %s", doc.HTML)
}
if strings.Count(doc.HTML, "
` +
``
picture := func(rot string) string {
return `` +
`` +
`` +
``
}
tests := []struct {
name, rot, want string
}{
{"upright", ``, "width:40pt;height:20pt;object-fit:fill;object-view-box:inset(10% 0% 0% 0%)"},
{"quarter turn", `rot="5400000"`, "width:20pt;height:40pt;object-fit:fill;object-view-box:inset(0% 10% 0% 0%)"},
}
for _, tc := range tests {
zipData := testDocx(t, picture(tc.rot), map[string]string{
"word/_rels/document.xml.rels": rels,
})
// the media part is binary: add it by rebuilding with the bytes
doc := parseDocxWithMedia(t, zipData, "word/media/p.png", pngBuf.Bytes())
if !strings.Contains(doc.HTML, tc.want) {
t.Errorf("%s: want %q in %.400s", tc.name, tc.want, doc.HTML)
}
}
}
// parseDocxWithMedia adds one binary part to a test package and parses it
func parseDocxWithMedia(t *testing.T, zipData []byte, name string, data []byte) *Document {
t.Helper()
zr, err := zip.NewReader(bytes.NewReader(zipData), int64(len(zipData)))
if err != nil {
t.Fatalf("zip: %v", err)
}
var buf bytes.Buffer
zw := zip.NewWriter(&buf)
for _, f := range zr.File {
rc, err := f.Open()
if err != nil {
t.Fatalf("zip open: %v", err)
}
w, _ := zw.Create(f.Name)
var b bytes.Buffer
if _, err := b.ReadFrom(rc); err != nil {
t.Fatalf("zip read: %v", err)
}
rc.Close()
w.Write(b.Bytes())
}
w, _ := zw.Create(name)
w.Write(data)
if err := zw.Close(); err != nil {
t.Fatalf("zip close: %v", err)
}
doc, err := ParseDocx(buf.Bytes())
if err != nil {
t.Fatalf("ParseDocx: %v", err)
}
return doc
}
func TestDocxRichRoundTrip(t *testing.T) {
// the editor's own model survives docx -> model unchanged
tests := []struct {
name, html string
}{
{"spacing and indents", `x
`},
{"exact line height", `x
`},
{"line spacing", `x
`},
{"keep with next", `x
`},
{"tab stops", `a` + "\t" + `1
`},
{"footnote reference", `a1
`},
{"page field", `1
`},
{"shaded paragraph", `x
`},
{"trailing line break", `x
`},
{"horizontal rule", `a
b
`},
{"bordered paragraph", `x
`},
}
for _, tc := range tests {
src := &Document{HTML: tc.html, Footnotes: []Footnote{{ID: "1", HTML: "note
"}}}
data, err := BuildDocx(src)
if err != nil {
t.Fatalf("%s: BuildDocx: %v", tc.name, err)
}
back, err := ParseDocx(data)
if err != nil {
t.Fatalf("%s: ParseDocx: %v", tc.name, err)
}
if !strings.Contains(back.HTML, tc.html) {
t.Errorf("%s: want %s, got %s", tc.name, tc.html, back.HTML)
}
}
}
func TestDocxWriterEditorBoxes(t *testing.T) {
tests := []struct {
name, html string
want []string
}{
{
// docs.css: 3px rule, 12px padding, 8pt + 2pt either side
name: "blockquote",
html: `quoted
`,
want: []string{``,
``},
},
{
// a 1px frame with 10px 12px inside: the half point w:space
// cannot hold goes to the spacing outside
name: "code block",
html: `code
`,
want: []string{``,
``,
``, `w:ascii="Consolas"`},
},
{
name: "an indent blockquote from the browser keeps no rule",
html: `x
`,
want: []string{`| H |
|---|
`,
want: []string{``, ``},
},
{
name: "imported table stays a Word table",
html: ``,
want: []string{``},
},
{
name: "rule",
html: `
`,
want: []string{``, `w:line="20" w:lineRule="exact"`},
},
}
for _, tc := range tests {
data, err := BuildDocx(&Document{HTML: tc.html})
if err != nil {
t.Fatalf("%s: BuildDocx: %v", tc.name, err)
}
body := string(zipPart(t, data, "word/document.xml"))
for _, w := range tc.want {
if !strings.Contains(body, w) {
t.Errorf("%s: want %s in %s", tc.name, w, body)
}
}
}
// the indent blockquote draws no rule
data, _ := BuildDocx(&Document{HTML: tests[2].html})
if body := string(zipPart(t, data, "word/document.xml")); strings.Contains(body, "") {
t.Errorf("border:none blockquote got a rule: %s", body)
}
}
func TestDocxPlainHeaderStaysPlain(t *testing.T) {
data, err := BuildDocx(&Document{HTML: "x
", Header: "Top & tail", Footer: "Bottom"})
if err != nil {
t.Fatalf("BuildDocx: %v", err)
}
back, err := ParseDocx(data)
if err != nil {
t.Fatalf("ParseDocx: %v", err)
}
if back.Header != "Top & tail" || back.HeaderHTML != "" {
t.Errorf("header = %q / %q, want plain text", back.Header, back.HeaderHTML)
}
if back.Footer != "Bottom" || back.FooterHTML != "" || back.PageNumbers {
t.Errorf("footer = %q / %q pn=%v, want plain text", back.Footer, back.FooterHTML, back.PageNumbers)
}
}