github.com/bingoohuang/gg@v0.0.0-20240325092523-45da7dee9335/pkg/gtf/gtf_test.go (about) 1 package gtf 2 3 import ( 4 "bytes" 5 "html/template" 6 "strconv" 7 "testing" 8 9 "github.com/stretchr/testify/assert" 10 ) 11 12 func TestPanicMe(t *testing.T) { 13 tpl, _ := NewTextTemplate("").Parse(`{{panic "FieldA"}}`) 14 var buf bytes.Buffer 15 tpl.Execute(&buf, map[string]string{}) 16 assert.Equal(t, "", buf.String()) 17 } 18 19 func TestSafeEq(t *testing.T) { 20 tpl, _ := NewTextTemplate("").Parse(`{{if safeEq . "FieldA" "1" "1"}}1{{end}}`) 21 var buf bytes.Buffer 22 tpl.Execute(&buf, map[string]string{"FieldA": "0"}) 23 assert.Equal(t, "", buf.String()) 24 } 25 26 func TestContains(t *testing.T) { 27 tpl, _ := NewTextTemplate("").Parse(`{{if contains . "FieldA"}}FieldA:{{.FieldA}}{{else}}NotFound{{end}}`) 28 var buf bytes.Buffer 29 tpl.Execute(&buf, map[string]string{}) 30 assert.Equal(t, "NotFound", buf.String()) 31 32 buf.Reset() 33 tpl.Execute(&buf, map[string]string{"FieldA": "Hello"}) 34 assert.Equal(t, "FieldA:Hello", buf.String()) 35 36 buf.Reset() 37 tpl.Execute(&buf, []string{"FieldA"}) 38 assert.Equal(t, "FieldA:", buf.String()) 39 40 buf.Reset() 41 tpl.Execute(&buf, [1]string{"FieldA"}) 42 assert.Equal(t, "FieldA:", buf.String()) 43 44 buf.Reset() 45 tpl.Execute(&buf, []string{"FieldB"}) 46 assert.Equal(t, "NotFound", buf.String()) 47 48 buf.Reset() 49 tpl.Execute(&buf, [1]string{"FieldB"}) 50 assert.Equal(t, "NotFound", buf.String()) 51 } 52 53 func AssertEqual(t *testing.T, buffer *bytes.Buffer, testString string) { 54 if buffer.String() != testString { 55 t.Errorf("Expected %s, got %s", testString, buffer.String()) 56 } 57 buffer.Reset() 58 } 59 60 func AssertIntInRange(t *testing.T, buffer *bytes.Buffer, min, max int) { 61 parsedInt, err := strconv.Atoi(buffer.String()) 62 if err != nil { 63 t.Error(err) 64 } 65 if parsedInt < min || parsedInt > max { 66 t.Errorf("Expected to be within the range of %d and %d, got %d", min, max, parsedInt) 67 } 68 buffer.Reset() 69 } 70 71 func ParseTest(buffer *bytes.Buffer, body string, data interface{}) { 72 tpl := NewHtmlTemplate("test") 73 tpl.Parse(body) 74 tpl.Execute(buffer, data) 75 } 76 77 func CustomParseTest(funcMap map[string]interface{}, buffer *bytes.Buffer, body string, data interface{}) { 78 tpl := template.New("test").Funcs(funcMap) 79 tpl.Parse(body) 80 tpl.Execute(buffer, data) 81 } 82 83 func TestGtfFuncMap(t *testing.T) { 84 var buffer bytes.Buffer 85 86 ParseTest(&buffer, "{{ \"The Go Programming Language\" | replace \" \" }}", "") 87 AssertEqual(t, &buffer, "TheGoProgrammingLanguage") 88 89 ParseTest(&buffer, "{{ \"The Go Programming Language\" | findreplace \" \" \"X\" }}", "") 90 AssertEqual(t, &buffer, "TheXGoXProgrammingXLanguage") 91 92 ParseTest(&buffer, "{{ \"the go programming language\" | title }}", "") 93 AssertEqual(t, &buffer, "The Go Programming Language") 94 95 ParseTest(&buffer, "{{ \"The Go Programming Language\" | default \"default value\" }}", "") 96 AssertEqual(t, &buffer, "The Go Programming Language") 97 98 ParseTest(&buffer, "{{ \"\" | default \"default value\" }}", "") 99 AssertEqual(t, &buffer, "default value") 100 101 ParseTest(&buffer, "{{ . | default \"default value\" }}", []string{"go", "python", "ruby"}) 102 AssertEqual(t, &buffer, "[go python ruby]") 103 104 ParseTest(&buffer, "{{ . | default 10 }}", []int{}) 105 AssertEqual(t, &buffer, "10") 106 107 ParseTest(&buffer, "{{ . | default \"empty\" }}", false) 108 AssertEqual(t, &buffer, "empty") 109 110 ParseTest(&buffer, "{{ . | default \"empty\" }}", 1) 111 AssertEqual(t, &buffer, "1") 112 113 ParseTest(&buffer, "{{ \"The Go Programming Language\" | length }}", "") 114 AssertEqual(t, &buffer, "27") 115 116 ParseTest(&buffer, "{{ \"안녕하세요\" | length }}", "") 117 AssertEqual(t, &buffer, "5") 118 119 ParseTest(&buffer, "{{ . | length }}", []string{"go", "python", "ruby"}) 120 AssertEqual(t, &buffer, "3") 121 122 ParseTest(&buffer, "{{ . | length }}", false) 123 AssertEqual(t, &buffer, "0") 124 125 ParseTest(&buffer, "{{ \"The Go Programming Language\" | lower }}", "") 126 AssertEqual(t, &buffer, "the go programming language") 127 128 ParseTest(&buffer, "{{ \"The Go Programming Language\" | upper }}", "") 129 AssertEqual(t, &buffer, "THE GO PROGRAMMING LANGUAGE") 130 131 ParseTest(&buffer, "{{ \"안녕하세요. 반갑습니다.\" | truncatechars 12 }}", "") 132 AssertEqual(t, &buffer, "안녕하세요. 반갑...") 133 134 ParseTest(&buffer, "{{ \"The Go Programming Language\" | truncatechars 12 }}", "") 135 AssertEqual(t, &buffer, "The Go Pr...") 136 137 ParseTest(&buffer, "{{ \"안녕하세요. The Go Programming Language\" | truncatechars 30 }}", "") 138 AssertEqual(t, &buffer, "안녕하세요. The Go Programming L...") 139 140 ParseTest(&buffer, "{{ \"The\" | truncatechars 30 }}", "") 141 AssertEqual(t, &buffer, "The") 142 143 ParseTest(&buffer, "{{ \"The Go Programming Language\" | truncatechars 3 }}", "") 144 AssertEqual(t, &buffer, "The") 145 146 ParseTest(&buffer, "{{ \"The Go\" | truncatechars 6 }}", "") 147 AssertEqual(t, &buffer, "The Go") 148 149 ParseTest(&buffer, "{{ \"The Go\" | truncatechars 30 }}", "") 150 AssertEqual(t, &buffer, "The Go") 151 152 ParseTest(&buffer, "{{ \"The Go\" | truncatechars 0 }}", "") 153 AssertEqual(t, &buffer, "") 154 155 ParseTest(&buffer, "{{ \"The Go\" | truncatechars -1 }}", "") 156 AssertEqual(t, &buffer, "The Go") 157 158 ParseTest(&buffer, "{{ \"http://www.example.org/foo?a=b&c=d\" | urlencode }}", "") 159 AssertEqual(t, &buffer, "http%3A%2F%2Fwww.example.org%2Ffoo%3Fa%3Db%26c%3Dd") 160 161 ParseTest(&buffer, "{{ \"The Go Programming Language\" | wordcount }}", "") 162 AssertEqual(t, &buffer, "4") 163 164 ParseTest(&buffer, "{{ \" The Go Programming Language \" | wordcount }}", "") 165 AssertEqual(t, &buffer, "4") 166 167 ParseTest(&buffer, "{{ 21 | divisibleby 3 }}", "") 168 AssertEqual(t, &buffer, "true") 169 170 ParseTest(&buffer, "{{ 21 | divisibleby 4 }}", "") 171 AssertEqual(t, &buffer, "false") 172 173 ParseTest(&buffer, "{{ 3.0 | divisibleby 3 }}", "") 174 AssertEqual(t, &buffer, "true") 175 176 ParseTest(&buffer, "{{ 3.0 | divisibleby 1.5 }}", "") 177 AssertEqual(t, &buffer, "true") 178 179 ParseTest(&buffer, "{{ . | divisibleby 1.5 }}", uint(300)) 180 AssertEqual(t, &buffer, "true") 181 182 ParseTest(&buffer, "{{ 12 | divisibleby . }}", uint(3)) 183 AssertEqual(t, &buffer, "true") 184 185 ParseTest(&buffer, "{{ 21 | divisibleby 4 }}", "") 186 AssertEqual(t, &buffer, "false") 187 188 ParseTest(&buffer, "{{ false | divisibleby 3 }}", "") 189 AssertEqual(t, &buffer, "false") 190 191 ParseTest(&buffer, "{{ 3 | divisibleby false }}", "") 192 AssertEqual(t, &buffer, "false") 193 194 ParseTest(&buffer, "{{ \"Go\" | lengthis 2 }}", "") 195 AssertEqual(t, &buffer, "true") 196 197 ParseTest(&buffer, "{{ \"안녕하세요.\" | lengthis 6 }}", "") 198 AssertEqual(t, &buffer, "true") 199 200 ParseTest(&buffer, "{{ \"안녕하세요. Go!\" | lengthis 10 }}", "") 201 AssertEqual(t, &buffer, "true") 202 203 ParseTest(&buffer, "{{ . | lengthis 3 }}", []string{"go", "python", "ruby"}) 204 AssertEqual(t, &buffer, "true") 205 206 ParseTest(&buffer, "{{ . | lengthis 3 }}", false) 207 AssertEqual(t, &buffer, "false") 208 209 ParseTest(&buffer, "{{ \" The Go Programming Language \" | trim }}", "") 210 AssertEqual(t, &buffer, "The Go Programming Language") 211 212 ParseTest(&buffer, "{{ \"the go programming language\" | capfirst }}", "") 213 AssertEqual(t, &buffer, "The go programming language") 214 215 ParseTest(&buffer, "You have 0 message{{ 0 | pluralize \"s\" }}", "") 216 AssertEqual(t, &buffer, "You have 0 messages") 217 218 ParseTest(&buffer, "You have 1 message{{ 1 | pluralize \"s\" }}", "") 219 AssertEqual(t, &buffer, "You have 1 message") 220 221 ParseTest(&buffer, "0 cand{{ 0 | pluralize \"y,ies\" }}", "") 222 AssertEqual(t, &buffer, "0 candies") 223 224 ParseTest(&buffer, "1 cand{{ 1 | pluralize \"y,ies\" }}", "") 225 AssertEqual(t, &buffer, "1 candy") 226 227 ParseTest(&buffer, "2 cand{{ 2 | pluralize \"y,ies\" }}", "") 228 AssertEqual(t, &buffer, "2 candies") 229 230 ParseTest(&buffer, "{{ 2 | pluralize \"y,ies,s\" }}", "") 231 AssertEqual(t, &buffer, "") 232 233 ParseTest(&buffer, "2 cand{{ . | pluralize \"y,ies\" }}", uint(2)) 234 AssertEqual(t, &buffer, "2 candies") 235 236 ParseTest(&buffer, "1 cand{{ . | pluralize \"y,ies\" }}", uint(1)) 237 AssertEqual(t, &buffer, "1 candy") 238 239 ParseTest(&buffer, "{{ . | pluralize \"y,ies\" }}", "test") 240 AssertEqual(t, &buffer, "") 241 242 ParseTest(&buffer, "{{ true | yesno \"yes~\" \"no~\" }}", "") 243 AssertEqual(t, &buffer, "yes~") 244 245 ParseTest(&buffer, "{{ false | yesno \"yes~\" \"no~\" }}", "") 246 AssertEqual(t, &buffer, "no~") 247 248 ParseTest(&buffer, "{{ \"Go\" | rjust 10 }}", "") 249 AssertEqual(t, &buffer, " Go") 250 251 ParseTest(&buffer, "{{ \"안녕하세요\" | rjust 10 }}", "") 252 AssertEqual(t, &buffer, " 안녕하세요") 253 254 ParseTest(&buffer, "{{ \"Go\" | ljust 10 }}", "") 255 AssertEqual(t, &buffer, "Go ") 256 257 ParseTest(&buffer, "{{ \"안녕하세요\" | ljust 10 }}", "") 258 AssertEqual(t, &buffer, "안녕하세요 ") 259 260 ParseTest(&buffer, "{{ \"Go\" | center 10 }}", "") 261 AssertEqual(t, &buffer, " Go ") 262 263 ParseTest(&buffer, "{{ \"안녕하세요\" | center 10 }}", "") 264 AssertEqual(t, &buffer, " 안녕하세요 ") 265 266 ParseTest(&buffer, "{{ 123456789 | filesizeformat }}", "") 267 AssertEqual(t, &buffer, "117.7 MB") 268 269 ParseTest(&buffer, "{{ 234 | filesizeformat }}", "") 270 AssertEqual(t, &buffer, "234 bytes") 271 272 ParseTest(&buffer, "{{ 12345 | filesizeformat }}", "") 273 AssertEqual(t, &buffer, "12.1 KB") 274 275 ParseTest(&buffer, "{{ 554832114 | filesizeformat }}", "") 276 AssertEqual(t, &buffer, "529.1 MB") 277 278 ParseTest(&buffer, "{{ 1048576 | filesizeformat }}", "") 279 AssertEqual(t, &buffer, "1 MB") 280 281 ParseTest(&buffer, "{{ 14868735121 | filesizeformat }}", "") 282 AssertEqual(t, &buffer, "13.8 GB") 283 284 ParseTest(&buffer, "{{ 14868735121365 | filesizeformat }}", "") 285 AssertEqual(t, &buffer, "13.5 TB") 286 287 ParseTest(&buffer, "{{ 1486873512136523 | filesizeformat }}", "") 288 AssertEqual(t, &buffer, "1.3 PB") 289 290 ParseTest(&buffer, "{{ 12345.35335 | filesizeformat }}", "") 291 AssertEqual(t, &buffer, "12.1 KB") 292 293 ParseTest(&buffer, "{{ 4294967293 | filesizeformat }}", "") 294 AssertEqual(t, &buffer, "4 GB") 295 296 ParseTest(&buffer, "{{ \"Go\" | filesizeformat }}", "") 297 AssertEqual(t, &buffer, "") 298 299 ParseTest(&buffer, "{{ . | filesizeformat }}", uint(500)) 300 AssertEqual(t, &buffer, "500 bytes") 301 302 ParseTest(&buffer, "{{ . | apnumber }}", uint(500)) 303 AssertEqual(t, &buffer, "500") 304 305 ParseTest(&buffer, "{{ . | apnumber }}", uint(7)) 306 AssertEqual(t, &buffer, "seven") 307 308 ParseTest(&buffer, "{{ . | apnumber }}", int8(3)) 309 AssertEqual(t, &buffer, "three") 310 311 ParseTest(&buffer, "{{ 2 | apnumber }}", "") 312 AssertEqual(t, &buffer, "two") 313 314 ParseTest(&buffer, "{{ 1000 | apnumber }}", "") 315 AssertEqual(t, &buffer, "1000") 316 317 ParseTest(&buffer, "{{ 1000 | intcomma }}", "") 318 AssertEqual(t, &buffer, "1,000") 319 320 ParseTest(&buffer, "{{ -1000 | intcomma }}", "") 321 AssertEqual(t, &buffer, "-1,000") 322 323 ParseTest(&buffer, "{{ 1578652313 | intcomma }}", "") 324 AssertEqual(t, &buffer, "1,578,652,313") 325 326 ParseTest(&buffer, "{{ . | intcomma }}", uint64(12315358198)) 327 AssertEqual(t, &buffer, "12,315,358,198") 328 329 ParseTest(&buffer, "{{ . | intcomma }}", 25.352) 330 AssertEqual(t, &buffer, "") 331 332 ParseTest(&buffer, "{{ 1 | ordinal }}", "") 333 AssertEqual(t, &buffer, "1st") 334 335 ParseTest(&buffer, "{{ 2 | ordinal }}", "") 336 AssertEqual(t, &buffer, "2nd") 337 338 ParseTest(&buffer, "{{ 3 | ordinal }}", "") 339 AssertEqual(t, &buffer, "3rd") 340 341 ParseTest(&buffer, "{{ 11 | ordinal }}", "") 342 AssertEqual(t, &buffer, "11th") 343 344 ParseTest(&buffer, "{{ 12 | ordinal }}", "") 345 AssertEqual(t, &buffer, "12th") 346 347 ParseTest(&buffer, "{{ 13 | ordinal }}", "") 348 AssertEqual(t, &buffer, "13th") 349 350 ParseTest(&buffer, "{{ 14 | ordinal }}", "") 351 AssertEqual(t, &buffer, "14th") 352 353 ParseTest(&buffer, "{{ -1 | ordinal }}", "") 354 AssertEqual(t, &buffer, "") 355 356 ParseTest(&buffer, "{{ . | ordinal }}", uint(14)) 357 AssertEqual(t, &buffer, "14th") 358 359 ParseTest(&buffer, "{{ . | ordinal }}", false) 360 AssertEqual(t, &buffer, "") 361 362 ParseTest(&buffer, "{{ . | first }}", "The go programming language") 363 AssertEqual(t, &buffer, "T") 364 365 ParseTest(&buffer, "{{ . | first }}", "안녕하세요") 366 AssertEqual(t, &buffer, "안") 367 368 ParseTest(&buffer, "{{ . | first }}", []string{"go", "python", "ruby"}) 369 AssertEqual(t, &buffer, "go") 370 371 ParseTest(&buffer, "{{ . | first }}", [3]string{"go", "python", "ruby"}) 372 AssertEqual(t, &buffer, "go") 373 374 ParseTest(&buffer, "{{ . | first }}", false) 375 AssertEqual(t, &buffer, "") 376 377 ParseTest(&buffer, "{{ . | last }}", "The go programming language") 378 AssertEqual(t, &buffer, "e") 379 380 ParseTest(&buffer, "{{ . | last }}", "안녕하세요") 381 AssertEqual(t, &buffer, "요") 382 383 ParseTest(&buffer, "{{ . | last }}", []string{"go", "python", "ruby"}) 384 AssertEqual(t, &buffer, "ruby") 385 386 ParseTest(&buffer, "{{ . | last }}", false) 387 AssertEqual(t, &buffer, "") 388 389 ParseTest(&buffer, "{{ . | join \" \" }}", []string{"go", "python", "ruby"}) 390 AssertEqual(t, &buffer, "go python ruby") 391 392 ParseTest(&buffer, "{{ . | slice 0 2 }}", []string{"go", "python", "ruby"}) 393 AssertEqual(t, &buffer, "[go python]") 394 395 ParseTest(&buffer, "{{ . | slice 0 6 }}", "The go programming language") 396 AssertEqual(t, &buffer, "The go") 397 398 ParseTest(&buffer, "{{ . | slice 0 2 }}", "안녕하세요") 399 AssertEqual(t, &buffer, "안녕") 400 401 ParseTest(&buffer, "{{ . | slice -10 10 }}", "안녕하세요") 402 AssertEqual(t, &buffer, "안녕하세요") 403 404 ParseTest(&buffer, "{{ . | slice 0 2 }}", false) 405 AssertEqual(t, &buffer, "") 406 407 ParseTest(&buffer, "{{ . | random }}", "T") 408 AssertEqual(t, &buffer, "T") 409 410 ParseTest(&buffer, "{{ . | random }}", "안") 411 AssertEqual(t, &buffer, "안") 412 413 ParseTest(&buffer, "{{ . | random }}", []string{"go"}) 414 AssertEqual(t, &buffer, "go") 415 416 ParseTest(&buffer, "{{ . | random }}", [1]string{"go"}) 417 AssertEqual(t, &buffer, "go") 418 419 ParseTest(&buffer, "{{ . | randomintrange 1 5 }}", false) 420 AssertIntInRange(t, &buffer, 1, 5) 421 422 ParseTest(&buffer, "{{ . | random }}", false) 423 AssertEqual(t, &buffer, "") 424 425 ParseTest(&buffer, "{{ . | striptags }}", "<strong>text</strong>") 426 AssertEqual(t, &buffer, "text") 427 428 ParseTest(&buffer, "{{ . | striptags }}", "<strong><em>안녕하세요</em></strong>") 429 AssertEqual(t, &buffer, "안녕하세요") 430 431 ParseTest(&buffer, "{{ . | striptags }}", "<a href=\"http://example.com/\">text <strong>안녕하세요</strong></a>") 432 AssertEqual(t, &buffer, "text 안녕하세요") 433 } 434 435 func TestInject(t *testing.T) { 436 var buffer bytes.Buffer 437 438 originalFuncMap := template.FuncMap{ 439 // originalFuncMap is made for test purpose. 440 // It tests that Inject function does not overwrite the original functions 441 // which have same names. 442 "length": func(value interface{}) int { 443 return -1 444 }, 445 "lower": func(s string) string { 446 return "foo" 447 }, 448 } 449 450 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 451 AssertEqual(t, &buffer, "-1") 452 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 453 AssertEqual(t, &buffer, "foo") 454 455 Inject(originalFuncMap, false, "") // Inject! 456 457 // Check if Inject function does not overwrite the original functions which have same names. 458 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 459 AssertEqual(t, &buffer, "-1") 460 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 461 AssertEqual(t, &buffer, "foo") 462 463 // Now, I can use gtf functions because they are injected into originalFuncMap. 464 CustomParseTest(originalFuncMap, &buffer, "{{ . | first }}", []string{"go", "python", "ruby"}) 465 AssertEqual(t, &buffer, "go") 466 CustomParseTest(originalFuncMap, &buffer, "{{ . | slice 0 6 }}", "The go programming language") 467 AssertEqual(t, &buffer, "The go") 468 CustomParseTest(originalFuncMap, &buffer, "{{ 13 | ordinal }}", "") 469 AssertEqual(t, &buffer, "13th") 470 } 471 472 func TestForceInject(t *testing.T) { 473 var buffer bytes.Buffer 474 475 originalFuncMap := template.FuncMap{ 476 "length": func(value interface{}) int { 477 return -1 478 }, 479 "lower": func(s string) string { 480 return "foo" 481 }, 482 } 483 484 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 485 AssertEqual(t, &buffer, "-1") 486 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 487 AssertEqual(t, &buffer, "foo") 488 489 Inject(originalFuncMap, true, "") // ForceInject! 490 491 // Check if ForceInject function overwrites the original functions which have same names. 492 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 493 AssertEqual(t, &buffer, "27") 494 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 495 AssertEqual(t, &buffer, "the go programming language") 496 497 // Now, I can use gtf functions because they are injected into originalFuncMap. 498 CustomParseTest(originalFuncMap, &buffer, "{{ . | first }}", []string{"go", "python", "ruby"}) 499 AssertEqual(t, &buffer, "go") 500 CustomParseTest(originalFuncMap, &buffer, "{{ . | slice 0 6 }}", "The go programming language") 501 AssertEqual(t, &buffer, "The go") 502 CustomParseTest(originalFuncMap, &buffer, "{{ 13 | ordinal }}", "") 503 AssertEqual(t, &buffer, "13th") 504 } 505 506 func TestInjectWithPrefix(t *testing.T) { 507 var buffer bytes.Buffer 508 509 originalFuncMap := template.FuncMap{ 510 "length": func(value interface{}) int { 511 return -1 512 }, 513 "lower": func(s string) string { 514 return "foo" 515 }, 516 } 517 518 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 519 AssertEqual(t, &buffer, "-1") 520 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 521 AssertEqual(t, &buffer, "foo") 522 523 Inject(originalFuncMap, false, "gtf_") // InjectWithPrefix! (prefix : gtf_) 524 525 // Check if Inject function does not overwrite the original functions which have same names. 526 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | length }}", "") 527 AssertEqual(t, &buffer, "-1") 528 CustomParseTest(originalFuncMap, &buffer, "{{ \"The Go Programming Language\" | lower }}", "") 529 AssertEqual(t, &buffer, "foo") 530 531 // Now, I can use gtf functions because they are injected into originalFuncMap. 532 CustomParseTest(originalFuncMap, &buffer, "{{ . | gtf_first }}", []string{"go", "python", "ruby"}) 533 AssertEqual(t, &buffer, "go") 534 CustomParseTest(originalFuncMap, &buffer, "{{ . | gtf_slice 0 6 }}", "The go programming language") 535 AssertEqual(t, &buffer, "The go") 536 CustomParseTest(originalFuncMap, &buffer, "{{ 13 | gtf_ordinal }}", "") 537 AssertEqual(t, &buffer, "13th") 538 }