summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/pelletier/go-toml/tomltree_write_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/pelletier/go-toml/tomltree_write_test.go')
-rw-r--r--vendor/github.com/pelletier/go-toml/tomltree_write_test.go376
1 files changed, 0 insertions, 376 deletions
diff --git a/vendor/github.com/pelletier/go-toml/tomltree_write_test.go b/vendor/github.com/pelletier/go-toml/tomltree_write_test.go
deleted file mode 100644
index 206203b88..000000000
--- a/vendor/github.com/pelletier/go-toml/tomltree_write_test.go
+++ /dev/null
@@ -1,376 +0,0 @@
-package toml
-
-import (
- "bytes"
- "errors"
- "fmt"
- "reflect"
- "strings"
- "testing"
- "time"
-)
-
-type failingWriter struct {
- failAt int
- written int
- buffer bytes.Buffer
-}
-
-func (f *failingWriter) Write(p []byte) (n int, err error) {
- count := len(p)
- toWrite := f.failAt - (count + f.written)
- if toWrite < 0 {
- toWrite = 0
- }
- if toWrite > count {
- f.written += count
- f.buffer.Write(p)
- return count, nil
- }
-
- f.buffer.Write(p[:toWrite])
- f.written = f.failAt
- return toWrite, fmt.Errorf("failingWriter failed after writing %d bytes", f.written)
-}
-
-func assertErrorString(t *testing.T, expected string, err error) {
- expectedErr := errors.New(expected)
- if err == nil || err.Error() != expectedErr.Error() {
- t.Errorf("expecting error %s, but got %s instead", expected, err)
- }
-}
-
-func TestTreeWriteToEmptyTable(t *testing.T) {
- doc := `[[empty-tables]]
-[[empty-tables]]`
-
- toml, err := Load(doc)
- if err != nil {
- t.Fatal("Unexpected Load error:", err)
- }
- tomlString, err := toml.ToTomlString()
- if err != nil {
- t.Fatal("Unexpected ToTomlString error:", err)
- }
-
- expected := `
-[[empty-tables]]
-
-[[empty-tables]]
-`
-
- if tomlString != expected {
- t.Fatalf("Expected:\n%s\nGot:\n%s", expected, tomlString)
- }
-}
-
-func TestTreeWriteToTomlString(t *testing.T) {
- toml, err := Load(`name = { first = "Tom", last = "Preston-Werner" }
-points = { x = 1, y = 2 }`)
-
- if err != nil {
- t.Fatal("Unexpected error:", err)
- }
-
- tomlString, _ := toml.ToTomlString()
- reparsedTree, err := Load(tomlString)
-
- assertTree(t, reparsedTree, err, map[string]interface{}{
- "name": map[string]interface{}{
- "first": "Tom",
- "last": "Preston-Werner",
- },
- "points": map[string]interface{}{
- "x": int64(1),
- "y": int64(2),
- },
- })
-}
-
-func TestTreeWriteToTomlStringSimple(t *testing.T) {
- tree, err := Load("[foo]\n\n[[foo.bar]]\na = 42\n\n[[foo.bar]]\na = 69\n")
- if err != nil {
- t.Errorf("Test failed to parse: %v", err)
- return
- }
- result, err := tree.ToTomlString()
- if err != nil {
- t.Errorf("Unexpected error: %s", err)
- }
- expected := "\n[foo]\n\n [[foo.bar]]\n a = 42\n\n [[foo.bar]]\n a = 69\n"
- if result != expected {
- t.Errorf("Expected got '%s', expected '%s'", result, expected)
- }
-}
-
-func TestTreeWriteToTomlStringKeysOrders(t *testing.T) {
- for i := 0; i < 100; i++ {
- tree, _ := Load(`
- foobar = true
- bar = "baz"
- foo = 1
- [qux]
- foo = 1
- bar = "baz2"`)
-
- stringRepr, _ := tree.ToTomlString()
-
- t.Log("Intermediate string representation:")
- t.Log(stringRepr)
-
- r := strings.NewReader(stringRepr)
- toml, err := LoadReader(r)
-
- if err != nil {
- t.Fatal("Unexpected error:", err)
- }
-
- assertTree(t, toml, err, map[string]interface{}{
- "foobar": true,
- "bar": "baz",
- "foo": 1,
- "qux": map[string]interface{}{
- "foo": 1,
- "bar": "baz2",
- },
- })
- }
-}
-
-func testMaps(t *testing.T, actual, expected map[string]interface{}) {
- if !reflect.DeepEqual(actual, expected) {
- t.Fatal("trees aren't equal.\n", "Expected:\n", expected, "\nActual:\n", actual)
- }
-}
-
-func TestTreeWriteToMapSimple(t *testing.T) {
- tree, _ := Load("a = 42\nb = 17")
-
- expected := map[string]interface{}{
- "a": int64(42),
- "b": int64(17),
- }
-
- testMaps(t, tree.ToMap(), expected)
-}
-
-func TestTreeWriteToInvalidTreeSimpleValue(t *testing.T) {
- tree := Tree{values: map[string]interface{}{"foo": int8(1)}}
- _, err := tree.ToTomlString()
- assertErrorString(t, "invalid value type at foo: int8", err)
-}
-
-func TestTreeWriteToInvalidTreeTomlValue(t *testing.T) {
- tree := Tree{values: map[string]interface{}{"foo": &tomlValue{value: int8(1), comment: "", position: Position{}}}}
- _, err := tree.ToTomlString()
- assertErrorString(t, "unsupported value type int8: 1", err)
-}
-
-func TestTreeWriteToInvalidTreeTomlValueArray(t *testing.T) {
- tree := Tree{values: map[string]interface{}{"foo": &tomlValue{value: int8(1), comment: "", position: Position{}}}}
- _, err := tree.ToTomlString()
- assertErrorString(t, "unsupported value type int8: 1", err)
-}
-
-func TestTreeWriteToFailingWriterInSimpleValue(t *testing.T) {
- toml, _ := Load(`a = 2`)
- writer := failingWriter{failAt: 0, written: 0}
- _, err := toml.WriteTo(&writer)
- assertErrorString(t, "failingWriter failed after writing 0 bytes", err)
-}
-
-func TestTreeWriteToFailingWriterInTable(t *testing.T) {
- toml, _ := Load(`
-[b]
-a = 2`)
- writer := failingWriter{failAt: 2, written: 0}
- _, err := toml.WriteTo(&writer)
- assertErrorString(t, "failingWriter failed after writing 2 bytes", err)
-
- writer = failingWriter{failAt: 13, written: 0}
- _, err = toml.WriteTo(&writer)
- assertErrorString(t, "failingWriter failed after writing 13 bytes", err)
-}
-
-func TestTreeWriteToFailingWriterInArray(t *testing.T) {
- toml, _ := Load(`
-[[b]]
-a = 2`)
- writer := failingWriter{failAt: 2, written: 0}
- _, err := toml.WriteTo(&writer)
- assertErrorString(t, "failingWriter failed after writing 2 bytes", err)
-
- writer = failingWriter{failAt: 15, written: 0}
- _, err = toml.WriteTo(&writer)
- assertErrorString(t, "failingWriter failed after writing 15 bytes", err)
-}
-
-func TestTreeWriteToMapExampleFile(t *testing.T) {
- tree, _ := LoadFile("example.toml")
- expected := map[string]interface{}{
- "title": "TOML Example",
- "owner": map[string]interface{}{
- "name": "Tom Preston-Werner",
- "organization": "GitHub",
- "bio": "GitHub Cofounder & CEO\nLikes tater tots and beer.",
- "dob": time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC),
- },
- "database": map[string]interface{}{
- "server": "192.168.1.1",
- "ports": []interface{}{int64(8001), int64(8001), int64(8002)},
- "connection_max": int64(5000),
- "enabled": true,
- },
- "servers": map[string]interface{}{
- "alpha": map[string]interface{}{
- "ip": "10.0.0.1",
- "dc": "eqdc10",
- },
- "beta": map[string]interface{}{
- "ip": "10.0.0.2",
- "dc": "eqdc10",
- },
- },
- "clients": map[string]interface{}{
- "data": []interface{}{
- []interface{}{"gamma", "delta"},
- []interface{}{int64(1), int64(2)},
- },
- },
- }
- testMaps(t, tree.ToMap(), expected)
-}
-
-func TestTreeWriteToMapWithTablesInMultipleChunks(t *testing.T) {
- tree, _ := Load(`
- [[menu.main]]
- a = "menu 1"
- b = "menu 2"
- [[menu.main]]
- c = "menu 3"
- d = "menu 4"`)
- expected := map[string]interface{}{
- "menu": map[string]interface{}{
- "main": []interface{}{
- map[string]interface{}{"a": "menu 1", "b": "menu 2"},
- map[string]interface{}{"c": "menu 3", "d": "menu 4"},
- },
- },
- }
- treeMap := tree.ToMap()
-
- testMaps(t, treeMap, expected)
-}
-
-func TestTreeWriteToMapWithArrayOfInlineTables(t *testing.T) {
- tree, _ := Load(`
- [params]
- language_tabs = [
- { key = "shell", name = "Shell" },
- { key = "ruby", name = "Ruby" },
- { key = "python", name = "Python" }
- ]`)
-
- expected := map[string]interface{}{
- "params": map[string]interface{}{
- "language_tabs": []interface{}{
- map[string]interface{}{
- "key": "shell",
- "name": "Shell",
- },
- map[string]interface{}{
- "key": "ruby",
- "name": "Ruby",
- },
- map[string]interface{}{
- "key": "python",
- "name": "Python",
- },
- },
- },
- }
-
- treeMap := tree.ToMap()
- testMaps(t, treeMap, expected)
-}
-
-func TestTreeWriteToFloat(t *testing.T) {
- tree, err := Load(`a = 3.0`)
- if err != nil {
- t.Fatal(err)
- }
- str, err := tree.ToTomlString()
- if err != nil {
- t.Fatal(err)
- }
- expected := `a = 3.0`
- if strings.TrimSpace(str) != strings.TrimSpace(expected) {
- t.Fatalf("Expected:\n%s\nGot:\n%s", expected, str)
- }
-}
-
-func TestTreeWriteToSpecialFloat(t *testing.T) {
- expected := `a = +inf
-b = -inf
-c = nan`
-
- tree, err := Load(expected)
- if err != nil {
- t.Fatal(err)
- }
- str, err := tree.ToTomlString()
- if err != nil {
- t.Fatal(err)
- }
- if strings.TrimSpace(str) != strings.TrimSpace(expected) {
- t.Fatalf("Expected:\n%s\nGot:\n%s", expected, str)
- }
-}
-
-func BenchmarkTreeToTomlString(b *testing.B) {
- toml, err := Load(sampleHard)
- if err != nil {
- b.Fatal("Unexpected error:", err)
- }
-
- for i := 0; i < b.N; i++ {
- _, err := toml.ToTomlString()
- if err != nil {
- b.Fatal(err)
- }
- }
-}
-
-var sampleHard = `# Test file for TOML
-# Only this one tries to emulate a TOML file written by a user of the kind of parser writers probably hate
-# This part you'll really hate
-
-[the]
-test_string = "You'll hate me after this - #" # " Annoying, isn't it?
-
- [the.hard]
- test_array = [ "] ", " # "] # ] There you go, parse this!
- test_array2 = [ "Test #11 ]proved that", "Experiment #9 was a success" ]
- # You didn't think it'd as easy as chucking out the last #, did you?
- another_test_string = " Same thing, but with a string #"
- harder_test_string = " And when \"'s are in the string, along with # \"" # "and comments are there too"
- # Things will get harder
-
- [the.hard."bit#"]
- "what?" = "You don't think some user won't do that?"
- multi_line_array = [
- "]",
- # ] Oh yes I did
- ]
-
-# Each of the following keygroups/key value pairs should produce an error. Uncomment to them to test
-
-#[error] if you didn't catch this, your parser is broken
-#string = "Anything other than tabs, spaces and newline after a keygroup or key value pair has ended should produce an error unless it is a comment" like this
-#array = [
-# "This might most likely happen in multiline arrays",
-# Like here,
-# "or here,
-# and here"
-# ] End of array comment, forgot the #
-#number = 3.14 pi <--again forgot the # `
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-06-29 14:26:28 +0000