mirror of
https://github.com/gohugoio/hugo.git
synced 2025-08-05 20:29:48 -04:00
264 lines
7.2 KiB
Go
264 lines
7.2 KiB
Go
// Copyright 2019 The Hugo Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package pageparser
|
|
|
|
import (
|
|
"testing"
|
|
|
|
qt "github.com/frankban/quicktest"
|
|
)
|
|
|
|
func TestItemValTyped(t *testing.T) {
|
|
c := qt.New(t)
|
|
|
|
source := []byte("3.14")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, float64(3.14))
|
|
source = []byte(".14")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, float64(0.14))
|
|
source = []byte("314")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, 314)
|
|
source = []byte("314")
|
|
c.Assert(Item{low: 0, high: len(source), isString: true}.ValTyped(source), qt.Equals, "314")
|
|
source = []byte("314x")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "314x")
|
|
source = []byte("314 ")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "314 ")
|
|
source = []byte("true")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, true)
|
|
source = []byte("false")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, false)
|
|
source = []byte("falsex")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "falsex")
|
|
source = []byte("xfalse")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "xfalse")
|
|
source = []byte("truex")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "truex")
|
|
source = []byte("xtrue")
|
|
c.Assert(Item{low: 0, high: len(source)}.ValTyped(source), qt.Equals, "xtrue")
|
|
}
|
|
|
|
func TestItemBoolMethods(t *testing.T) {
|
|
c := qt.New(t)
|
|
|
|
source := []byte(" shortcode ")
|
|
tests := []struct {
|
|
name string
|
|
item Item
|
|
source []byte
|
|
want bool
|
|
call func(Item, []byte) bool
|
|
}{
|
|
{
|
|
name: "IsText true",
|
|
item: Item{Type: tText},
|
|
call: func(i Item, _ []byte) bool { return i.IsText() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsIndentation false",
|
|
item: Item{Type: tText},
|
|
call: func(i Item, _ []byte) bool { return i.IsIndentation() },
|
|
want: false,
|
|
},
|
|
{
|
|
name: "IsShortcodeName",
|
|
item: Item{Type: tScName},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeName() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsNonWhitespace true",
|
|
item: Item{
|
|
Type: tText,
|
|
low: 2,
|
|
high: 11,
|
|
},
|
|
source: source,
|
|
call: func(i Item, src []byte) bool { return i.IsNonWhitespace(src) },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsShortcodeParam false",
|
|
item: Item{Type: tScParamVal},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeParam() },
|
|
want: false,
|
|
},
|
|
{
|
|
name: "IsInlineShortcodeName",
|
|
item: Item{Type: tScNameInline},
|
|
call: func(i Item, _ []byte) bool { return i.IsInlineShortcodeName() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsLeftShortcodeDelim tLeftDelimScWithMarkup",
|
|
item: Item{Type: tLeftDelimScWithMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsLeftShortcodeDelim() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsLeftShortcodeDelim tLeftDelimScNoMarkup",
|
|
item: Item{Type: tLeftDelimScNoMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsLeftShortcodeDelim() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsRightShortcodeDelim tRightDelimScWithMarkup",
|
|
item: Item{Type: tRightDelimScWithMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsRightShortcodeDelim() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsRightShortcodeDelim tRightDelimScNoMarkup",
|
|
item: Item{Type: tRightDelimScNoMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsRightShortcodeDelim() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsShortcodeClose",
|
|
item: Item{Type: tScClose},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeClose() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsShortcodeParamVal",
|
|
item: Item{Type: tScParamVal},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeParamVal() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsShortcodeMarkupDelimiter tLeftDelimScWithMarkup",
|
|
item: Item{Type: tLeftDelimScWithMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeMarkupDelimiter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsShortcodeMarkupDelimiter tRightDelimScWithMarkup",
|
|
item: Item{Type: tRightDelimScWithMarkup},
|
|
call: func(i Item, _ []byte) bool { return i.IsShortcodeMarkupDelimiter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsFrontMatter TypeFrontMatterYAML",
|
|
item: Item{Type: TypeFrontMatterYAML},
|
|
call: func(i Item, _ []byte) bool { return i.IsFrontMatter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsFrontMatter TypeFrontMatterTOML",
|
|
item: Item{Type: TypeFrontMatterTOML},
|
|
call: func(i Item, _ []byte) bool { return i.IsFrontMatter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsFrontMatter TypeFrontMatterJSON",
|
|
item: Item{Type: TypeFrontMatterJSON},
|
|
call: func(i Item, _ []byte) bool { return i.IsFrontMatter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsFrontMatter TypeFrontMatterORG",
|
|
item: Item{Type: TypeFrontMatterORG},
|
|
call: func(i Item, _ []byte) bool { return i.IsFrontMatter() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsDone tError",
|
|
item: Item{Type: tError},
|
|
call: func(i Item, _ []byte) bool { return i.IsDone() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsDone tEOF",
|
|
item: Item{Type: tEOF},
|
|
call: func(i Item, _ []byte) bool { return i.IsDone() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsEOF",
|
|
item: Item{Type: tEOF},
|
|
call: func(i Item, _ []byte) bool { return i.IsEOF() },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "IsError",
|
|
item: Item{Type: tError},
|
|
call: func(i Item, _ []byte) bool { return i.IsError() },
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := tt.call(tt.item, tt.source)
|
|
c.Assert(got, qt.Equals, tt.want)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestItem_ToString(t *testing.T) {
|
|
c := qt.New(t)
|
|
|
|
source := []byte("src")
|
|
long := make([]byte, 100)
|
|
for i := range long {
|
|
long[i] = byte(i)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
item Item
|
|
source []byte
|
|
want string
|
|
call func(Item, []byte) string
|
|
}{
|
|
{
|
|
name: "EOF",
|
|
item: Item{Type: tEOF},
|
|
call: func(i Item, _ []byte) string { return i.ToString(source) },
|
|
want: "EOF",
|
|
},
|
|
{
|
|
name: "Error",
|
|
item: Item{Type: tError},
|
|
call: func(i Item, _ []byte) string { return i.ToString(source) },
|
|
want: "",
|
|
},
|
|
{
|
|
name: "Indentation",
|
|
item: Item{Type: tIndentation},
|
|
call: func(i Item, _ []byte) string { return i.ToString(source) },
|
|
want: "tIndentation:[]",
|
|
},
|
|
{
|
|
name: "Long",
|
|
item: Item{Type: tKeywordMarker + 1, low: 0, high: 100},
|
|
call: func(i Item, _ []byte) string { return i.ToString(long) },
|
|
want: "<" + string(long) + ">",
|
|
},
|
|
{
|
|
name: "Empty",
|
|
item: Item{Type: tKeywordMarker + 1},
|
|
call: func(i Item, _ []byte) string { return i.ToString([]byte("")) },
|
|
want: "<>",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := tt.call(tt.item, tt.source)
|
|
c.Assert(got, qt.Equals, tt.want)
|
|
})
|
|
}
|
|
}
|