mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-29 11:52:10 -05:00
347 lines
9.2 KiB
Go
347 lines
9.2 KiB
Go
// Copyright 2015 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 helpers
|
||
|
||
import (
|
||
"reflect"
|
||
"strings"
|
||
"testing"
|
||
|
||
"github.com/stretchr/testify/assert"
|
||
)
|
||
|
||
func TestGuessType(t *testing.T) {
|
||
for i, this := range []struct {
|
||
in string
|
||
expect string
|
||
}{
|
||
{"md", "markdown"},
|
||
{"markdown", "markdown"},
|
||
{"mdown", "markdown"},
|
||
{"asciidoc", "asciidoc"},
|
||
{"adoc", "asciidoc"},
|
||
{"ad", "asciidoc"},
|
||
{"rst", "rst"},
|
||
{"mmark", "mmark"},
|
||
{"html", "html"},
|
||
{"htm", "html"},
|
||
{"org", "org"},
|
||
{"excel", "unknown"},
|
||
} {
|
||
result := GuessType(this.in)
|
||
if result != this.expect {
|
||
t.Errorf("[%d] got %s but expected %s", i, result, this.expect)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestFirstUpper(t *testing.T) {
|
||
for i, this := range []struct {
|
||
in string
|
||
expect string
|
||
}{
|
||
{"foo", "Foo"},
|
||
{"foo bar", "Foo bar"},
|
||
{"Foo Bar", "Foo Bar"},
|
||
{"", ""},
|
||
{"å", "Å"},
|
||
} {
|
||
result := FirstUpper(this.in)
|
||
if result != this.expect {
|
||
t.Errorf("[%d] got %s but expected %s", i, result, this.expect)
|
||
}
|
||
}
|
||
}
|
||
|
||
var containsTestText = (`На берегу пустынных волн
|
||
Стоял он, дум великих полн,
|
||
И вдаль глядел. Пред ним широко
|
||
Река неслася; бедный чёлн
|
||
По ней стремился одиноко.
|
||
По мшистым, топким берегам
|
||
Чернели избы здесь и там,
|
||
Приют убогого чухонца;
|
||
И лес, неведомый лучам
|
||
В тумане спрятанного солнца,
|
||
Кругом шумел.
|
||
|
||
Τη γλώσσα μου έδωσαν ελληνική
|
||
το σπίτι φτωχικό στις αμμουδιές του Ομήρου.
|
||
Μονάχη έγνοια η γλώσσα μου στις αμμουδιές του Ομήρου.
|
||
|
||
από το Άξιον Εστί
|
||
του Οδυσσέα Ελύτη
|
||
|
||
Sîne klâwen durh die wolken sint geslagen,
|
||
er stîget ûf mit grôzer kraft,
|
||
ich sih in grâwen tägelîch als er wil tagen,
|
||
den tac, der im geselleschaft
|
||
erwenden wil, dem werden man,
|
||
den ich mit sorgen în verliez.
|
||
ich bringe in hinnen, ob ich kan.
|
||
sîn vil manegiu tugent michz leisten hiez.
|
||
`)
|
||
|
||
var containsBenchTestData = []struct {
|
||
v1 string
|
||
v2 []byte
|
||
expect bool
|
||
}{
|
||
{"abc", []byte("a"), true},
|
||
{"abc", []byte("b"), true},
|
||
{"abcdefg", []byte("efg"), true},
|
||
{"abc", []byte("d"), false},
|
||
{containsTestText, []byte("стремился"), true},
|
||
{containsTestText, []byte(containsTestText[10:80]), true},
|
||
{containsTestText, []byte(containsTestText[100:111]), true},
|
||
{containsTestText, []byte(containsTestText[len(containsTestText)-100 : len(containsTestText)-10]), true},
|
||
{containsTestText, []byte(containsTestText[len(containsTestText)-20:]), true},
|
||
{containsTestText, []byte("notfound"), false},
|
||
}
|
||
|
||
// some corner cases
|
||
var containsAdditionalTestData = []struct {
|
||
v1 string
|
||
v2 []byte
|
||
expect bool
|
||
}{
|
||
{"", nil, false},
|
||
{"", []byte("a"), false},
|
||
{"a", []byte(""), false},
|
||
{"", []byte(""), false},
|
||
}
|
||
|
||
func TestReaderContains(t *testing.T) {
|
||
for i, this := range append(containsBenchTestData, containsAdditionalTestData...) {
|
||
result := ReaderContains(strings.NewReader(this.v1), this.v2)
|
||
if result != this.expect {
|
||
t.Errorf("[%d] got %t but expected %t", i, result, this.expect)
|
||
}
|
||
}
|
||
|
||
assert.False(t, ReaderContains(nil, []byte("a")))
|
||
assert.False(t, ReaderContains(nil, nil))
|
||
}
|
||
|
||
func BenchmarkReaderContains(b *testing.B) {
|
||
b.ResetTimer()
|
||
for i := 0; i < b.N; i++ {
|
||
for i, this := range containsBenchTestData {
|
||
result := ReaderContains(strings.NewReader(this.v1), this.v2)
|
||
if result != this.expect {
|
||
b.Errorf("[%d] got %t but expected %t", i, result, this.expect)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestUniqueStrings(t *testing.T) {
|
||
in := []string{"a", "b", "a", "b", "c", "", "a", "", "d"}
|
||
output := UniqueStrings(in)
|
||
expected := []string{"a", "b", "c", "", "d"}
|
||
if !reflect.DeepEqual(output, expected) {
|
||
t.Errorf("Expected %#v, got %#v\n", expected, output)
|
||
}
|
||
}
|
||
|
||
func TestFindAvailablePort(t *testing.T) {
|
||
addr, err := FindAvailablePort()
|
||
assert.Nil(t, err)
|
||
assert.NotNil(t, addr)
|
||
assert.True(t, addr.Port > 0)
|
||
}
|
||
|
||
func TestSeq(t *testing.T) {
|
||
for i, this := range []struct {
|
||
in []interface{}
|
||
expect interface{}
|
||
}{
|
||
{[]interface{}{-2, 5}, []int{-2, -1, 0, 1, 2, 3, 4, 5}},
|
||
{[]interface{}{1, 2, 4}, []int{1, 3}},
|
||
{[]interface{}{1}, []int{1}},
|
||
{[]interface{}{3}, []int{1, 2, 3}},
|
||
{[]interface{}{3.2}, []int{1, 2, 3}},
|
||
{[]interface{}{0}, []int{}},
|
||
{[]interface{}{-1}, []int{-1}},
|
||
{[]interface{}{-3}, []int{-1, -2, -3}},
|
||
{[]interface{}{3, -2}, []int{3, 2, 1, 0, -1, -2}},
|
||
{[]interface{}{6, -2, 2}, []int{6, 4, 2}},
|
||
{[]interface{}{1, 0, 2}, false},
|
||
{[]interface{}{1, -1, 2}, false},
|
||
{[]interface{}{2, 1, 1}, false},
|
||
{[]interface{}{2, 1, 1, 1}, false},
|
||
{[]interface{}{2001}, false},
|
||
{[]interface{}{}, false},
|
||
// TODO(bep) {[]interface{}{t}, false},
|
||
{nil, false},
|
||
} {
|
||
|
||
result, err := Seq(this.in...)
|
||
|
||
if b, ok := this.expect.(bool); ok && !b {
|
||
if err == nil {
|
||
t.Errorf("[%d] TestSeq didn't return an expected error", i)
|
||
}
|
||
} else {
|
||
if err != nil {
|
||
t.Errorf("[%d] failed: %s", i, err)
|
||
continue
|
||
}
|
||
if !reflect.DeepEqual(result, this.expect) {
|
||
t.Errorf("[%d] TestSeq got %v but expected %v", i, result, this.expect)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestDoArithmetic(t *testing.T) {
|
||
for i, this := range []struct {
|
||
a interface{}
|
||
b interface{}
|
||
op rune
|
||
expect interface{}
|
||
}{
|
||
{3, 2, '+', int64(5)},
|
||
{3, 2, '-', int64(1)},
|
||
{3, 2, '*', int64(6)},
|
||
{3, 2, '/', int64(1)},
|
||
{3.0, 2, '+', float64(5)},
|
||
{3.0, 2, '-', float64(1)},
|
||
{3.0, 2, '*', float64(6)},
|
||
{3.0, 2, '/', float64(1.5)},
|
||
{3, 2.0, '+', float64(5)},
|
||
{3, 2.0, '-', float64(1)},
|
||
{3, 2.0, '*', float64(6)},
|
||
{3, 2.0, '/', float64(1.5)},
|
||
{3.0, 2.0, '+', float64(5)},
|
||
{3.0, 2.0, '-', float64(1)},
|
||
{3.0, 2.0, '*', float64(6)},
|
||
{3.0, 2.0, '/', float64(1.5)},
|
||
{uint(3), uint(2), '+', uint64(5)},
|
||
{uint(3), uint(2), '-', uint64(1)},
|
||
{uint(3), uint(2), '*', uint64(6)},
|
||
{uint(3), uint(2), '/', uint64(1)},
|
||
{uint(3), 2, '+', uint64(5)},
|
||
{uint(3), 2, '-', uint64(1)},
|
||
{uint(3), 2, '*', uint64(6)},
|
||
{uint(3), 2, '/', uint64(1)},
|
||
{3, uint(2), '+', uint64(5)},
|
||
{3, uint(2), '-', uint64(1)},
|
||
{3, uint(2), '*', uint64(6)},
|
||
{3, uint(2), '/', uint64(1)},
|
||
{uint(3), -2, '+', int64(1)},
|
||
{uint(3), -2, '-', int64(5)},
|
||
{uint(3), -2, '*', int64(-6)},
|
||
{uint(3), -2, '/', int64(-1)},
|
||
{-3, uint(2), '+', int64(-1)},
|
||
{-3, uint(2), '-', int64(-5)},
|
||
{-3, uint(2), '*', int64(-6)},
|
||
{-3, uint(2), '/', int64(-1)},
|
||
{uint(3), 2.0, '+', float64(5)},
|
||
{uint(3), 2.0, '-', float64(1)},
|
||
{uint(3), 2.0, '*', float64(6)},
|
||
{uint(3), 2.0, '/', float64(1.5)},
|
||
{3.0, uint(2), '+', float64(5)},
|
||
{3.0, uint(2), '-', float64(1)},
|
||
{3.0, uint(2), '*', float64(6)},
|
||
{3.0, uint(2), '/', float64(1.5)},
|
||
{0, 0, '+', 0},
|
||
{0, 0, '-', 0},
|
||
{0, 0, '*', 0},
|
||
{"foo", "bar", '+', "foobar"},
|
||
{3, 0, '/', false},
|
||
{3.0, 0, '/', false},
|
||
{3, 0.0, '/', false},
|
||
{uint(3), uint(0), '/', false},
|
||
{3, uint(0), '/', false},
|
||
{-3, uint(0), '/', false},
|
||
{uint(3), 0, '/', false},
|
||
{3.0, uint(0), '/', false},
|
||
{uint(3), 0.0, '/', false},
|
||
{3, "foo", '+', false},
|
||
{3.0, "foo", '+', false},
|
||
{uint(3), "foo", '+', false},
|
||
{"foo", 3, '+', false},
|
||
{"foo", "bar", '-', false},
|
||
{3, 2, '%', false},
|
||
} {
|
||
result, err := DoArithmetic(this.a, this.b, this.op)
|
||
if b, ok := this.expect.(bool); ok && !b {
|
||
if err == nil {
|
||
t.Errorf("[%d] doArithmetic didn't return an expected error", i)
|
||
}
|
||
} else {
|
||
if err != nil {
|
||
t.Errorf("[%d] failed: %s", i, err)
|
||
continue
|
||
}
|
||
if !reflect.DeepEqual(result, this.expect) {
|
||
t.Errorf("[%d] doArithmetic got %v but expected %v", i, result, this.expect)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestToLowerMap(t *testing.T) {
|
||
|
||
tests := []struct {
|
||
input map[string]interface{}
|
||
expected map[string]interface{}
|
||
}{
|
||
{
|
||
map[string]interface{}{
|
||
"abC": 32,
|
||
},
|
||
map[string]interface{}{
|
||
"abc": 32,
|
||
},
|
||
},
|
||
{
|
||
map[string]interface{}{
|
||
"abC": 32,
|
||
"deF": map[interface{}]interface{}{
|
||
23: "A value",
|
||
24: map[string]interface{}{
|
||
"AbCDe": "A value",
|
||
"eFgHi": "Another value",
|
||
},
|
||
},
|
||
"gHi": map[string]interface{}{
|
||
"J": 25,
|
||
},
|
||
},
|
||
map[string]interface{}{
|
||
"abc": 32,
|
||
"def": map[string]interface{}{
|
||
"23": "A value",
|
||
"24": map[string]interface{}{
|
||
"abcde": "A value",
|
||
"efghi": "Another value",
|
||
},
|
||
},
|
||
"ghi": map[string]interface{}{
|
||
"j": 25,
|
||
},
|
||
},
|
||
},
|
||
}
|
||
|
||
for i, test := range tests {
|
||
// ToLowerMap modifies input.
|
||
ToLowerMap(test.input)
|
||
if !reflect.DeepEqual(test.expected, test.input) {
|
||
t.Errorf("[%d] Expected\n%#v, got\n%#v\n", i, test.expected, test.input)
|
||
}
|
||
}
|
||
}
|