stringy/stringy_test.go

418 lines
11 KiB
Go

package stringy
import (
"testing"
)
var sm StringManipulation = New("This is example.")
func TestInput_Acronym(t *testing.T) {
acronym := New("Laugh Out Loud")
val := acronym.Acronym().Get()
if val != "LOL" {
t.Errorf("Expected: %s but got: %s", "IS", val)
}
}
func TestInput_Between(t *testing.T) {
val := sm.Between("This", "example").ToUpper()
if val != "IS" {
t.Errorf("Expected: %s but got: %s", "IS", val)
}
}
func TestInput_EmptyBetween(t *testing.T) {
sm := New("This is example.")
val := sm.Between("", "").ToUpper()
if val != "THIS IS EXAMPLE." {
t.Errorf("Expected: %s but got: %s", "THIS IS EXAMPLE.", val)
}
}
func TestInput_EmptyNoMatchBetween(t *testing.T) {
sm := New("This is example.")
val := sm.Between("hello", "test").ToUpper()
if val != "THIS IS EXAMPLE." {
t.Errorf("Expected: %s but got: %s", "THIS IS EXAMPLE.", val)
}
}
func TestInput_BooleanTrue(t *testing.T) {
strs := []string{"on", "On", "yes", "YES", "1", "true"}
for _, s := range strs {
t.Run(s, func(t *testing.T) {
if val := New(s).Boolean(); !val {
t.Errorf("Expected: to be true but got: %v", val)
}
})
}
}
func TestInput_BooleanFalse(t *testing.T) {
strs := []string{"off", "Off", "no", "NO", "0", "false"}
for _, s := range strs {
t.Run(s, func(t *testing.T) {
if val := New(s).Boolean(); val {
t.Errorf("Expected: to be false but got: %v", val)
}
})
}
}
func TestInput_BooleanError(t *testing.T) {
strs := []string{"invalid", "-1", ""}
for _, s := range strs {
t.Run(s, func(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("Error expected")
}
}()
val := New(s).Boolean()
t.Errorf("Expected: to panic but got: %v", val)
})
}
}
func TestInput_CamelCase(t *testing.T) {
str := New("Camel case this_complicated__string%%")
against := "camelCaseThisComplicatedString"
if val := str.CamelCase("%", "").Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", "camelCaseThisComplicatedString", val)
}
}
func TestInput_CamelCaseNoRule(t *testing.T) {
str := New("Camel case this_complicated__string%%")
against := "camelCaseThisComplicatedString%%"
if val := str.CamelCase().Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", "camelCaseThisComplicatedString", val)
}
}
func TestInput_CamelCaseOddRuleError(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("Error expected")
}
}()
str := New("Camel case this_complicated__string%%")
against := "camelCaseThisComplicatedString%%"
if val := str.CamelCase("%").Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", "camelCaseThisComplicatedString", val)
}
}
func TestInput_PascalCaseNoRule(t *testing.T) {
str := New("pascal case this_complicated__string%%")
against := "PascalCaseThisComplicatedString%%"
if val := str.PascalCase().Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", "PascalCaseThisComplicatedString", val)
}
}
func TestInput_PascalCaseOddRuleError(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("Error expected")
}
}()
str := New("pascal case this_complicated__string%%")
against := "PascalCaseThisComplicatedString%%"
if val := str.PascalCase("%").Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", "PascalCaseThisComplicatedString", val)
}
}
func TestInput_ContainsAll(t *testing.T) {
contains := New("hello mam how are you??")
if val := contains.ContainsAll("mam", "?"); !val {
t.Errorf("Expected value to be true but got false")
}
if val := contains.ContainsAll("non existent"); val {
t.Errorf("Expected value to be false but got true")
}
}
func TestInput_Delimited(t *testing.T) {
str := New("Delimited case this_complicated__string@@")
against := "delimited.case.this.complicated.string"
if val := str.Delimited(".", "@", "").ToLower(); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_DelimitedNoDelimeter(t *testing.T) {
str := New("Delimited case this_complicated__string@@")
against := "delimited.case.this.complicated.string@@"
if val := str.Delimited("").ToLower(); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_KebabCase(t *testing.T) {
str := New("Kebab case this-complicated___string@@")
against := "Kebab-case-this-complicated-string"
if val := str.KebabCase("@", "").Get(); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_LcFirst(t *testing.T) {
tests := []struct {
name string
arg string
want string
}{
{
name: "leading uppercase",
arg: "This is an all lower",
want: "this is an all lower",
},
{
name: "empty string",
arg: "",
want: "",
},
{
name: "multi-byte leading character",
arg: "ΔΔΔ",
want: "δΔΔ",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := New(tt.arg).LcFirst(); got != tt.want {
t.Errorf("LcFirst(%v) = %v, want %v", tt.arg, got, tt.want)
}
})
}
}
func TestInput_Lines(t *testing.T) {
lines := New("fòô\r\nbàř\nyolo")
strSlic := lines.Lines()
if len(strSlic) != 3 {
t.Errorf("Length expected to be 3 but got: %d", len(strSlic))
}
if strSlic[0] != "fòô" {
t.Errorf("Expected: %s but got: %s", "fòô", strSlic[0])
}
}
func TestInput_Pad(t *testing.T) {
pad := New("Roshan")
if result := pad.Pad(10, "0", "both"); result != "00Roshan00" {
t.Errorf("Expected: %s but got: %s", "00Roshan00", result)
}
if result := pad.Pad(10, "0", "left"); result != "0000Roshan" {
t.Errorf("Expected: %s but got: %s", "0000Roshan", result)
}
if result := pad.Pad(10, "0", "right"); result != "Roshan0000" {
t.Errorf("Expected: %s but got: %s", "Roshan0000", result)
}
}
func TestInput_PadInvalidLength(t *testing.T) {
pad := New("Roshan")
if result := pad.Pad(6, "0", "both"); result != "Roshan" {
t.Errorf("Expected: %s but got: %s", "Roshan", result)
}
if result := pad.Pad(6, "0", "left"); result != "Roshan" {
t.Errorf("Expected: %s but got: %s", "Roshan", result)
}
if result := pad.Pad(6, "0", "right"); result != "Roshan" {
t.Errorf("Expected: %s but got: %s", "Roshan", result)
}
if result := pad.Pad(13, "0", "middle"); result != "Roshan" {
t.Errorf("Expected: %s but got: %s", "Roshan", result)
}
}
func TestInput_RemoveSpecialCharacter(t *testing.T) {
cleanString := New("special@#remove%%%%")
against := "specialremove"
if result := cleanString.RemoveSpecialCharacter(); result != against {
t.Errorf("Expected: %s but got: %s", against, result)
}
}
func TestInput_ReplaceFirst(t *testing.T) {
replaceFirst := New("Hello My name is Roshan and his name is Alis.")
against := "Hello My nombre is Roshan and his name is Alis."
if result := replaceFirst.ReplaceFirst("name", "nombre"); result != against {
t.Errorf("Expected: %s but got: %s", against, result)
}
}
func TestInput_ReplaceFirstEmptyInput(t *testing.T) {
replaceFirst := New("")
against := ""
if result := replaceFirst.ReplaceFirst("name", "nombre"); result != against {
t.Errorf("Expected: %s but got: %s", against, result)
}
}
func TestInput_ReplaceLast(t *testing.T) {
replaceLast := New("Hello My name is Roshan and his name is Alis.")
against := "Hello My name is Roshan and his nombre is Alis."
if result := replaceLast.ReplaceLast("name", "nombre"); result != against {
t.Errorf("Expected: %s but got: %s", against, result)
}
}
func TestInput_Reverse(t *testing.T) {
reverseString := New("roshan")
against := "nahsor"
if result := reverseString.Reverse(); result != against {
t.Errorf("Expected: %s but got: %s", against, result)
}
}
func TestInput_Shuffle(t *testing.T) {
check := "roshan"
shuffleString := New(check)
if result := shuffleString.Shuffle(); len(result) != len(check) && check == result {
t.Errorf("Shuffle string gave wrong output")
}
}
func TestInput_SnakeCase(t *testing.T) {
str := New("SnakeCase this-complicated___string@@")
against := "snake_case_this_complicated_string"
if val := str.SnakeCase("@", "").ToLower(); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_Surround(t *testing.T) {
str := New("this")
against := "__this__"
if val := str.Surround("__"); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_Tease(t *testing.T) {
str := New("This is just simple paragraph on lorem ipsum.")
against := "This is just..."
if val := str.Tease(12, "..."); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_TeaseEmpty(t *testing.T) {
str := New("This is just simple paragraph on lorem ipsum.")
against := "This is just simple paragraph on lorem ipsum."
if val := str.Tease(200, "..."); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_Title(t *testing.T) {
str := New("this is just AN eXample")
against := "This Is Just An Example"
if val := str.Title(); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_UcFirst(t *testing.T) {
tests := []struct {
name string
arg string
want string
}{
{
name: "leading lowercase",
arg: "test input",
want: "Test input",
},
{
name: "empty string",
arg: "",
want: "",
},
{
name: "multi-byte leading character",
arg: "δδδ",
want: "Δδδ",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := New(tt.arg).UcFirst(); got != tt.want {
t.Errorf("UcFirst(%v) = %v, want %v", tt.arg, got, tt.want)
}
})
}
}
func TestInput_First(t *testing.T) {
fcn := New("4111 1111 1111 1111")
against := "4111"
if first := fcn.First(4); first != against {
t.Errorf("Expected: to be %s but got: %s", against, first)
}
}
func TestInput_FirstError(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("Error expected but got none")
}
}()
fcn := New("4111 1111 1111 1111")
fcn.First(100)
}
func TestInput_LastError(t *testing.T) {
defer func() {
if err := recover(); err == nil {
t.Errorf("Error expected but got none")
}
}()
fcn := New("4111 1111 1111 1111")
fcn.Last(100)
}
func TestInput_Last(t *testing.T) {
lcn := New("4111 1111 1111 1348")
against := "1348"
if last := lcn.Last(4); last != against {
t.Errorf("Expected: to be %s but got: %s", against, last)
}
}
func TestInput_Prefix(t *testing.T) {
str := New("foobar")
against := "foobar"
if val := str.Prefix("foo"); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
str = New("foobar")
against = "foofoofoobar"
if val := str.Prefix("foofoo"); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}
func TestInput_Suffix(t *testing.T) {
str := New("foobar")
against := "foobar"
if val := str.Suffix("bar"); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
str = New("foobar")
against = "foobarbarbar"
if val := str.Suffix("barbar"); val != against {
t.Errorf("Expected: to be %s but got: %s", against, val)
}
}