pax_global_header 0000666 0000000 0000000 00000000064 15206753664 0014530 g ustar 00root root 0000000 0000000 52 comment=60aeed6ac0becb64e7c8e5c09049dd36ef35e387
golang-github-ysmood-gop-0.4.1/ 0000775 0000000 0000000 00000000000 15206753664 0016354 5 ustar 00root root 0000000 0000000 golang-github-ysmood-gop-0.4.1/.cspell.json 0000664 0000000 0000000 00000000134 15206753664 0020605 0 ustar 00root root 0000000 0000000 {
"words": [
"tmpl",
"tput",
"Unsets",
"ysmood"
]
}
golang-github-ysmood-gop-0.4.1/.github/ 0000775 0000000 0000000 00000000000 15206753664 0017714 5 ustar 00root root 0000000 0000000 golang-github-ysmood-gop-0.4.1/.github/workflows/ 0000775 0000000 0000000 00000000000 15206753664 0021751 5 ustar 00root root 0000000 0000000 golang-github-ysmood-gop-0.4.1/.github/workflows/test.yml 0000664 0000000 0000000 00000000707 15206753664 0023457 0 ustar 00root root 0000000 0000000 name: Test
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/setup-go@v2
with:
go-version: 1.18
- uses: actions/checkout@v2
- name: lint
run: go run github.com/ysmood/golangci-lint@latest
- name: test
env:
TERM: xterm-256color
run: |
go test -race -coverprofile=coverage.out ./...
go run github.com/ysmood/got/cmd/check-cov@latest
golang-github-ysmood-gop-0.4.1/.gitignore 0000664 0000000 0000000 00000000031 15206753664 0020336 0 ustar 00root root 0000000 0000000 *.out
*.test
tmp/
.claude golang-github-ysmood-gop-0.4.1/.golangci.yml 0000664 0000000 0000000 00000000315 15206753664 0020737 0 ustar 00root root 0000000 0000000 run:
skip-dirs-use-default: false
linters:
enable:
- gofmt
- gocyclo
- misspell
- bodyclose
disable:
- govet
gocyclo:
min-complexity: 15
issues:
exclude-use-default: false
golang-github-ysmood-gop-0.4.1/LICENSE 0000664 0000000 0000000 00000002052 15206753664 0017360 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2023 Yad Smood
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
golang-github-ysmood-gop-0.4.1/README.md 0000664 0000000 0000000 00000003473 15206753664 0017642 0 ustar 00root root 0000000 0000000 # Go Pretty Print Value
Make a random Go value human readable. The output format uses valid golang syntax, so you don't have to learn any new knowledge to understand the output.
## Features
- Uses valid golang syntax to print the data
- Make rune, []byte, time, etc. data human readable
- Color output with customizable theme
- Stable map output with sorted by keys
- Auto split multiline large string block
- Prints the path of circular reference
- Auto format inline json string
- Low-level API to extend the lib
## Usage
Usually, you only need to use `gop.P` function:
```go
package main
import (
"time"
"github.com/ysmood/got/lib/gop"
)
func main() {
val := map[string]interface{}{
"bool": true,
"number": 1 + 1i,
"bytes": []byte{97, 98, 99},
"lines": "multiline string\nline two",
"slice": []interface{}{1, 2},
"time": time.Now(),
"chan": make(chan int, 1),
"struct": struct{ test int32 }{
test: 13,
},
"json": `{"a" : 1}`,
"func": func(int) int { return 0 },
}
val["slice"].([]interface{})[1] = val["slice"]
_ = gop.P(val)
}
```
The output will be something like:
```go
// 2023-10-07T18:19:57.517309+08:00 example/main.go:27 (main.main)
map[string]interface {}{
"bool": true,
"bytes": []byte("abc"),
"chan": make(chan int, 1)/* 0x1400008c070 */,
"func": (func(int) int)(nil)/* 0x1025a5460 */,
"json": gop.JSONStr(map[string]interface {}{
"a": 1.0,
}, `{"a" : 1}`),
"lines": `multiline string
line two`,
"number": 1+1i,
"slice": []interface {}{
1,
gop.Circular("slice").([]interface {}),
},
"struct": struct { test int32 }{
test: int32(13),
},
"time": gop.Time("2023-10-07T18:19:57.516984+08:00", 3081584),
}
```
golang-github-ysmood-gop-0.4.1/bench_test.go 0000664 0000000 0000000 00000003665 15206753664 0021033 0 ustar 00root root 0000000 0000000 package gop_test
import (
"testing"
"time"
"unsafe"
"github.com/ysmood/gop"
)
func benchValue() interface{} {
ref := "test"
timeStamp, _ := time.Parse(time.RFC3339Nano, "2021-08-28T08:36:36.807908+08:00")
fn := func(string) int { return 10 }
ch1 := make(chan int)
ch2 := make(chan string, 3)
ch3 := make(chan struct{})
return []interface{}{
nil,
[]int{},
[]interface{}{true, false, uintptr(0x17), float32(100.121111133)},
true, 10, int8(2), int32(100),
float64(100.121111133),
complex64(1 + 2i), complex128(1 + 2i),
[3]int{1, 2},
ch1,
ch2,
ch3,
fn,
map[interface{}]interface{}{
`"test"`: 10,
"a": 1,
&ref: 1,
},
unsafe.Pointer(&ref),
struct {
Int int
str string
M map[int]int
}{10, "ok", map[int]int{1: 0x20}},
[]byte("aa\xe2"),
[]byte("bytes\n\tbytes"),
[]byte("long long long long string"),
byte('a'),
byte(1),
'天',
"long long long long string",
"\ntest",
"\t\n`",
&ref,
(*struct{ Int int })(nil),
&struct{ Int int }{},
&map[int]int{1: 2, 3: 4},
&[]int{1, 2},
&[2]int{1, 2},
&[]byte{1, 2},
timeStamp,
time.Hour,
`{"a": 1}`,
[]byte(`{"a": 1}`),
}
}
func BenchmarkTokenize(b *testing.B) {
v := benchValue()
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = gop.Tokenize(v)
}
}
func BenchmarkFormatDefault(b *testing.B) {
v := benchValue()
ts := gop.Tokenize(v)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = gop.Format(ts, gop.ThemeDefault)
}
}
func BenchmarkFormatNone(b *testing.B) {
v := benchValue()
ts := gop.Tokenize(v)
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = gop.Format(ts, gop.ThemeNone)
}
}
func BenchmarkF(b *testing.B) {
v := benchValue()
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = gop.F(v)
}
}
func BenchmarkPlain(b *testing.B) {
v := benchValue()
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = gop.Plain(v)
}
}
golang-github-ysmood-gop-0.4.1/convertors.go 0000664 0000000 0000000 00000003247 15206753664 0021115 0 ustar 00root root 0000000 0000000 package gop
import (
"encoding/base64"
"fmt"
"reflect"
"time"
)
// SymbolPtr for Ptr
const SymbolPtr = "gop.Ptr"
// Ptr returns a pointer to v
func Ptr(v interface{}) interface{} {
val := reflect.ValueOf(v)
ptr := reflect.New(val.Type())
ptr.Elem().Set(val)
return ptr.Interface()
}
// SymbolCircular for Circular
const SymbolCircular = "gop.Circular"
// Circular reference of the path from the root
func Circular(path ...interface{}) interface{} {
return nil
}
// SymbolBase64 for Base64
const SymbolBase64 = "gop.Base64"
// Base64 returns the []byte that s represents
func Base64(s string) []byte {
b, _ := base64.StdEncoding.DecodeString(s)
return b
}
// SymbolRune for Rune
const SymbolRune = "gop.Rune"
func Rune(i int32, r rune) rune {
return r
}
// SymbolTime for Time
const SymbolTime = "gop.Time"
// Time from parsing s
func Time(s string, monotonic int) time.Time {
t, _ := time.Parse(time.RFC3339Nano, s)
return t
}
// SymbolDuration for Duration
const SymbolDuration = "gop.Duration"
// Duration from parsing s
func Duration(s string) time.Duration {
d, _ := time.ParseDuration(s)
return d
}
// SymbolJSONStr for JSONStr
const SymbolJSONStr = "gop.JSONStr"
// JSONStr returns the raw
func JSONStr(v interface{}, raw string) string {
return raw
}
// SymbolJSONBytes for JSONBytes
const SymbolJSONBytes = "gop.JSONBytes"
// JSONBytes returns the raw as []byte
func JSONBytes(v interface{}, raw string) []byte {
return []byte(raw)
}
const SymbolGopError = "gop.GopError"
// GopError returns an error with the given message, it represents an error occurred during tokenization or formatting.
func GopError(msg string) error {
return fmt.Errorf("%s", msg)
}
golang-github-ysmood-gop-0.4.1/example/ 0000775 0000000 0000000 00000000000 15206753664 0020007 5 ustar 00root root 0000000 0000000 golang-github-ysmood-gop-0.4.1/example/main.go 0000664 0000000 0000000 00000000777 15206753664 0021275 0 ustar 00root root 0000000 0000000 // Package main ...
package main
import (
"time"
"github.com/ysmood/gop"
)
func main() {
val := map[string]interface{}{
"bool": true,
"number": 1 + 1i,
"bytes": []byte{97, 98, 99},
"lines": "multiline string\nline two",
"slice": []interface{}{1, 2},
"time": time.Now(),
"chan": make(chan int, 1),
"struct": struct{ test int32 }{
test: 13,
},
"json": `{"a" : 1}`,
"func": func(int) int { return 0 },
}
val["slice"].([]interface{})[1] = val["slice"]
_ = gop.P(val)
}
golang-github-ysmood-gop-0.4.1/fixtures/ 0000775 0000000 0000000 00000000000 15206753664 0020225 5 ustar 00root root 0000000 0000000 golang-github-ysmood-gop-0.4.1/fixtures/compile_check.go.tmpl 0000664 0000000 0000000 00000000125 15206753664 0024312 0 ustar 00root root 0000000 0000000 package main
import (
"unsafe"
"github.com/ysmood/gop"
)
func main() {
_ = %s
} golang-github-ysmood-gop-0.4.1/fixtures/expected.tmpl 0000664 0000000 0000000 00000003015 15206753664 0022723 0 ustar 00root root 0000000 0000000 []interface {}{
nil,
[]int{},
[]interface {}{
true,
false,
uintptr(23),
float32(100.12111),
},
true,
10,
int8(2),
gop.Rune(100, 'd'),
100.121111133,
complex64(1+2i),
1+2i,
[3]int{
1,
2,
0,
},
make(chan int)/* {{.ch1}} */,
make(chan string, 3)/* {{.ch2}} */,
make(chan struct {})/* {{.ch3}} */,
(func(string) int)(nil)/* {{.fn}} */,
map[interface {}]interface {}{
`"test"`: 10,
"a": 1,
(interface {})(nil)/* {{.ref}} */: 1,
},
unsafe.Pointer(uintptr({{.ptr}})),
struct { Int int; str string; M map[int]int }{
Int: 10,
str: "ok",
M: map[int]int{
1: 32,
},
},
gop.Base64("YWHi"),
[]byte(`bytes
bytes`),
[]byte("long long long long string"),
byte('a'),
byte(0x1),
gop.Rune(22825, '天'),
"long long long long string",
`
test`,
"" +
" \n" +
"`",
gop.Ptr("test").(*string),
(*struct { Int int })(nil),
&struct { Int int }{
Int: 0,
},
&map[int]int{
1: 2,
3: 4,
},
&[]int{
1,
2,
},
&[2]int{
1,
2,
},
gop.Ptr([]byte("\x01\x02")).(*[]uint8),
gop.Time("2021-08-28T08:36:36.807908+08:00", 63765707796),
gop.Duration("1h0m0s"),
gop.JSONStr(map[string]interface {}{
"a": 1.0,
}, `{"a": 1}`),
gop.JSONBytes(map[string]interface {}{
"a": 1.0,
}, `{"a": 1}`),
} golang-github-ysmood-gop-0.4.1/fixtures/expected_with_color.tmpl 0000664 0000000 0000000 00000004655 15206753664 0025167 0 ustar 00root root 0000000 0000000 <36>[]interface {}<39>{
<31>nil<39>,
<36>[]int<39>{},
<36>[]interface {}<39>{
<34>true<39>,
<34>false<39>,
<36>uintptr<39>(<32>23<39>),
<36>float32<39>(<32>100.12111<39>),
},
<34>true<39>,
<32>10<39>,
<36>int8<39>(<32>2<39>),
<36>gop.Rune<39>(<32>100<39>, <33>'d'<39>),
<32>100.121111133<39>,
<36>complex64<39>(<32>1+2i<39>),
<32>1+2i<39>,
<36>[3]int<39>{
<32>1<39>,
<32>2<39>,
<32>0<39>,
},
<35>make<39>(<34>chan<39> <36>int<39>)<37>/* {{.ch1}} */<39>,
<35>make<39>(<34>chan<39> <36>string<39>, <32>3<39>)<37>/* {{.ch2}} */<39>,
<35>make<39>(<34>chan<39> <36>struct {}<39>)<37>/* {{.ch3}} */<39>,
(<36>func(string) int<39>)(<31>nil<39>)<37>/* {{.fn}} */<39>,
<36>map[interface {}]interface {}<39>{
<33>`"test"`<39>: <32>10<39>,
<33>"a"<39>: <32>1<39>,
(<36>interface {}<39>)(<31>nil<39>)<37>/* {{.ref}} */<39>: <32>1<39>,
},
<36>unsafe.Pointer<39>(<36>uintptr<39>(<32>{{.ptr}}<39>)),
<36>struct { Int int; str string; M map[int]int }<39>{
Int: <32>10<39>,
str: <33>"ok"<39>,
M: <36>map[int]int<39>{
<32>1<39>: <32>32<39>,
},
},
<35>gop.Base64<39>(<33>"YWHi"<39>),
<36>[]byte<39>(<33>`bytes<39>
<33> bytes`<39>),
<36>[]byte<39>(<33>"long long long long string"<39>),
<36>byte<39>(<33>'a'<39>),
<36>byte<39>(<33>0x1<39>),
<36>gop.Rune<39>(<32>22825<39>, <33>'天'<39>),
<33>"long long long long string"<39>,
<33>`<39>
<33>test`<39>,
<33>"" +<39>
<33> " \n" +<39>
<33> "`"<39>,
<35>gop.Ptr<39>(<33>"test"<39>).(<36>*string<39>),
(<36>*struct { Int int }<39>)(<31>nil<39>),
&<36>struct { Int int }<39>{
Int: <32>0<39>,
},
&<36>map[int]int<39>{
<32>1<39>: <32>2<39>,
<32>3<39>: <32>4<39>,
},
&<36>[]int<39>{
<32>1<39>,
<32>2<39>,
},
&<36>[2]int<39>{
<32>1<39>,
<32>2<39>,
},
<35>gop.Ptr<39>(<36>[]byte<39>(<33>"\x01\x02"<39>)).(<36>*[]uint8<39>),
<35>gop.Time<39>(<33>"2021-08-28T08:36:36.807908+08:00"<39>, <32>63765707796<39>),
<36>gop.Duration<39>(<33>"1h0m0s"<39>),
<35>gop.JSONStr<39>(<36>map[string]interface {}<39>{
<33>"a"<39>: <32>1.0<39>,
}, <33>`{"a": 1}`<39>),
<35>gop.JSONBytes<39>(<36>map[string]interface {}<39>{
<33>"a"<39>: <32>1.0<39>,
}, <33>`{"a": 1}`<39>),
} golang-github-ysmood-gop-0.4.1/format.go 0000664 0000000 0000000 00000013314 15206753664 0020175 0 ustar 00root root 0000000 0000000 // Package gop ...
package gop
import (
"fmt"
"io"
"os"
"path/filepath"
"runtime"
"strings"
"time"
)
// Stdout is the default stdout for gop.P .
var Stdout io.Writer = os.Stdout
const indentUnit = " "
// Theme to color values
type Theme func(t Type) []Style
// ThemeDefault colors for Sprint
var ThemeDefault = func(t Type) []Style {
switch t {
case TypeName:
return []Style{Cyan}
case Bool, Chan:
return []Style{Blue}
case RuneInt32, Byte, String:
return []Style{Yellow}
case Number:
return []Style{Green}
case Func:
return []Style{Magenta}
case Comment:
return []Style{White}
case Nil:
return []Style{Red}
case Error:
return []Style{Underline, Red}
default:
return []Style{None}
}
}
// ThemeNone colors for Sprint
var ThemeNone = func(t Type) []Style {
return []Style{None}
}
// F is a shortcut for Format with color
func F(v interface{}) string {
return Format(Tokenize(v), ThemeDefault)
}
// P pretty print the values
func P(values ...interface{}) error {
list := []interface{}{}
for _, v := range values {
list = append(list, F(v))
}
pc, file, line, _ := runtime.Caller(1)
fn := runtime.FuncForPC(pc).Name()
cwd, _ := os.Getwd()
file, _ = filepath.Rel(cwd, file)
tpl := Stylize("// %s %s:%d (%s)\n", ThemeDefault(Comment))
_, _ = fmt.Fprintf(Stdout, tpl, time.Now().Format(time.RFC3339Nano), file, line, fn)
_, err := fmt.Fprintln(Stdout, list...)
return err
}
// Plain is a shortcut for Format with plain color
func Plain(v interface{}) string {
return Format(Tokenize(v), ThemeNone)
}
// indentCache holds pre-repeated indent strings to avoid calling
// strings.Repeat for every indented line.
var indentCache = func() []string {
out := make([]string, 33)
for i := range out {
out[i] = strings.Repeat(indentUnit, i)
}
return out
}()
func writeIndent(sb *strings.Builder, depth int) {
if depth < len(indentCache) {
sb.WriteString(indentCache[depth])
return
}
for i := 0; i < depth; i++ {
sb.WriteString(indentUnit)
}
}
// Format a list of tokens.
func Format(ts []Token, theme Theme) string {
var out strings.Builder
depth := 0
for i, t := range ts {
tt := t.Type()
if oneOf(tt, SliceOpen, MapOpen, StructOpen) {
depth++
}
if i < len(ts)-1 && oneOf(ts[i+1].Type(), SliceClose, MapClose, StructClose) {
depth--
}
styles := theme(tt)
switch tt {
case SliceOpen, MapOpen, StructOpen:
buildStyled(&out, t, styles)
out.WriteByte('\n')
case SliceItem, MapKey, StructKey:
writeIndent(&out, depth)
case Colon, InlineComma, Chan:
buildStyled(&out, t, styles)
out.WriteByte(' ')
case Comma:
buildStyled(&out, t, styles)
out.WriteByte('\n')
case SliceClose, MapClose, StructClose:
s := out.String()
if strings.HasSuffix(s, "{\n") {
out.Reset()
out.WriteString(s[:len(s)-1])
buildStyled(&out, t, styles)
} else {
writeIndent(&out, depth)
buildStyled(&out, t, styles)
}
case String:
writeReadableString(&out, t, depth, styles)
default:
buildStyled(&out, t, styles)
}
}
return out.String()
}
// buildStyled renders t into sb, applying styles when any are active.
// Non-Lit tokens always produce single-line output, so we can emit the
// escape sequences around t.Build directly and skip the temp builder.
func buildStyled(sb *strings.Builder, t Token, styles []Style) {
if NoStyle || !hasActiveStyle(styles) {
t.Build(sb)
return
}
if l, ok := t.(*Lit); ok {
Render(sb, l.L, styles)
return
}
for i := len(styles) - 1; i >= 0; i-- {
if styles[i] != None {
sb.WriteString(styles[i].Set)
}
}
t.Build(sb)
for _, s := range styles {
if s != None {
sb.WriteString(s.Unset)
}
}
}
// writeReadableString handles the String-type token path: it materializes
// the raw literal, reshapes it via readableStr, then stylizes the result.
func writeReadableString(sb *strings.Builder, t Token, depth int, styles []Style) {
var raw string
if l, ok := t.(*Lit); ok {
raw = l.L
} else {
var inner strings.Builder
t.Build(&inner)
raw = inner.String()
}
s := readableStr(depth, raw)
if NoStyle || !hasActiveStyle(styles) {
sb.WriteString(s)
return
}
Render(sb, s, styles)
}
func oneOf(t Type, list ...Type) bool {
for _, el := range list {
if t == el {
return true
}
}
return false
}
// To make multi-line string block more human readable.
// Split newline into two strings, convert "\t" into tab.
// Such as format string: "line one \n\t line two" into:
//
// "line one \n" +
// " line two"
func readableStr(depth int, s string) string {
if (strings.Contains(s, "\n") || strings.Contains(s, `"`)) && !strings.Contains(s, "`") {
return "`" + s + "`"
}
s = fmt.Sprintf("%#v", s)
s, _ = replaceEscaped(s, 't', " ")
indent := strings.Repeat(indentUnit, depth+1)
if n, has := replaceEscaped(s, 'n', "\\n\" +\n"+indent+"\""); has {
return "\"\" +\n" + indent + n
}
return s
}
// We use a simple state machine to replace escaped char like "\n"
func replaceEscaped(s string, escaped rune, new string) (string, bool) {
type State int
const (
init State = iota
preMatch
match
)
state := init
var out strings.Builder
var buf strings.Builder
has := false
onInit := func(r rune) {
state = init
out.WriteString(buf.String())
out.WriteRune(r)
buf.Reset()
}
onPreMatch := func() {
state = preMatch
buf.Reset()
buf.WriteString("\\")
}
onEscape := func() {
state = match
out.WriteString(new)
buf.Reset()
has = true
}
for _, r := range s {
switch state {
case preMatch:
switch r {
case escaped:
onEscape()
default:
onInit(r)
}
case match:
switch r {
case '\\':
onPreMatch()
default:
onInit(r)
}
default:
switch r {
case '\\':
onPreMatch()
default:
onInit(r)
}
}
}
return out.String(), has
}
golang-github-ysmood-gop-0.4.1/format_test.go 0000664 0000000 0000000 00000040057 15206753664 0021240 0 ustar 00root root 0000000 0000000 package gop_test
import (
"bytes"
"crypto/rand"
"encoding/base64"
"encoding/hex"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"reflect"
"strings"
"testing"
"text/template"
"time"
"unsafe"
"github.com/ysmood/gop"
)
func eq(t *testing.T, a, b interface{}) {
t.Helper()
if a == b {
return
}
t.Log(a, "[should equal]", b)
t.Fail()
}
// RandStr generates a random string with the specified length
func randStr(l int) string {
b := make([]byte, (l+1)/2)
_, _ = rand.Read(b)
return hex.EncodeToString(b)[:l]
}
func render(value string, data interface{}) string {
out := bytes.NewBuffer(nil)
t := template.New("")
t, err := t.Parse(value)
if err != nil {
panic(err)
}
err = t.Execute(out, data)
if err != nil {
panic(err)
}
return out.String()
}
func assertPanic(t *testing.T, fn func()) (val interface{}) {
t.Helper()
defer func() {
t.Helper()
val = recover()
if val == nil {
t.Error("should panic")
}
}()
fn()
return
}
func TestStyle(t *testing.T) {
s := gop.Style{Set: "", Unset: ""}
eq(t, gop.S("test", s), "test")
eq(t, gop.S("", s), "