package html
import (
"bytes"
"fmt"
"io/ioutil"
"regexp"
"strings"
"testing"
assert "github.com/alecthomas/assert/v2"
"github.com/alecthomas/chroma/v2"
"github.com/alecthomas/chroma/v2/lexers"
"github.com/alecthomas/chroma/v2/styles"
)
func TestCompressStyle(t *testing.T) {
style := "color: #888888; background-color: #faffff"
actual := compressStyle(style)
expected := "color:#888;background-color:#faffff"
assert.Equal(t, expected, actual)
}
func BenchmarkHTMLFormatter(b *testing.B) {
formatter := New()
b.ResetTimer()
for i := 0; i < b.N; i++ {
it, err := lexers.Get("go").Tokenise(nil, "package main\nfunc main()\n{\nprintln(`hello world`)\n}\n")
assert.NoError(b, err)
err = formatter.Format(ioutil.Discard, styles.Fallback, it)
assert.NoError(b, err)
}
}
func TestSplitTokensIntoLines(t *testing.T) {
in := []chroma.Token{
{Value: "hello", Type: chroma.NameKeyword},
{Value: " world\nwhat?\n", Type: chroma.NameKeyword},
}
expected := [][]chroma.Token{
{
{Type: chroma.NameKeyword, Value: "hello"},
{Type: chroma.NameKeyword, Value: " world\n"},
},
{
{Type: chroma.NameKeyword, Value: "what?\n"},
},
}
actual := chroma.SplitTokensIntoLines(in)
assert.Equal(t, expected, actual)
}
func TestFormatterStyleToCSS(t *testing.T) {
builder := styles.Get("github").Builder()
builder.Add(chroma.LineHighlight, "bg:#ffffcc")
builder.Add(chroma.LineNumbers, "bold")
style, err := builder.Build()
if err != nil {
t.Error(err)
}
formatter := New(WithClasses(true))
css := formatter.styleToCSS(style)
for _, s := range css {
if strings.HasPrefix(strings.TrimSpace(s), ";") {
t.Errorf("rule starts with semicolon - expected valid css rule without semicolon: %v", s)
}
}
}
func TestClassPrefix(t *testing.T) {
wantPrefix := "some-prefix-"
withPrefix := New(WithClasses(true), ClassPrefix(wantPrefix))
noPrefix := New(WithClasses(true))
for st := range chroma.StandardTypes {
if noPrefix.class(st) == "" {
if got := withPrefix.class(st); got != "" {
t.Errorf("Formatter.class(%v): prefix shouldn't be added to empty classes", st)
}
} else if got := withPrefix.class(st); !strings.HasPrefix(got, wantPrefix) {
t.Errorf("Formatter.class(%v): %q should have a class prefix", st, got)
}
}
var styleBuf bytes.Buffer
err := withPrefix.WriteCSS(&styleBuf, styles.Fallback)
assert.NoError(t, err)
if !strings.Contains(styleBuf.String(), ".some-prefix-chroma ") {
t.Error("Stylesheets should have a class prefix")
}
}
func TestTableLineNumberNewlines(t *testing.T) {
f := New(WithClasses(true), WithLineNumbers(true), LineNumbersInTable(true))
it, err := lexers.Get("go").Tokenise(nil, "package main\nfunc main()\n{\nprintln(`hello world`)\n}\n")
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
// Don't bother testing the whole output, just verify it's got line numbers
// in a -friendly format.
// Note: placing the newlines inside the lets browser selections look
// better, instead of "skipping" over the span margin.
assert.Contains(t, buf.String(), `2
3
4
`)
}
func TestTabWidthStyle(t *testing.T) {
f := New(TabWidth(4), WithClasses(false))
it, err := lexers.Get("bash").Tokenise(nil, "echo FOO")
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
assert.True(t, regexp.MustCompile(`echo FOO`).MatchString(buf.String()))
}
func TestWithCustomCSSStyleInheritance(t *testing.T) {
f := New(WithClasses(false), WithCustomCSS(map[chroma.TokenType]string{
chroma.String: `background: blue;`,
chroma.LiteralStringDouble: `color: tomato;`,
}))
it, err := lexers.Get("bash").Tokenise(nil, `echo "FOO"`)
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
assert.True(t, regexp.MustCompile(` "FOO"`).MatchString(buf.String()))
}
func TestWrapLongLines(t *testing.T) {
f := New(WithClasses(false), WrapLongLines(true))
it, err := lexers.Get("go").Tokenise(nil, "package main\nfunc main()\n{\nprintln(\"hello world\")\n}\n")
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
assert.True(t, regexp.MustCompile(``)
}
func TestLineNumbers(t *testing.T) {
f := New(WithClasses(true), WithLineNumbers(true))
it, err := lexers.Get("bash").Tokenise(nil, "echo FOO")
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
assert.Contains(t, buf.String(), `1echo FOO`)
}
func TestPreWrapper(t *testing.T) {
f := New(Standalone(true), WithClasses(true))
it, err := lexers.Get("bash").Tokenise(nil, "echo FOO")
assert.NoError(t, err)
var buf bytes.Buffer
err = f.Format(&buf, styles.Fallback, it)
assert.NoError(t, err)
assert.True(t, regexp.MustCompile("\necho FOO\n\n