I: pbuilder: network access will be disabled during build
I: Current time: Sat Feb 14 07:10:35 +14 2026
I: pbuilder-time-stamp: 1771002635
I: Building the build Environment
I: extracting base tarball [/var/cache/pbuilder/unstable-reproducible-base.tgz]
I: copying local configuration
W: --override-config is not set; not updating apt.conf Read the manpage for details.
I: mounting /proc filesystem
I: mounting /sys filesystem
I: creating /{dev,run}/shm
I: mounting /dev/pts filesystem
I: redirecting /dev/ptmx to /dev/pts/ptmx
I: policy-rc.d already exists
I: Copying source file
I: copying [golang-github-pelletier-go-toml_1.9.5-1.dsc]
I: copying [./golang-github-pelletier-go-toml_1.9.5.orig.tar.gz]
I: copying [./golang-github-pelletier-go-toml_1.9.5-1.debian.tar.xz]
I: Extracting source
dpkg-source: warning: cannot verify inline signature for ./golang-github-pelletier-go-toml_1.9.5-1.dsc: unsupported subcommand
dpkg-source: info: extracting golang-github-pelletier-go-toml in golang-github-pelletier-go-toml-1.9.5
dpkg-source: info: unpacking golang-github-pelletier-go-toml_1.9.5.orig.tar.gz
dpkg-source: info: unpacking golang-github-pelletier-go-toml_1.9.5-1.debian.tar.xz
I: Not using root during the build.
I: Installing the build-deps
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/D01_modify_environment starting
debug: Running on codethink01-arm64.
I: Changing host+domainname to test build reproducibility
I: Adding a custom variable just for the fun of it...
I: Changing /bin/sh to bash
'/bin/sh' -> '/bin/bash'
lrwxrwxrwx 1 root root 9 Feb 13 17:10 /bin/sh -> /bin/bash
I: Setting pbuilder2's login shell to /bin/bash
I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/D01_modify_environment finished
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/D02_print_environment starting
I: set
  BASH=/bin/sh
  BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath
  BASH_ALIASES=()
  BASH_ARGC=()
  BASH_ARGV=()
  BASH_CMDS=()
  BASH_LINENO=([0]="12" [1]="0")
  BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:.
  BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment")
  BASH_VERSINFO=([0]="5" [1]="2" [2]="37" [3]="1" [4]="release" [5]="aarch64-unknown-linux-gnu")
  BASH_VERSION='5.2.37(1)-release'
  BUILDDIR=/build/reproducible-path
  BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other'
  BUILDUSERNAME=pbuilder2
  BUILD_ARCH=arm64
  DEBIAN_FRONTEND=noninteractive
  DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=12 '
  DIRSTACK=()
  DISTRIBUTION=unstable
  EUID=0
  FUNCNAME=([0]="Echo" [1]="main")
  GROUPS=()
  HOME=/root
  HOSTNAME=i-capture-the-hostname
  HOSTTYPE=aarch64
  HOST_ARCH=arm64
  IFS=' 	
  '
  INVOCATION_ID=e0c4b0d37793448ea131639696f6a40e
  LANG=C
  LANGUAGE=nl_BE:nl
  LC_ALL=C
  MACHTYPE=aarch64-unknown-linux-gnu
  MAIL=/var/mail/root
  OPTERR=1
  OPTIND=1
  OSTYPE=linux-gnu
  PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path
  PBCURRENTCOMMANDLINEOPERATION=build
  PBUILDER_OPERATION=build
  PBUILDER_PKGDATADIR=/usr/share/pbuilder
  PBUILDER_PKGLIBDIR=/usr/lib/pbuilder
  PBUILDER_SYSCONFDIR=/etc
  PIPESTATUS=([0]="0")
  POSIXLY_CORRECT=y
  PPID=3681646
  PS4='+ '
  PWD=/
  SHELL=/bin/bash
  SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix
  SHLVL=3
  SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.6ear0qo1/pbuilderrc_HwUG --distribution unstable --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.6ear0qo1/b2 --logfile b2/build.log golang-github-pelletier-go-toml_1.9.5-1.dsc'
  SUDO_GID=109
  SUDO_UID=104
  SUDO_USER=jenkins
  TERM=unknown
  TZ=/usr/share/zoneinfo/Etc/GMT-14
  UID=0
  USER=root
  _='I: set'
  http_proxy=http://192.168.101.4:3128
I: uname -a
  Linux i-capture-the-hostname 6.1.0-28-cloud-arm64 #1 SMP Debian 6.1.119-1 (2024-11-22) aarch64 GNU/Linux
I: ls -l /bin
  lrwxrwxrwx 1 root root 7 Nov 22  2024 /bin -> usr/bin
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/D02_print_environment finished
 -> Attempting to satisfy build-dependencies
 -> Creating pbuilder-satisfydepends-dummy package
Package: pbuilder-satisfydepends-dummy
Version: 0.invalid.0
Architecture: arm64
Maintainer: Debian Pbuilder Team <pbuilder-maint@lists.alioth.debian.org>
Description: Dummy package to satisfy dependencies with aptitude - created by pbuilder
 This package was created automatically by pbuilder to satisfy the
 build-dependencies of the package being currently built.
Depends: debhelper-compat (= 13), dh-sequence-golang, golang-any, golang-github-burntsushi-toml-dev (>= 0.3.1), golang-gopkg-yaml.v2-dev (>= 2.3.0)
dpkg-deb: building package 'pbuilder-satisfydepends-dummy' in '/tmp/satisfydepends-aptitude/pbuilder-satisfydepends-dummy.deb'.
Selecting previously unselected package pbuilder-satisfydepends-dummy.
(Reading database ... 19963 files and directories currently installed.)
Preparing to unpack .../pbuilder-satisfydepends-dummy.deb ...
Unpacking pbuilder-satisfydepends-dummy (0.invalid.0) ...
dpkg: pbuilder-satisfydepends-dummy: dependency problems, but configuring anyway as you requested:
 pbuilder-satisfydepends-dummy depends on debhelper-compat (= 13); however:
  Package debhelper-compat is not installed.
 pbuilder-satisfydepends-dummy depends on dh-sequence-golang; however:
  Package dh-sequence-golang is not installed.
 pbuilder-satisfydepends-dummy depends on golang-any; however:
  Package golang-any is not installed.
 pbuilder-satisfydepends-dummy depends on golang-github-burntsushi-toml-dev (>= 0.3.1); however:
  Package golang-github-burntsushi-toml-dev is not installed.
 pbuilder-satisfydepends-dummy depends on golang-gopkg-yaml.v2-dev (>= 2.3.0); however:
  Package golang-gopkg-yaml.v2-dev is not installed.

Setting up pbuilder-satisfydepends-dummy (0.invalid.0) ...
Reading package lists...
Building dependency tree...
Reading state information...
Initializing package states...
Writing extended state information...
Building tag database...
pbuilder-satisfydepends-dummy is already installed at the requested version (0.invalid.0)
pbuilder-satisfydepends-dummy is already installed at the requested version (0.invalid.0)
The following NEW packages will be installed:
  autoconf{a} automake{a} autopoint{a} autotools-dev{a} bsdextrautils{a} debhelper{a} dh-autoreconf{a} dh-golang{a} dh-strip-nondeterminism{a} dwz{a} file{a} gettext{a} gettext-base{a} golang-1.23-go{a} golang-1.23-src{a} golang-any{a} golang-github-burntsushi-toml-dev{a} golang-go{a} golang-gopkg-yaml.v2-dev{a} golang-src{a} groff-base{a} intltool-debian{a} libarchive-zip-perl{a} libdebhelper-perl{a} libelf1t64{a} libfile-stripnondeterminism-perl{a} libicu72{a} libmagic-mgc{a} libmagic1t64{a} libpipeline1{a} libtool{a} libuchardet0{a} libunistring5{a} libxml2{a} m4{a} man-db{a} po-debconf{a} sensible-utils{a} 
The following packages are RECOMMENDED but will NOT be installed:
  curl libarchive-cpio-perl libltdl-dev libmail-sendmail-perl lynx pkgconf wget 
0 packages upgraded, 38 newly installed, 0 to remove and 0 not upgraded.
Need to get 62.7 MB of archives. After unpacking 321 MB will be used.
Writing extended state information...
Get: 1 http://deb.debian.org/debian unstable/main arm64 sensible-utils all 0.0.24 [24.8 kB]
Get: 2 http://deb.debian.org/debian unstable/main arm64 libmagic-mgc arm64 1:5.45-3+b1 [314 kB]
Get: 3 http://deb.debian.org/debian unstable/main arm64 libmagic1t64 arm64 1:5.45-3+b1 [102 kB]
Get: 4 http://deb.debian.org/debian unstable/main arm64 file arm64 1:5.45-3+b1 [43.4 kB]
Get: 5 http://deb.debian.org/debian unstable/main arm64 gettext-base arm64 0.22.5-4 [198 kB]
Get: 6 http://deb.debian.org/debian unstable/main arm64 libuchardet0 arm64 0.0.8-1+b2 [69.2 kB]
Get: 7 http://deb.debian.org/debian unstable/main arm64 groff-base arm64 1.23.0-7 [1129 kB]
Get: 8 http://deb.debian.org/debian unstable/main arm64 bsdextrautils arm64 2.40.3-1 [91.5 kB]
Get: 9 http://deb.debian.org/debian unstable/main arm64 libpipeline1 arm64 1.5.8-1 [40.2 kB]
Get: 10 http://deb.debian.org/debian unstable/main arm64 man-db arm64 2.13.0-1 [1404 kB]
Get: 11 http://deb.debian.org/debian unstable/main arm64 m4 arm64 1.4.19-5 [284 kB]
Get: 12 http://deb.debian.org/debian unstable/main arm64 autoconf all 2.72-3 [493 kB]
Get: 13 http://deb.debian.org/debian unstable/main arm64 autotools-dev all 20220109.1 [51.6 kB]
Get: 14 http://deb.debian.org/debian unstable/main arm64 automake all 1:1.16.5-1.3 [823 kB]
Get: 15 http://deb.debian.org/debian unstable/main arm64 autopoint all 0.22.5-4 [723 kB]
Get: 16 http://deb.debian.org/debian unstable/main arm64 libdebhelper-perl all 13.23 [90.6 kB]
Get: 17 http://deb.debian.org/debian unstable/main arm64 libtool all 2.5.4-2 [539 kB]
Get: 18 http://deb.debian.org/debian unstable/main arm64 dh-autoreconf all 20 [17.1 kB]
Get: 19 http://deb.debian.org/debian unstable/main arm64 libarchive-zip-perl all 1.68-1 [104 kB]
Get: 20 http://deb.debian.org/debian unstable/main arm64 libfile-stripnondeterminism-perl all 1.14.0-1 [19.5 kB]
Get: 21 http://deb.debian.org/debian unstable/main arm64 dh-strip-nondeterminism all 1.14.0-1 [8448 B]
Get: 22 http://deb.debian.org/debian unstable/main arm64 libelf1t64 arm64 0.192-4 [189 kB]
Get: 23 http://deb.debian.org/debian unstable/main arm64 dwz arm64 0.15-1+b1 [102 kB]
Get: 24 http://deb.debian.org/debian unstable/main arm64 libunistring5 arm64 1.3-1 [449 kB]
Get: 25 http://deb.debian.org/debian unstable/main arm64 libicu72 arm64 72.1-6 [9239 kB]
Get: 26 http://deb.debian.org/debian unstable/main arm64 libxml2 arm64 2.12.7+dfsg+really2.9.14-0.2+b1 [630 kB]
Get: 27 http://deb.debian.org/debian unstable/main arm64 gettext arm64 0.22.5-4 [1532 kB]
Get: 28 http://deb.debian.org/debian unstable/main arm64 intltool-debian all 0.35.0+20060710.6 [22.9 kB]
Get: 29 http://deb.debian.org/debian unstable/main arm64 po-debconf all 1.0.21+nmu1 [248 kB]
Get: 30 http://deb.debian.org/debian unstable/main arm64 debhelper all 13.23 [919 kB]
Get: 31 http://deb.debian.org/debian unstable/main arm64 dh-golang all 1.62 [24.7 kB]
Get: 32 http://deb.debian.org/debian unstable/main arm64 golang-1.23-src all 1.23.4-2 [19.1 MB]
Get: 33 http://deb.debian.org/debian unstable/main arm64 golang-1.23-go arm64 1.23.4-2 [23.5 MB]
Get: 34 http://deb.debian.org/debian unstable/main arm64 golang-src all 2:1.23~2 [5088 B]
Get: 35 http://deb.debian.org/debian unstable/main arm64 golang-go arm64 2:1.23~2 [44.3 kB]
Get: 36 http://deb.debian.org/debian unstable/main arm64 golang-any arm64 2:1.23~2 [5172 B]
Get: 37 http://deb.debian.org/debian unstable/main arm64 golang-github-burntsushi-toml-dev all 1.4.0-1 [116 kB]
Get: 38 http://deb.debian.org/debian unstable/main arm64 golang-gopkg-yaml.v2-dev all 2.4.0-4 [61.5 kB]
Fetched 62.7 MB in 0s (243 MB/s)
Preconfiguring packages ...
Selecting previously unselected package sensible-utils.
(Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 19963 files and directories currently installed.)
Preparing to unpack .../00-sensible-utils_0.0.24_all.deb ...
Unpacking sensible-utils (0.0.24) ...
Selecting previously unselected package libmagic-mgc.
Preparing to unpack .../01-libmagic-mgc_1%3a5.45-3+b1_arm64.deb ...
Unpacking libmagic-mgc (1:5.45-3+b1) ...
Selecting previously unselected package libmagic1t64:arm64.
Preparing to unpack .../02-libmagic1t64_1%3a5.45-3+b1_arm64.deb ...
Unpacking libmagic1t64:arm64 (1:5.45-3+b1) ...
Selecting previously unselected package file.
Preparing to unpack .../03-file_1%3a5.45-3+b1_arm64.deb ...
Unpacking file (1:5.45-3+b1) ...
Selecting previously unselected package gettext-base.
Preparing to unpack .../04-gettext-base_0.22.5-4_arm64.deb ...
Unpacking gettext-base (0.22.5-4) ...
Selecting previously unselected package libuchardet0:arm64.
Preparing to unpack .../05-libuchardet0_0.0.8-1+b2_arm64.deb ...
Unpacking libuchardet0:arm64 (0.0.8-1+b2) ...
Selecting previously unselected package groff-base.
Preparing to unpack .../06-groff-base_1.23.0-7_arm64.deb ...
Unpacking groff-base (1.23.0-7) ...
Selecting previously unselected package bsdextrautils.
Preparing to unpack .../07-bsdextrautils_2.40.3-1_arm64.deb ...
Unpacking bsdextrautils (2.40.3-1) ...
Selecting previously unselected package libpipeline1:arm64.
Preparing to unpack .../08-libpipeline1_1.5.8-1_arm64.deb ...
Unpacking libpipeline1:arm64 (1.5.8-1) ...
Selecting previously unselected package man-db.
Preparing to unpack .../09-man-db_2.13.0-1_arm64.deb ...
Unpacking man-db (2.13.0-1) ...
Selecting previously unselected package m4.
Preparing to unpack .../10-m4_1.4.19-5_arm64.deb ...
Unpacking m4 (1.4.19-5) ...
Selecting previously unselected package autoconf.
Preparing to unpack .../11-autoconf_2.72-3_all.deb ...
Unpacking autoconf (2.72-3) ...
Selecting previously unselected package autotools-dev.
Preparing to unpack .../12-autotools-dev_20220109.1_all.deb ...
Unpacking autotools-dev (20220109.1) ...
Selecting previously unselected package automake.
Preparing to unpack .../13-automake_1%3a1.16.5-1.3_all.deb ...
Unpacking automake (1:1.16.5-1.3) ...
Selecting previously unselected package autopoint.
Preparing to unpack .../14-autopoint_0.22.5-4_all.deb ...
Unpacking autopoint (0.22.5-4) ...
Selecting previously unselected package libdebhelper-perl.
Preparing to unpack .../15-libdebhelper-perl_13.23_all.deb ...
Unpacking libdebhelper-perl (13.23) ...
Selecting previously unselected package libtool.
Preparing to unpack .../16-libtool_2.5.4-2_all.deb ...
Unpacking libtool (2.5.4-2) ...
Selecting previously unselected package dh-autoreconf.
Preparing to unpack .../17-dh-autoreconf_20_all.deb ...
Unpacking dh-autoreconf (20) ...
Selecting previously unselected package libarchive-zip-perl.
Preparing to unpack .../18-libarchive-zip-perl_1.68-1_all.deb ...
Unpacking libarchive-zip-perl (1.68-1) ...
Selecting previously unselected package libfile-stripnondeterminism-perl.
Preparing to unpack .../19-libfile-stripnondeterminism-perl_1.14.0-1_all.deb ...
Unpacking libfile-stripnondeterminism-perl (1.14.0-1) ...
Selecting previously unselected package dh-strip-nondeterminism.
Preparing to unpack .../20-dh-strip-nondeterminism_1.14.0-1_all.deb ...
Unpacking dh-strip-nondeterminism (1.14.0-1) ...
Selecting previously unselected package libelf1t64:arm64.
Preparing to unpack .../21-libelf1t64_0.192-4_arm64.deb ...
Unpacking libelf1t64:arm64 (0.192-4) ...
Selecting previously unselected package dwz.
Preparing to unpack .../22-dwz_0.15-1+b1_arm64.deb ...
Unpacking dwz (0.15-1+b1) ...
Selecting previously unselected package libunistring5:arm64.
Preparing to unpack .../23-libunistring5_1.3-1_arm64.deb ...
Unpacking libunistring5:arm64 (1.3-1) ...
Selecting previously unselected package libicu72:arm64.
Preparing to unpack .../24-libicu72_72.1-6_arm64.deb ...
Unpacking libicu72:arm64 (72.1-6) ...
Selecting previously unselected package libxml2:arm64.
Preparing to unpack .../25-libxml2_2.12.7+dfsg+really2.9.14-0.2+b1_arm64.deb ...
Unpacking libxml2:arm64 (2.12.7+dfsg+really2.9.14-0.2+b1) ...
Selecting previously unselected package gettext.
Preparing to unpack .../26-gettext_0.22.5-4_arm64.deb ...
Unpacking gettext (0.22.5-4) ...
Selecting previously unselected package intltool-debian.
Preparing to unpack .../27-intltool-debian_0.35.0+20060710.6_all.deb ...
Unpacking intltool-debian (0.35.0+20060710.6) ...
Selecting previously unselected package po-debconf.
Preparing to unpack .../28-po-debconf_1.0.21+nmu1_all.deb ...
Unpacking po-debconf (1.0.21+nmu1) ...
Selecting previously unselected package debhelper.
Preparing to unpack .../29-debhelper_13.23_all.deb ...
Unpacking debhelper (13.23) ...
Selecting previously unselected package dh-golang.
Preparing to unpack .../30-dh-golang_1.62_all.deb ...
Unpacking dh-golang (1.62) ...
Selecting previously unselected package golang-1.23-src.
Preparing to unpack .../31-golang-1.23-src_1.23.4-2_all.deb ...
Unpacking golang-1.23-src (1.23.4-2) ...
Selecting previously unselected package golang-1.23-go.
Preparing to unpack .../32-golang-1.23-go_1.23.4-2_arm64.deb ...
Unpacking golang-1.23-go (1.23.4-2) ...
Selecting previously unselected package golang-src.
Preparing to unpack .../33-golang-src_2%3a1.23~2_all.deb ...
Unpacking golang-src (2:1.23~2) ...
Selecting previously unselected package golang-go:arm64.
Preparing to unpack .../34-golang-go_2%3a1.23~2_arm64.deb ...
Unpacking golang-go:arm64 (2:1.23~2) ...
Selecting previously unselected package golang-any:arm64.
Preparing to unpack .../35-golang-any_2%3a1.23~2_arm64.deb ...
Unpacking golang-any:arm64 (2:1.23~2) ...
Selecting previously unselected package golang-github-burntsushi-toml-dev.
Preparing to unpack .../36-golang-github-burntsushi-toml-dev_1.4.0-1_all.deb ...
Unpacking golang-github-burntsushi-toml-dev (1.4.0-1) ...
Selecting previously unselected package golang-gopkg-yaml.v2-dev.
Preparing to unpack .../37-golang-gopkg-yaml.v2-dev_2.4.0-4_all.deb ...
Unpacking golang-gopkg-yaml.v2-dev (2.4.0-4) ...
Setting up libpipeline1:arm64 (1.5.8-1) ...
Setting up golang-gopkg-yaml.v2-dev (2.4.0-4) ...
Setting up libicu72:arm64 (72.1-6) ...
Setting up bsdextrautils (2.40.3-1) ...
Setting up libmagic-mgc (1:5.45-3+b1) ...
Setting up libarchive-zip-perl (1.68-1) ...
Setting up libdebhelper-perl (13.23) ...
Setting up golang-github-burntsushi-toml-dev (1.4.0-1) ...
Setting up libmagic1t64:arm64 (1:5.45-3+b1) ...
Setting up gettext-base (0.22.5-4) ...
Setting up m4 (1.4.19-5) ...
Setting up file (1:5.45-3+b1) ...
Setting up libelf1t64:arm64 (0.192-4) ...
Setting up autotools-dev (20220109.1) ...
Setting up libunistring5:arm64 (1.3-1) ...
Setting up golang-1.23-src (1.23.4-2) ...
Setting up autopoint (0.22.5-4) ...
Setting up autoconf (2.72-3) ...
Setting up dwz (0.15-1+b1) ...
Setting up sensible-utils (0.0.24) ...
Setting up libuchardet0:arm64 (0.0.8-1+b2) ...
Setting up golang-src (2:1.23~2) ...
Setting up libxml2:arm64 (2.12.7+dfsg+really2.9.14-0.2+b1) ...
Setting up automake (1:1.16.5-1.3) ...
update-alternatives: using /usr/bin/automake-1.16 to provide /usr/bin/automake (automake) in auto mode
Setting up libfile-stripnondeterminism-perl (1.14.0-1) ...
Setting up gettext (0.22.5-4) ...
Setting up libtool (2.5.4-2) ...
Setting up intltool-debian (0.35.0+20060710.6) ...
Setting up dh-autoreconf (20) ...
Setting up golang-1.23-go (1.23.4-2) ...
Setting up dh-strip-nondeterminism (1.14.0-1) ...
Setting up groff-base (1.23.0-7) ...
Setting up golang-go:arm64 (2:1.23~2) ...
Setting up po-debconf (1.0.21+nmu1) ...
Setting up man-db (2.13.0-1) ...
Not building database; man-db/auto-update is not 'true'.
Setting up golang-any:arm64 (2:1.23~2) ...
Setting up debhelper (13.23) ...
Setting up dh-golang (1.62) ...
Processing triggers for libc-bin (2.40-5) ...
Reading package lists...
Building dependency tree...
Reading state information...
Reading extended state information...
Initializing package states...
Writing extended state information...
Building tag database...
 -> Finished parsing the build-deps
I: Building the package
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/A99_set_merged_usr starting
Not re-configuring usrmerge for unstable
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/A99_set_merged_usr finished
hostname: Name or service not known
I: Running cd /build/reproducible-path/golang-github-pelletier-go-toml-1.9.5/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S  > ../golang-github-pelletier-go-toml_1.9.5-1_source.changes
dpkg-buildpackage: info: source package golang-github-pelletier-go-toml
dpkg-buildpackage: info: source version 1.9.5-1
dpkg-buildpackage: info: source distribution unstable
dpkg-buildpackage: info: source changed by Anthony Fok <foka@debian.org>
 dpkg-source --before-build .
dpkg-buildpackage: info: host architecture arm64
 debian/rules clean
dh clean --buildsystem=golang
   dh_auto_clean -O--buildsystem=golang
   dh_autoreconf_clean -O--buildsystem=golang
   dh_clean -O--buildsystem=golang
 debian/rules binary
dh binary --buildsystem=golang
   dh_update_autotools_config -O--buildsystem=golang
   dh_autoreconf -O--buildsystem=golang
   dh_auto_configure -O--buildsystem=golang
   dh_auto_build -O--buildsystem=golang
dh_auto_build: warning: github.com/pelletier/go-toml/benchmark contains no non-test Go files, removing it from build
	cd obj-aarch64-linux-gnu && go install -trimpath -v -p 12 github.com/pelletier/go-toml github.com/pelletier/go-toml/cmd/jsontoml github.com/pelletier/go-toml/cmd/tomljson github.com/pelletier/go-toml/cmd/tomll github.com/pelletier/go-toml/query
internal/coverage/rtcov
internal/goarch
internal/byteorder
internal/goos
internal/godebugs
internal/unsafeheader
internal/profilerecord
sync/atomic
internal/goexperiment
internal/runtime/syscall
unicode
internal/race
internal/cpu
runtime/internal/math
internal/abi
internal/chacha8rand
runtime/internal/sys
unicode/utf8
encoding
cmp
internal/itoa
math/bits
internal/asan
internal/msan
unicode/utf16
math
internal/runtime/atomic
internal/bytealg
internal/stringslite
internal/runtime/exithook
runtime
internal/reflectlite
iter
sync
slices
internal/bisect
internal/testlog
errors
sort
io
internal/oserror
strconv
path
syscall
internal/godebug
math/rand
bytes
strings
reflect
internal/syscall/execenv
internal/syscall/unix
time
io/fs
internal/poll
internal/filepathlite
os
internal/fmtsort
encoding/binary
encoding/base64
io/ioutil
fmt
flag
encoding/json
math/big
github.com/pelletier/go-toml
github.com/pelletier/go-toml/cmd/jsontoml
github.com/pelletier/go-toml/cmd/tomljson
github.com/pelletier/go-toml/cmd/tomll
github.com/pelletier/go-toml/query
   dh_auto_test -O--buildsystem=golang
	cd obj-aarch64-linux-gnu && go test -vet=off -v -p 12 github.com/pelletier/go-toml github.com/pelletier/go-toml/benchmark github.com/pelletier/go-toml/cmd/jsontoml github.com/pelletier/go-toml/cmd/tomljson github.com/pelletier/go-toml/cmd/tomll github.com/pelletier/go-toml/query
?   	github.com/pelletier/go-toml/cmd/tomll	[no test files]
=== RUN   TestBareKeyBasic
    keysparsing_test.go:10: key=test expected=[test] parsed=[test]
--- PASS: TestBareKeyBasic (0.00s)
=== RUN   TestBareKeyDotted
    keysparsing_test.go:10: key=this.is.a.key expected=[this is a key] parsed=[this is a key]
--- PASS: TestBareKeyDotted (0.00s)
=== RUN   TestDottedKeyBasic
    keysparsing_test.go:10: key="a.dotted.key" expected=[a.dotted.key] parsed=[a.dotted.key]
--- PASS: TestDottedKeyBasic (0.00s)
=== RUN   TestBaseKeyPound
--- PASS: TestBaseKeyPound (0.00s)
=== RUN   TestUnclosedSingleQuotedKey
--- PASS: TestUnclosedSingleQuotedKey (0.00s)
=== RUN   TestUnclosedDoubleQuotedKey
--- PASS: TestUnclosedDoubleQuotedKey (0.00s)
=== RUN   TestInvalidStartKeyCharacter
--- PASS: TestInvalidStartKeyCharacter (0.00s)
=== RUN   TestInvalidSpaceInKey
--- PASS: TestInvalidSpaceInKey (0.00s)
=== RUN   TestQuotedKeys
    keysparsing_test.go:10: key=hello."foo".bar expected=[hello foo bar] parsed=[hello foo bar]
    keysparsing_test.go:10: key="hello!" expected=[hello!] parsed=[hello!]
    keysparsing_test.go:10: key=foo."ba.r".baz expected=[foo ba.r baz] parsed=[foo ba.r baz]
    keysparsing_test.go:10: key="hello\tworld" expected=[hello\tworld] parsed=[hello\tworld]
--- PASS: TestQuotedKeys (0.00s)
=== RUN   TestEmptyKey
    keysparsing_test.go:10: key="" expected=[] parsed=[]
--- PASS: TestEmptyKey (0.00s)
=== RUN   TestValidKeyGroup
--- PASS: TestValidKeyGroup (0.00s)
=== RUN   TestNestedQuotedUnicodeKeyGroup
--- PASS: TestNestedQuotedUnicodeKeyGroup (0.00s)
=== RUN   TestNestedQuotedUnicodeKeyAssign
--- PASS: TestNestedQuotedUnicodeKeyAssign (0.00s)
=== RUN   TestUnclosedKeyGroup
--- PASS: TestUnclosedKeyGroup (0.00s)
=== RUN   TestComment
--- PASS: TestComment (0.00s)
=== RUN   TestKeyGroupComment
--- PASS: TestKeyGroupComment (0.00s)
=== RUN   TestMultipleKeyGroupsComment
--- PASS: TestMultipleKeyGroupsComment (0.00s)
=== RUN   TestSimpleWindowsCRLF
--- PASS: TestSimpleWindowsCRLF (0.00s)
=== RUN   TestBasicKey
--- PASS: TestBasicKey (0.00s)
=== RUN   TestBasicKeyWithUnderscore
--- PASS: TestBasicKeyWithUnderscore (0.00s)
=== RUN   TestBasicKeyWithDash
--- PASS: TestBasicKeyWithDash (0.00s)
=== RUN   TestBasicKeyWithUppercaseMix
--- PASS: TestBasicKeyWithUppercaseMix (0.00s)
=== RUN   TestBasicKeyWithInternationalCharacters
--- PASS: TestBasicKeyWithInternationalCharacters (0.00s)
=== RUN   TestBasicKeyAndEqual
--- PASS: TestBasicKeyAndEqual (0.00s)
=== RUN   TestKeyWithSharpAndEqual
--- PASS: TestKeyWithSharpAndEqual (0.00s)
=== RUN   TestKeyWithSymbolsAndEqual
--- PASS: TestKeyWithSymbolsAndEqual (0.00s)
=== RUN   TestKeyEqualStringEscape
--- PASS: TestKeyEqualStringEscape (0.00s)
=== RUN   TestKeyEqualStringUnfinished
--- PASS: TestKeyEqualStringUnfinished (0.00s)
=== RUN   TestKeyEqualString
--- PASS: TestKeyEqualString (0.00s)
=== RUN   TestKeyEqualTrue
--- PASS: TestKeyEqualTrue (0.00s)
=== RUN   TestKeyEqualFalse
--- PASS: TestKeyEqualFalse (0.00s)
=== RUN   TestArrayNestedString
--- PASS: TestArrayNestedString (0.00s)
=== RUN   TestArrayNestedInts
--- PASS: TestArrayNestedInts (0.00s)
=== RUN   TestArrayInts
--- PASS: TestArrayInts (0.00s)
=== RUN   TestMultilineArrayComments
--- PASS: TestMultilineArrayComments (0.00s)
=== RUN   TestNestedArraysComment
--- PASS: TestNestedArraysComment (0.00s)
=== RUN   TestKeyEqualArrayBools
--- PASS: TestKeyEqualArrayBools (0.00s)
=== RUN   TestKeyEqualArrayBoolsWithComments
--- PASS: TestKeyEqualArrayBoolsWithComments (0.00s)
=== RUN   TestKeyEqualDate
=== RUN   TestKeyEqualDate/local_date_time
=== RUN   TestKeyEqualDate/local_date_time_space
=== RUN   TestKeyEqualDate/local_date_time_fraction
=== RUN   TestKeyEqualDate/local_date_time_fraction_space
=== RUN   TestKeyEqualDate/offset_date-time_utc
=== RUN   TestKeyEqualDate/offset_date-time_-07:00
=== RUN   TestKeyEqualDate/offset_date-time_fractions_-07:00
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_utc
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_offset
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_fraction_offset
=== RUN   TestKeyEqualDate/local_date
=== RUN   TestKeyEqualDate/local_time
=== RUN   TestKeyEqualDate/local_time_fraction
=== RUN   TestKeyEqualDate/local_time_invalid_minute_digit
=== RUN   TestKeyEqualDate/local_time_invalid_minute/second_digit
=== RUN   TestKeyEqualDate/local_time_invalid_second_digit
=== RUN   TestKeyEqualDate/local_time_invalid_second_digit#01
=== RUN   TestKeyEqualDate/local_date-time_invalid_minute_digit
=== RUN   TestKeyEqualDate/local_date-time_invalid_hour_digit
=== RUN   TestKeyEqualDate/local_date-time_invalid_hour_digit#01
=== RUN   TestKeyEqualDate/local_date-time_invalid_minute/second_digit
=== RUN   TestKeyEqualDate/local_date-time_invalid_second_digit
=== RUN   TestKeyEqualDate/local_date-time_invalid_fraction
=== RUN   TestKeyEqualDate/local_date-time_invalid_month-date_separator
=== RUN   TestKeyEqualDate/local_date-time_extra_whitespace
=== RUN   TestKeyEqualDate/local_date-time_extra_whitespace#01
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_offset#01
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_offset#02
=== RUN   TestKeyEqualDate/offset_date-time_space_separated_offset#03
--- PASS: TestKeyEqualDate (0.00s)
    --- PASS: TestKeyEqualDate/local_date_time (0.00s)
    --- PASS: TestKeyEqualDate/local_date_time_space (0.00s)
    --- PASS: TestKeyEqualDate/local_date_time_fraction (0.00s)
    --- PASS: TestKeyEqualDate/local_date_time_fraction_space (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_utc (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_-07:00 (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_fractions_-07:00 (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_utc (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_offset (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_fraction_offset (0.00s)
    --- PASS: TestKeyEqualDate/local_date (0.00s)
    --- PASS: TestKeyEqualDate/local_time (0.00s)
    --- PASS: TestKeyEqualDate/local_time_fraction (0.00s)
    --- PASS: TestKeyEqualDate/local_time_invalid_minute_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_time_invalid_minute/second_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_time_invalid_second_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_time_invalid_second_digit#01 (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_minute_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_hour_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_hour_digit#01 (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_minute/second_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_second_digit (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_fraction (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_invalid_month-date_separator (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_extra_whitespace (0.00s)
    --- PASS: TestKeyEqualDate/local_date-time_extra_whitespace#01 (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_offset#01 (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_offset#02 (0.00s)
    --- PASS: TestKeyEqualDate/offset_date-time_space_separated_offset#03 (0.00s)
=== RUN   TestFloatEndingWithDot
--- PASS: TestFloatEndingWithDot (0.00s)
=== RUN   TestFloatWithTwoDots
--- PASS: TestFloatWithTwoDots (0.00s)
=== RUN   TestFloatWithExponent1
--- PASS: TestFloatWithExponent1 (0.00s)
=== RUN   TestFloatWithExponent2
--- PASS: TestFloatWithExponent2 (0.00s)
=== RUN   TestFloatWithExponent3
--- PASS: TestFloatWithExponent3 (0.00s)
=== RUN   TestFloatWithExponent4
--- PASS: TestFloatWithExponent4 (0.00s)
=== RUN   TestFloatWithExponent5
--- PASS: TestFloatWithExponent5 (0.00s)
=== RUN   TestInvalidEsquapeSequence
--- PASS: TestInvalidEsquapeSequence (0.00s)
=== RUN   TestNestedArrays
--- PASS: TestNestedArrays (0.00s)
=== RUN   TestKeyEqualNumber
--- PASS: TestKeyEqualNumber (0.00s)
=== RUN   TestMultiline
--- PASS: TestMultiline (0.00s)
=== RUN   TestKeyEqualStringUnicodeEscape
--- PASS: TestKeyEqualStringUnicodeEscape (0.00s)
=== RUN   TestKeyEqualStringNoEscape
--- PASS: TestKeyEqualStringNoEscape (0.00s)
=== RUN   TestLiteralString
--- PASS: TestLiteralString (0.00s)
=== RUN   TestMultilineLiteralString
--- PASS: TestMultilineLiteralString (0.00s)
=== RUN   TestMultilineString
--- PASS: TestMultilineString (0.00s)
=== RUN   TestUnicodeString
--- PASS: TestUnicodeString (0.00s)
=== RUN   TestEscapeInString
--- PASS: TestEscapeInString (0.00s)
=== RUN   TestTabInString
--- PASS: TestTabInString (0.00s)
=== RUN   TestKeyGroupArray
--- PASS: TestKeyGroupArray (0.00s)
=== RUN   TestQuotedKey
--- PASS: TestQuotedKey (0.00s)
=== RUN   TestQuotedKeyTab
--- PASS: TestQuotedKeyTab (0.00s)
=== RUN   TestKeyNewline
--- PASS: TestKeyNewline (0.00s)
=== RUN   TestInvalidFloat
--- PASS: TestInvalidFloat (0.00s)
=== RUN   TestLexUnknownRvalue
--- PASS: TestLexUnknownRvalue (0.00s)
=== RUN   TestLexInlineTableEmpty
--- PASS: TestLexInlineTableEmpty (0.00s)
=== RUN   TestLexInlineTableBareKey
--- PASS: TestLexInlineTableBareKey (0.00s)
=== RUN   TestLexInlineTableBareKeyDash
--- PASS: TestLexInlineTableBareKeyDash (0.00s)
=== RUN   TestLexInlineTableBareKeyInArray
--- PASS: TestLexInlineTableBareKeyInArray (0.00s)
=== RUN   TestLexInlineTableError1
--- PASS: TestLexInlineTableError1 (0.00s)
=== RUN   TestLexInlineTableError2
--- PASS: TestLexInlineTableError2 (0.00s)
=== RUN   TestLexInlineTableDottedKey1
--- PASS: TestLexInlineTableDottedKey1 (0.00s)
=== RUN   TestLexInlineTableDottedKey2
--- PASS: TestLexInlineTableDottedKey2 (0.00s)
=== RUN   TestLexInlineTableDottedKey3
--- PASS: TestLexInlineTableDottedKey3 (0.00s)
=== RUN   TestLexInlineTableBareKeyWithComma
--- PASS: TestLexInlineTableBareKeyWithComma (0.00s)
=== RUN   TestLexInlineTableBareKeyUnderscore
--- PASS: TestLexInlineTableBareKeyUnderscore (0.00s)
=== RUN   TestLexInlineTableQuotedKey
--- PASS: TestLexInlineTableQuotedKey (0.00s)
=== RUN   TestDates
--- PASS: TestDates (0.00s)
=== RUN   TestDateIsValid
--- PASS: TestDateIsValid (0.00s)
=== RUN   TestParseDate
--- PASS: TestParseDate (0.00s)
=== RUN   TestDateArithmetic
--- PASS: TestDateArithmetic (0.00s)
=== RUN   TestDateBefore
--- PASS: TestDateBefore (0.00s)
=== RUN   TestDateAfter
--- PASS: TestDateAfter (0.00s)
=== RUN   TestTimeToString
--- PASS: TestTimeToString (0.00s)
=== RUN   TestTimeOf
--- PASS: TestTimeOf (0.00s)
=== RUN   TestTimeIsValid
--- PASS: TestTimeIsValid (0.00s)
=== RUN   TestDateTimeToString
--- PASS: TestDateTimeToString (0.00s)
=== RUN   TestParseDateTimeErrors
--- PASS: TestParseDateTimeErrors (0.00s)
=== RUN   TestDateTimeOf
--- PASS: TestDateTimeOf (0.00s)
=== RUN   TestDateTimeIsValid
--- PASS: TestDateTimeIsValid (0.00s)
=== RUN   TestDateTimeIn
--- PASS: TestDateTimeIn (0.00s)
=== RUN   TestDateTimeBefore
--- PASS: TestDateTimeBefore (0.00s)
=== RUN   TestDateTimeAfter
--- PASS: TestDateTimeAfter (0.00s)
=== RUN   TestMarshalJSON
--- PASS: TestMarshalJSON (0.00s)
=== RUN   TestUnmarshalJSON
--- PASS: TestUnmarshalJSON (0.00s)
=== RUN   TestInterface
--- PASS: TestInterface (0.00s)
=== RUN   TestBasicMarshal
--- PASS: TestBasicMarshal (0.00s)
=== RUN   TestBasicMarshalCustomIndentation
--- PASS: TestBasicMarshalCustomIndentation (0.00s)
=== RUN   TestBasicMarshalWrongIndentation
--- PASS: TestBasicMarshalWrongIndentation (0.00s)
=== RUN   TestBasicMarshalOrdered
--- PASS: TestBasicMarshalOrdered (0.00s)
=== RUN   TestBasicMarshalWithPointer
--- PASS: TestBasicMarshalWithPointer (0.00s)
=== RUN   TestBasicMarshalOrderedWithPointer
--- PASS: TestBasicMarshalOrderedWithPointer (0.00s)
=== RUN   TestBasicUnmarshal
--- PASS: TestBasicUnmarshal (0.00s)
=== RUN   TestBasicMarshalQuotedKey
--- PASS: TestBasicMarshalQuotedKey (0.00s)
=== RUN   TestBasicUnmarshalQuotedKey
{Hello 3.5 {One} [{Two} {Three}]}
--- PASS: TestBasicUnmarshalQuotedKey (0.00s)
=== RUN   TestDocMarshal
--- PASS: TestDocMarshal (0.00s)
=== RUN   TestDocMarshalOrdered
--- PASS: TestDocMarshalOrdered (0.00s)
=== RUN   TestDocMarshalMaps
--- PASS: TestDocMarshalMaps (0.00s)
=== RUN   TestDocMarshalOrderedMaps
--- PASS: TestDocMarshalOrderedMaps (0.00s)
=== RUN   TestDocMarshalPointer
--- PASS: TestDocMarshalPointer (0.00s)
=== RUN   TestDocUnmarshal
--- PASS: TestDocUnmarshal (0.00s)
=== RUN   TestDocPartialUnmarshal
--- PASS: TestDocPartialUnmarshal (0.00s)
=== RUN   TestTypeChecks
--- PASS: TestTypeChecks (0.00s)
=== RUN   TestUnexportedUnmarshal
--- PASS: TestUnexportedUnmarshal (0.00s)
=== RUN   TestErrUnmarshal
--- PASS: TestErrUnmarshal (0.00s)
=== RUN   TestEmptyMarshal
--- PASS: TestEmptyMarshal (0.00s)
=== RUN   TestEmptyMarshalOmit
--- PASS: TestEmptyMarshalOmit (0.00s)
=== RUN   TestEmptyUnmarshal
--- PASS: TestEmptyUnmarshal (0.00s)
=== RUN   TestEmptyUnmarshalOmit
--- PASS: TestEmptyUnmarshalOmit (0.00s)
=== RUN   TestPointerMarshal
--- PASS: TestPointerMarshal (0.00s)
=== RUN   TestPointerUnmarshal
--- PASS: TestPointerUnmarshal (0.00s)
=== RUN   TestUnmarshalTypeMismatch
--- PASS: TestUnmarshalTypeMismatch (0.00s)
=== RUN   TestNestedMarshal
--- PASS: TestNestedMarshal (0.00s)
=== RUN   TestNestedUnmarshal
--- PASS: TestNestedUnmarshal (0.00s)
=== RUN   TestCustomMarshaler
--- PASS: TestCustomMarshaler (0.00s)
=== RUN   TestNestedCustomMarshaler
--- PASS: TestNestedCustomMarshaler (0.00s)
=== RUN   TestTextMarshaler
--- PASS: TestTextMarshaler (0.00s)
=== RUN   TestUnmarshalTextMarshaler
--- PASS: TestUnmarshalTextMarshaler (0.00s)
=== RUN   TestNestedTextMarshaler
--- PASS: TestNestedTextMarshaler (0.00s)
=== RUN   TestPrecedentMarshaler
--- PASS: TestPrecedentMarshaler (0.00s)
=== RUN   TestPointerMarshaler
--- PASS: TestPointerMarshaler (0.00s)
=== RUN   TestPointerCustomMarshalerSequence
--- PASS: TestPointerCustomMarshalerSequence (0.00s)
=== RUN   TestPointerTextMarshalerSequence
--- PASS: TestPointerTextMarshalerSequence (0.00s)
=== RUN   TestMarshalComment
--- PASS: TestMarshalComment (0.00s)
=== RUN   TestMarshalMultilineCommented
--- PASS: TestMarshalMultilineCommented (0.00s)
=== RUN   TestMarshalMultilineLiteral
--- PASS: TestMarshalMultilineLiteral (0.00s)
=== RUN   TestMarshalNonPrimitiveTypeCommented
--- PASS: TestMarshalNonPrimitiveTypeCommented (0.00s)
=== RUN   TestCompactComments
--- PASS: TestCompactComments (0.00s)
=== RUN   TestEncodeQuotedMapKeys
--- PASS: TestEncodeQuotedMapKeys (0.00s)
=== RUN   TestDecodeQuotedMapKeys
--- PASS: TestDecodeQuotedMapKeys (0.00s)
=== RUN   TestMarshalArray
--- PASS: TestMarshalArray (0.00s)
=== RUN   TestMarshalArrayOnePerLine
--- PASS: TestMarshalArrayOnePerLine (0.00s)
=== RUN   TestMarshalCustomTag
--- PASS: TestMarshalCustomTag (0.00s)
=== RUN   TestMarshalCustomComment
--- PASS: TestMarshalCustomComment (0.00s)
=== RUN   TestMarshalCustomCommented
--- PASS: TestMarshalCustomCommented (0.00s)
=== RUN   TestMarshalDirectMultilineString
--- PASS: TestMarshalDirectMultilineString (0.00s)
=== RUN   TestUnmarshalTabInStringAndQuotedKey
--- PASS: TestUnmarshalTabInStringAndQuotedKey (0.00s)
=== RUN   TestMarshalCustomMultiline
--- PASS: TestMarshalCustomMultiline (0.00s)
=== RUN   TestMultilineWithAdjacentQuotationMarks
--- PASS: TestMultilineWithAdjacentQuotationMarks (0.00s)
=== RUN   TestMarshalEmbedTree
--- PASS: TestMarshalEmbedTree (0.00s)
=== RUN   TestUnmarshalCustomTag
--- PASS: TestUnmarshalCustomTag (0.00s)
=== RUN   TestUnmarshalMap
--- PASS: TestUnmarshalMap (0.00s)
=== RUN   TestUnmarshalMapWithTypedKey
--- PASS: TestUnmarshalMapWithTypedKey (0.00s)
=== RUN   TestUnmarshalNonPointer
--- PASS: TestUnmarshalNonPointer (0.00s)
=== RUN   TestUnmarshalInvalidPointerKind
--- PASS: TestUnmarshalInvalidPointerKind (0.00s)
=== RUN   TestMarshalSlice
--- PASS: TestMarshalSlice (0.00s)
=== RUN   TestMarshalSlicePointer
--- PASS: TestMarshalSlicePointer (0.00s)
=== RUN   TestMarshalNestedArrayInlineTables
--- PASS: TestMarshalNestedArrayInlineTables (0.00s)
=== RUN   TestUnmarshalDuration
--- PASS: TestUnmarshalDuration (0.00s)
=== RUN   TestMarshalDuration
--- PASS: TestMarshalDuration (0.00s)
=== RUN   TestUnmarshalBadDuration
--- PASS: TestUnmarshalBadDuration (0.00s)
=== RUN   TestUnmarshalCamelCaseKey
--- PASS: TestUnmarshalCamelCaseKey (0.00s)
=== RUN   TestUnmarshalNegativeUint
--- PASS: TestUnmarshalNegativeUint (0.00s)
=== RUN   TestUnmarshalCheckConversionFloatInt
--- PASS: TestUnmarshalCheckConversionFloatInt (0.00s)
=== RUN   TestUnmarshalOverflow
--- PASS: TestUnmarshalOverflow (0.00s)
=== RUN   TestUnmarshalDefault
--- PASS: TestUnmarshalDefault (0.00s)
=== RUN   TestUnmarshalDefaultFailureBool
--- PASS: TestUnmarshalDefaultFailureBool (0.00s)
=== RUN   TestUnmarshalDefaultFailureInt
--- PASS: TestUnmarshalDefaultFailureInt (0.00s)
=== RUN   TestUnmarshalDefaultFailureInt64
--- PASS: TestUnmarshalDefaultFailureInt64 (0.00s)
=== RUN   TestUnmarshalDefaultFailureFloat64
--- PASS: TestUnmarshalDefaultFailureFloat64 (0.00s)
=== RUN   TestUnmarshalDefaultFailureDuration
--- PASS: TestUnmarshalDefaultFailureDuration (0.00s)
=== RUN   TestUnmarshalDefaultFailureUnsupported
--- PASS: TestUnmarshalDefaultFailureUnsupported (0.00s)
=== RUN   TestMarshalNestedAnonymousStructs
--- PASS: TestMarshalNestedAnonymousStructs (0.00s)
=== RUN   TestEncoderPromoteNestedAnonymousStructs
--- PASS: TestEncoderPromoteNestedAnonymousStructs (0.00s)
=== RUN   TestMarshalNestedAnonymousStructs_DuplicateField
--- PASS: TestMarshalNestedAnonymousStructs_DuplicateField (0.00s)
=== RUN   TestUnmarshalNestedAnonymousStructs
--- PASS: TestUnmarshalNestedAnonymousStructs (0.00s)
=== RUN   TestUnmarshalNestedAnonymousStructs_Controversial
--- PASS: TestUnmarshalNestedAnonymousStructs_Controversial (0.00s)
=== RUN   TestUnmarshalPreservesUnexportedFields
=== RUN   TestUnmarshalPreservesUnexportedFields/unexported_field_should_not_be_set_from_toml
=== RUN   TestUnmarshalPreservesUnexportedFields/unexported_field_should_be_preserved
--- PASS: TestUnmarshalPreservesUnexportedFields (0.00s)
    --- PASS: TestUnmarshalPreservesUnexportedFields/unexported_field_should_not_be_set_from_toml (0.00s)
    --- PASS: TestUnmarshalPreservesUnexportedFields/unexported_field_should_be_preserved (0.00s)
=== RUN   TestTreeMarshal
=== RUN   TestTreeMarshal/#00
=== RUN   TestTreeMarshal/#01
=== RUN   TestTreeMarshal/#02
=== RUN   TestTreeMarshal/#03
--- PASS: TestTreeMarshal (0.00s)
    --- PASS: TestTreeMarshal/#00 (0.00s)
    --- PASS: TestTreeMarshal/#01 (0.00s)
    --- PASS: TestTreeMarshal/#02 (0.00s)
    --- PASS: TestTreeMarshal/#03 (0.00s)
=== RUN   TestMarshalArrays
=== RUN   TestMarshalArrays/#00
=== RUN   TestMarshalArrays/#01
=== RUN   TestMarshalArrays/#02
=== RUN   TestMarshalArrays/#03
--- PASS: TestMarshalArrays (0.00s)
    --- PASS: TestMarshalArrays/#00 (0.00s)
    --- PASS: TestMarshalArrays/#01 (0.00s)
    --- PASS: TestMarshalArrays/#02 (0.00s)
    --- PASS: TestMarshalArrays/#03 (0.00s)
=== RUN   TestUnmarshalLocalDate
=== RUN   TestUnmarshalLocalDate/ToLocalDate
=== RUN   TestUnmarshalLocalDate/ToLocalDate#01
--- PASS: TestUnmarshalLocalDate (0.00s)
    --- PASS: TestUnmarshalLocalDate/ToLocalDate (0.00s)
    --- PASS: TestUnmarshalLocalDate/ToLocalDate#01 (0.00s)
=== RUN   TestMarshalLocalDate
--- PASS: TestMarshalLocalDate (0.00s)
=== RUN   TestUnmarshalLocalDateTime
=== RUN   TestUnmarshalLocalDateTime/ToLocalDateTime_0_normal
=== RUN   TestUnmarshalLocalDateTime/ToTime_0_normal
=== RUN   TestUnmarshalLocalDateTime/ToLocalDateTime_1_with_nanoseconds
=== RUN   TestUnmarshalLocalDateTime/ToTime_1_with_nanoseconds
--- PASS: TestUnmarshalLocalDateTime (0.00s)
    --- PASS: TestUnmarshalLocalDateTime/ToLocalDateTime_0_normal (0.00s)
    --- PASS: TestUnmarshalLocalDateTime/ToTime_0_normal (0.00s)
    --- PASS: TestUnmarshalLocalDateTime/ToLocalDateTime_1_with_nanoseconds (0.00s)
    --- PASS: TestUnmarshalLocalDateTime/ToTime_1_with_nanoseconds (0.00s)
=== RUN   TestMarshalLocalDateTime
=== RUN   TestMarshalLocalDateTime/0_normal
=== RUN   TestMarshalLocalDateTime/1_with_nanoseconds
--- PASS: TestMarshalLocalDateTime (0.00s)
    --- PASS: TestMarshalLocalDateTime/0_normal (0.00s)
    --- PASS: TestMarshalLocalDateTime/1_with_nanoseconds (0.00s)
=== RUN   TestUnmarshalLocalTime
=== RUN   TestUnmarshalLocalTime/ToLocalTime_0_normal
=== RUN   TestUnmarshalLocalTime/ToLocalTime_1_with_nanoseconds
--- PASS: TestUnmarshalLocalTime (0.00s)
    --- PASS: TestUnmarshalLocalTime/ToLocalTime_0_normal (0.00s)
    --- PASS: TestUnmarshalLocalTime/ToLocalTime_1_with_nanoseconds (0.00s)
=== RUN   TestMarshalLocalTime
=== RUN   TestMarshalLocalTime/0_normal
=== RUN   TestMarshalLocalTime/1_with_nanoseconds
--- PASS: TestMarshalLocalTime (0.00s)
    --- PASS: TestMarshalLocalTime/0_normal (0.00s)
    --- PASS: TestMarshalLocalTime/1_with_nanoseconds (0.00s)
=== RUN   TestUnmarshalSameInnerField
--- PASS: TestUnmarshalSameInnerField (0.00s)
=== RUN   TestMarshalInterface
--- PASS: TestMarshalInterface (0.00s)
=== RUN   TestUnmarshalToNilInterface
--- PASS: TestUnmarshalToNilInterface (0.00s)
=== RUN   TestUnmarshalToNonNilInterface
--- PASS: TestUnmarshalToNonNilInterface (0.00s)
=== RUN   TestUnmarshalEmbedTree
--- PASS: TestUnmarshalEmbedTree (0.00s)
=== RUN   TestMarshalNil
--- PASS: TestMarshalNil (0.00s)
=== RUN   TestUnmarshalNil
--- PASS: TestUnmarshalNil (0.00s)
=== RUN   TestUnmarshalSlice
--- PASS: TestUnmarshalSlice (0.00s)
=== RUN   TestUnmarshalSliceFail
--- PASS: TestUnmarshalSliceFail (0.00s)
=== RUN   TestUnmarshalSliceFail2
--- PASS: TestUnmarshalSliceFail2 (0.00s)
=== RUN   TestMarshalMixedTypeArray
--- PASS: TestMarshalMixedTypeArray (0.00s)
=== RUN   TestUnmarshalMixedTypeArray
--- PASS: TestUnmarshalMixedTypeArray (0.00s)
=== RUN   TestUnmarshalArray
--- PASS: TestUnmarshalArray (0.00s)
=== RUN   TestUnmarshalArrayFail
--- PASS: TestUnmarshalArrayFail (0.00s)
=== RUN   TestUnmarshalArrayFail2
--- PASS: TestUnmarshalArrayFail2 (0.00s)
=== RUN   TestUnmarshalArrayFail3
--- PASS: TestUnmarshalArrayFail3 (0.00s)
=== RUN   TestDecoderStrict
--- PASS: TestDecoderStrict (0.00s)
=== RUN   TestDecoderStrictValid
--- PASS: TestDecoderStrictValid (0.00s)
=== RUN   TestDecoderStrictCustomUnmarshal
--- PASS: TestDecoderStrictCustomUnmarshal (0.00s)
=== RUN   TestCustomUnmarshal
--- PASS: TestCustomUnmarshal (0.00s)
=== RUN   TestCustomUnmarshalError
--- PASS: TestCustomUnmarshalError (0.00s)
=== RUN   TestTextUnmarshal
--- PASS: TestTextUnmarshal (0.00s)
=== RUN   TestTextUnmarshalError
--- PASS: TestTextUnmarshalError (0.00s)
=== RUN   TestPreserveNotEmptyField
--- PASS: TestPreserveNotEmptyField (0.00s)
=== RUN   TestUnmarshalEmptyInterface
--- PASS: TestUnmarshalEmptyInterface (0.00s)
=== RUN   TestUnmarshalEmptyInterfaceDeep
--- PASS: TestUnmarshalEmptyInterfaceDeep (0.00s)
=== RUN   TestGithubIssue431
--- PASS: TestGithubIssue431 (0.00s)
=== RUN   TestGithubIssue437
--- PASS: TestGithubIssue437 (0.00s)
=== RUN   TestLeafUnmarshalerError
--- PASS: TestLeafUnmarshalerError (0.00s)
=== RUN   TestGithubIssue732
--- PASS: TestGithubIssue732 (0.00s)
=== RUN   TestCreateSubTree
--- PASS: TestCreateSubTree (0.00s)
=== RUN   TestSimpleKV
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e87e0)(a = 42
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e88d0)(a = 42
        b = 21
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:18: asserting path [b]
    parser_test.go:31: 	comparing key [b] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSimpleKV (0.00s)
=== RUN   TestNumberInKey
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e89c0)(hello2 = 42
        )
    parser_test.go:18: asserting path [hello2]
    parser_test.go:31: 	comparing key [hello2] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNumberInKey (0.00s)
=== RUN   TestIncorrectKeyExtraSquareBracket
--- PASS: TestIncorrectKeyExtraSquareBracket (0.00s)
=== RUN   TestSimpleNumbers
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e8c00)(a = 42
        b = -21
        c = 4.2
        d = -2.1
        )
    parser_test.go:18: asserting path [b]
    parser_test.go:31: 	comparing key [b] by string representation because it's of type int64
    parser_test.go:18: asserting path [c]
    parser_test.go:31: 	comparing key [c] by string representation because it's of type float64
    parser_test.go:18: asserting path [d]
    parser_test.go:31: 	comparing key [d] by string representation because it's of type float64
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSimpleNumbers (0.00s)
=== RUN   TestSpecialFloats
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e8d20)(minusinf = -inf
        minusnan = nan
        normalinf = +inf
        normalnan = nan
        plusinf = +inf
        plusnan = nan
        )
    parser_test.go:18: asserting path [normalinf]
    parser_test.go:31: 	comparing key [normalinf] by string representation because it's of type float64
    parser_test.go:18: asserting path [plusinf]
    parser_test.go:31: 	comparing key [plusinf] by string representation because it's of type float64
    parser_test.go:18: asserting path [minusinf]
    parser_test.go:31: 	comparing key [minusinf] by string representation because it's of type float64
    parser_test.go:18: asserting path [normalnan]
    parser_test.go:31: 	comparing key [normalnan] by string representation because it's of type float64
    parser_test.go:18: asserting path [plusnan]
    parser_test.go:31: 	comparing key [plusnan] by string representation because it's of type float64
    parser_test.go:18: asserting path [minusnan]
    parser_test.go:31: 	comparing key [minusnan] by string representation because it's of type float64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSpecialFloats (0.00s)
=== RUN   TestHexIntegers
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e8e40)(a = 3735928559
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e8f30)(a = 3735928559
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e8ff0)(a = 3735928559
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestHexIntegers (0.00s)
=== RUN   TestOctIntegers
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9140)(a = 342391
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9230)(a = 493
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestOctIntegers (0.00s)
=== RUN   TestBinIntegers
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9380)(a = 214
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestBinIntegers (0.00s)
=== RUN   TestBadIntegerBase
--- PASS: TestBadIntegerBase (0.00s)
=== RUN   TestIntegerNoDigit
--- PASS: TestIntegerNoDigit (0.00s)
=== RUN   TestNumbersWithUnderscores
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9620)(a = 1000
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9710)(a = 5349221
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e97d0)(a = 12345
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9890)(flt8 = 9224617.445991227
        )
    parser_test.go:18: asserting path [flt8]
    parser_test.go:31: 	comparing key [flt8] by string representation because it's of type float64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9950)(flt9 = 10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104.0
        )
    parser_test.go:18: asserting path [flt9]
    parser_test.go:31: 	comparing key [flt9] by string representation because it's of type float64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNumbersWithUnderscores (0.00s)
=== RUN   TestFloatsWithExponents
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9a40)(a = 49999999999999995805696.0
        b = 49999999999999995805696.0
        c = -49999999999999995805696.0
        d = -0.0000000000000000000005
        e = 0.0000000000000000000000000000000006626
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type float64
    parser_test.go:18: asserting path [b]
    parser_test.go:31: 	comparing key [b] by string representation because it's of type float64
    parser_test.go:18: asserting path [c]
    parser_test.go:31: 	comparing key [c] by string representation because it's of type float64
    parser_test.go:18: asserting path [d]
    parser_test.go:31: 	comparing key [d] by string representation because it's of type float64
    parser_test.go:18: asserting path [e]
    parser_test.go:31: 	comparing key [e] by string representation because it's of type float64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestFloatsWithExponents (0.00s)
=== RUN   TestSimpleDate
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9b60)(a = 1979-05-27T07:32:00Z
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type time.Time
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSimpleDate (0.00s)
=== RUN   TestDateOffset
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9c80)(a = 1979-05-27T00:32:00-07:00
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type time.Time
    parser_test.go:42: Finished tree assertion.
--- PASS: TestDateOffset (0.00s)
=== RUN   TestDateNano
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9da0)(a = 1979-05-27T00:32:00-07:00
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type time.Time
    parser_test.go:42: Finished tree assertion.
--- PASS: TestDateNano (0.00s)
=== RUN   TestLocalDateTime
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003e9ec0)(a = 1979-05-27T07:32:00
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type toml.LocalDateTime
    parser_test.go:42: Finished tree assertion.
--- PASS: TestLocalDateTime (0.00s)
=== RUN   TestLocalDateTimeNano
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470060)(a = 1979-05-27T07:32:00.999999000
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type toml.LocalDateTime
    parser_test.go:42: Finished tree assertion.
--- PASS: TestLocalDateTimeNano (0.00s)
=== RUN   TestLocalDate
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470180)(a = 1979-05-27
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type toml.LocalDate
    parser_test.go:42: Finished tree assertion.
--- PASS: TestLocalDate (0.00s)
=== RUN   TestLocalDateError
--- PASS: TestLocalDateError (0.00s)
=== RUN   TestLocalTimeError
--- PASS: TestLocalTimeError (0.00s)
=== RUN   TestLocalDateTimeError
--- PASS: TestLocalDateTimeError (0.00s)
=== RUN   TestDateTimeOffsetError
--- PASS: TestDateTimeOffsetError (0.00s)
=== RUN   TestLocalTime
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004704e0)(a = 07:32:00
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type toml.LocalTime
    parser_test.go:42: Finished tree assertion.
--- PASS: TestLocalTime (0.00s)
=== RUN   TestLocalTimeNano
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470600)(a = 00:32:00.999999000
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type toml.LocalTime
    parser_test.go:42: Finished tree assertion.
--- PASS: TestLocalTimeNano (0.00s)
=== RUN   TestSimpleString
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470720)(a = "hello world"
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSimpleString (0.00s)
=== RUN   TestSpaceKey
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470840)("a b" = "hello world"
        )
    parser_test.go:18: asserting path [a b]
    parser_test.go:31: 	comparing key [a b] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSpaceKey (0.00s)
=== RUN   TestDoubleQuotedKey
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470960)("\t" = "b"
        key = "a"
        "❤" = "d"
        "🤔" = "c"
        )
    parser_test.go:18: asserting path [key]
    parser_test.go:31: 	comparing key [key] by string representation because it's of type string
    parser_test.go:18: asserting path [	]
    parser_test.go:31: 	comparing key [	] by string representation because it's of type string
    parser_test.go:18: asserting path [🤔]
    parser_test.go:31: 	comparing key [🤔] by string representation because it's of type string
    parser_test.go:18: asserting path [❤]
    parser_test.go:31: 	comparing key [❤] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestDoubleQuotedKey (0.00s)
=== RUN   TestSingleQuotedKey
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470a80)("\\U0001F914" = "c"
        "\\t" = "b"
        "\\u2764" = "d"
        key = "a"
        )
    parser_test.go:18: asserting path [\u2764]
    parser_test.go:31: 	comparing key [\u2764] by string representation because it's of type string
    parser_test.go:18: asserting path [key]
    parser_test.go:31: 	comparing key [key] by string representation because it's of type string
    parser_test.go:18: asserting path [\t]
    parser_test.go:31: 	comparing key [\t] by string representation because it's of type string
    parser_test.go:18: asserting path [\U0001F914]
    parser_test.go:31: 	comparing key [\U0001F914] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSingleQuotedKey (0.00s)
=== RUN   TestStringEscapables
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470ba0)(a = "a \n b"
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470c90)(a = "a \t b"
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470d50)(a = "a \r b"
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470e10)(a = "a \\ b"
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestStringEscapables (0.00s)
=== RUN   TestEmptyQuotedString
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470f00)(
        []
           = 1
        )
    parser_test.go:18: asserting path []
    parser_test.go:28: 	comparing key [] by subtree assestion
    parser_test.go:18: asserting path [ ]
    parser_test.go:31: 	comparing key [ ] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestEmptyQuotedString (0.00s)
=== RUN   TestBools
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471080)(a = true
        b = false
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type bool
    parser_test.go:18: asserting path [b]
    parser_test.go:31: 	comparing key [b] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
--- PASS: TestBools (0.00s)
=== RUN   TestNestedKeys
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004711a0)(
        [a]
        
          [a.b]
        
            [a.b.c]
              d = 42
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:28: 	comparing key [a] by subtree assestion
    parser_test.go:18: asserting path [a b]
    parser_test.go:28: 	comparing key [a b] by subtree assestion
    parser_test.go:18: asserting path [a b c]
    parser_test.go:28: 	comparing key [a b c] by subtree assestion
    parser_test.go:18: asserting path [a b c d]
    parser_test.go:31: 	comparing key [a b c d] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNestedKeys (0.00s)
=== RUN   TestNestedQuotedUnicodeKeys
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471440)(
        [j]
        
          [j."ʞ"]
        
            [j."ʞ".l]
              d = 42
        )
    parser_test.go:18: asserting path [j]
    parser_test.go:28: 	comparing key [j] by subtree assestion
    parser_test.go:18: asserting path [j ʞ]
    parser_test.go:28: 	comparing key [j ʞ] by subtree assestion
    parser_test.go:18: asserting path [j ʞ l]
    parser_test.go:28: 	comparing key [j ʞ l] by subtree assestion
    parser_test.go:18: asserting path [j ʞ l d]
    parser_test.go:31: 	comparing key [j ʞ l d] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004716b0)(
        [g]
        
          [g.h]
        
            [g.h.i]
              d = 42
        )
    parser_test.go:18: asserting path [g]
    parser_test.go:28: 	comparing key [g] by subtree assestion
    parser_test.go:18: asserting path [g h]
    parser_test.go:28: 	comparing key [g h] by subtree assestion
    parser_test.go:18: asserting path [g h i]
    parser_test.go:28: 	comparing key [g h i] by subtree assestion
    parser_test.go:18: asserting path [g h i d]
    parser_test.go:31: 	comparing key [g h i d] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004718f0)(
        [d]
        
          [d.e]
        
            [d.e.f]
              k = 42
        )
    parser_test.go:18: asserting path [d]
    parser_test.go:28: 	comparing key [d] by subtree assestion
    parser_test.go:18: asserting path [d e]
    parser_test.go:28: 	comparing key [d e] by subtree assestion
    parser_test.go:18: asserting path [d e f]
    parser_test.go:28: 	comparing key [d e f] by subtree assestion
    parser_test.go:18: asserting path [d e f k]
    parser_test.go:31: 	comparing key [d e f k] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNestedQuotedUnicodeKeys (0.00s)
=== RUN   TestArrayOne
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471b90)(a = [1]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayOne (0.00s)
=== RUN   TestArrayZero
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471cb0)(a = []
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayZero (0.00s)
=== RUN   TestArraySimple
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471dd0)(a = [42, 21, 10]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471ec0)(a = [42, 21, 10]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArraySimple (0.00s)
=== RUN   TestArrayMultiline
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da030)(a = [42, 21, 10]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayMultiline (0.00s)
=== RUN   TestArrayNested
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da150)(a = [[42, 21], [10]]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayNested (0.00s)
=== RUN   TestNestedArrayComment
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da2a0)(someArray = [["entry1"]]
        )
    parser_test.go:18: asserting path [someArray]
    parser_test.go:31: 	comparing key [someArray] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNestedArrayComment (0.00s)
=== RUN   TestNestedEmptyArrays
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da3c0)(a = [[[]]]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNestedEmptyArrays (0.00s)
=== RUN   TestArrayNestedStrings
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da4e0)(data = [["gamma", "delta"], ["Foo"]]
        )
    parser_test.go:18: asserting path [data]
    parser_test.go:31: 	comparing key [data] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayNestedStrings (0.00s)
=== RUN   TestParseUnknownRvalue
--- PASS: TestParseUnknownRvalue (0.00s)
=== RUN   TestMissingValue
--- PASS: TestMissingValue (0.00s)
=== RUN   TestUnterminatedArray
--- PASS: TestUnterminatedArray (0.00s)
=== RUN   TestNewlinesInArrays
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002da900)(a = [1, 2, 3]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNewlinesInArrays (0.00s)
=== RUN   TestArrayWithExtraComma
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002daa20)(a = [1, 2, 3]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayWithExtraComma (0.00s)
=== RUN   TestArrayWithExtraCommaComment
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002dab40)(a = [1, 2, 3]
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:31: 	comparing key [a] by string representation because it's of type []interface {}
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayWithExtraCommaComment (0.00s)
=== RUN   TestSimpleInlineGroup
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002dac60)(
        [key]
          a = 42
        )
    parser_test.go:18: asserting path [key]
    parser_test.go:28: 	comparing key [key] by subtree assestion
    parser_test.go:18: asserting path [key a]
    parser_test.go:31: 	comparing key [key a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestSimpleInlineGroup (0.00s)
=== RUN   TestDoubleInlineGroup
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002dade0)(
        [key]
          a = 42
          b = "foo"
        )
    parser_test.go:18: asserting path [key]
    parser_test.go:28: 	comparing key [key] by subtree assestion
    parser_test.go:18: asserting path [key a]
    parser_test.go:31: 	comparing key [key a] by string representation because it's of type int64
    parser_test.go:18: asserting path [key b]
    parser_test.go:31: 	comparing key [key b] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestDoubleInlineGroup (0.00s)
=== RUN   TestNestedInlineGroup
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002daf90)(
        [out]
        
          [out.block0]
            x = 99
            y = 100
        
          [out.block1]
            p = "999"
            q = "1000"
        )
    parser_test.go:18: asserting path [out]
    parser_test.go:28: 	comparing key [out] by subtree assestion
    parser_test.go:18: asserting path [out block0]
    parser_test.go:28: 	comparing key [out block0] by subtree assestion
    parser_test.go:18: asserting path [out block0 x]
    parser_test.go:31: 	comparing key [out block0 x] by string representation because it's of type int64
    parser_test.go:18: asserting path [out block0 y]
    parser_test.go:31: 	comparing key [out block0 y] by string representation because it's of type int64
    parser_test.go:18: asserting path [out block1]
    parser_test.go:28: 	comparing key [out block1] by subtree assestion
    parser_test.go:18: asserting path [out block1 p]
    parser_test.go:31: 	comparing key [out block1 p] by string representation because it's of type string
    parser_test.go:18: asserting path [out block1 q]
    parser_test.go:31: 	comparing key [out block1 q] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestNestedInlineGroup (0.00s)
=== RUN   TestArrayInNestedInlineGroup
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002db2c0)(
        [image]
          name = "xxx"
        
          [image.palette]
            colors = ["red", "blue", "green"]
            id = 100
        )
    parser_test.go:18: asserting path [image]
    parser_test.go:28: 	comparing key [image] by subtree assestion
    parser_test.go:18: asserting path [image palette]
    parser_test.go:28: 	comparing key [image palette] by subtree assestion
    parser_test.go:18: asserting path [image palette id]
    parser_test.go:31: 	comparing key [image palette id] by string representation because it's of type int64
    parser_test.go:18: asserting path [image palette colors]
    parser_test.go:31: 	comparing key [image palette colors] by string representation because it's of type []interface {}
    parser_test.go:18: asserting path [image name]
    parser_test.go:31: 	comparing key [image name] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestArrayInNestedInlineGroup (0.00s)
=== RUN   TestExampleInlineGroup
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002db560)(
        [name]
          first = "Tom"
          last = "Preston-Werner"
        
        [point]
          x = 1
          y = 2
        )
    parser_test.go:18: asserting path [name]
    parser_test.go:28: 	comparing key [name] by subtree assestion
    parser_test.go:18: asserting path [name first]
    parser_test.go:31: 	comparing key [name first] by string representation because it's of type string
    parser_test.go:18: asserting path [name last]
    parser_test.go:31: 	comparing key [name last] by string representation because it's of type string
    parser_test.go:18: asserting path [point]
    parser_test.go:28: 	comparing key [point] by subtree assestion
    parser_test.go:18: asserting path [point y]
    parser_test.go:31: 	comparing key [point y] by string representation because it's of type int64
    parser_test.go:18: asserting path [point x]
    parser_test.go:31: 	comparing key [point x] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestExampleInlineGroup (0.00s)
=== RUN   TestInlineGroupBareKeysUnderscore
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002db800)(
        [foo]
          _bar = "buz"
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:28: 	comparing key [foo] by subtree assestion
    parser_test.go:18: asserting path [foo _bar]
    parser_test.go:31: 	comparing key [foo _bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestInlineGroupBareKeysUnderscore (0.00s)
=== RUN   TestInlineGroupBareKeysDash
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002db980)(
        [foo]
          -bar = "buz"
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:28: 	comparing key [foo] by subtree assestion
    parser_test.go:18: asserting path [foo -bar]
    parser_test.go:31: 	comparing key [foo -bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestInlineGroupBareKeysDash (0.00s)
=== RUN   TestInlineGroupKeyQuoted
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002dbb00)(
        [foo]
          bar = "buz"
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:28: 	comparing key [foo] by subtree assestion
    parser_test.go:18: asserting path [foo bar]
    parser_test.go:31: 	comparing key [foo bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestInlineGroupKeyQuoted (0.00s)
=== RUN   TestExampleInlineGroupInArray
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002dbc80)(
        [[points]]
          x = 1
          y = 2
        )
    parser_test.go:18: asserting path [points]
    parser_test.go:23: 	comparing key [points] by array iteration
    parser_test.go:18: asserting path [points x]
    parser_test.go:31: 	comparing key [points x] by string representation because it's of type int64
    parser_test.go:18: asserting path [points y]
    parser_test.go:31: 	comparing key [points y] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestExampleInlineGroupInArray (0.00s)
=== RUN   TestInlineTableUnterminated
--- PASS: TestInlineTableUnterminated (0.00s)
=== RUN   TestInlineTableCommaExpected
--- PASS: TestInlineTableCommaExpected (0.00s)
=== RUN   TestInlineTableCommaStart
--- PASS: TestInlineTableCommaStart (0.00s)
=== RUN   TestInlineTableDoubleComma
--- PASS: TestInlineTableDoubleComma (0.00s)
=== RUN   TestInlineTableTrailingComma
--- PASS: TestInlineTableTrailingComma (0.00s)
=== RUN   TestAddKeyToInlineTable
--- PASS: TestAddKeyToInlineTable (0.00s)
=== RUN   TestAddSubTableToInlineTable
--- PASS: TestAddSubTableToInlineTable (0.00s)
=== RUN   TestAddKeyToSubTableOfInlineTable
--- PASS: TestAddKeyToSubTableOfInlineTable (0.00s)
=== RUN   TestReDefineInlineTable
--- PASS: TestReDefineInlineTable (0.00s)
=== RUN   TestDuplicateGroups
--- PASS: TestDuplicateGroups (0.00s)
=== RUN   TestDuplicateKeys
--- PASS: TestDuplicateKeys (0.00s)
=== RUN   TestEmptyIntermediateTable
--- PASS: TestEmptyIntermediateTable (0.00s)
=== RUN   TestImplicitDeclarationBefore
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003669f0)(
        [a]
          better = 43
        
          [a.b]
        
            [a.b.c]
              answer = 42
        )
    parser_test.go:18: asserting path [a]
    parser_test.go:28: 	comparing key [a] by subtree assestion
    parser_test.go:18: asserting path [a b]
    parser_test.go:28: 	comparing key [a b] by subtree assestion
    parser_test.go:18: asserting path [a b c]
    parser_test.go:28: 	comparing key [a b c] by subtree assestion
    parser_test.go:18: asserting path [a b c answer]
    parser_test.go:31: 	comparing key [a b c answer] by string representation because it's of type int64
    parser_test.go:18: asserting path [a better]
    parser_test.go:31: 	comparing key [a better] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestImplicitDeclarationBefore (0.00s)
=== RUN   TestFloatsWithoutLeadingZeros
--- PASS: TestFloatsWithoutLeadingZeros (0.00s)
=== RUN   TestMissingFile
--- PASS: TestMissingFile (0.00s)
=== RUN   TestParseFile
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000366e10)(title = "TOML Example"
        
        [clients]
          data = [["gamma", "delta"], [1, 2]]
          score = 0.00000004
        
        [database]
          connection_max = 5000
          enabled = true
          ports = [8001, 8001, 8002]
          server = "192.168.1.1"
        
        [owner]
          bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
          dob = 1979-05-27T07:32:00Z
          name = "Tom Preston-Werner"
          organization = "GitHub"
        
        [servers]
        
          [servers.alpha]
            dc = "eqdc10"
            ip = "10.0.0.1"
        
          [servers.beta]
            dc = "eqdc10"
            ip = "10.0.0.2"
        )
    parser_test.go:18: asserting path [owner]
    parser_test.go:28: 	comparing key [owner] by subtree assestion
    parser_test.go:18: asserting path [owner organization]
    parser_test.go:31: 	comparing key [owner organization] by string representation because it's of type string
    parser_test.go:18: asserting path [owner bio]
    parser_test.go:31: 	comparing key [owner bio] by string representation because it's of type string
    parser_test.go:18: asserting path [owner dob]
    parser_test.go:31: 	comparing key [owner dob] by string representation because it's of type time.Time
    parser_test.go:18: asserting path [owner name]
    parser_test.go:31: 	comparing key [owner name] by string representation because it's of type string
    parser_test.go:18: asserting path [database]
    parser_test.go:28: 	comparing key [database] by subtree assestion
    parser_test.go:18: asserting path [database ports]
    parser_test.go:31: 	comparing key [database ports] by string representation because it's of type []interface {}
    parser_test.go:18: asserting path [database connection_max]
    parser_test.go:31: 	comparing key [database connection_max] by string representation because it's of type int64
    parser_test.go:18: asserting path [database enabled]
    parser_test.go:31: 	comparing key [database enabled] by string representation because it's of type bool
    parser_test.go:18: asserting path [database server]
    parser_test.go:31: 	comparing key [database server] by string representation because it's of type string
    parser_test.go:18: asserting path [servers]
    parser_test.go:28: 	comparing key [servers] by subtree assestion
    parser_test.go:18: asserting path [servers alpha]
    parser_test.go:28: 	comparing key [servers alpha] by subtree assestion
    parser_test.go:18: asserting path [servers alpha ip]
    parser_test.go:31: 	comparing key [servers alpha ip] by string representation because it's of type string
    parser_test.go:18: asserting path [servers alpha dc]
    parser_test.go:31: 	comparing key [servers alpha dc] by string representation because it's of type string
    parser_test.go:18: asserting path [servers beta]
    parser_test.go:28: 	comparing key [servers beta] by subtree assestion
    parser_test.go:18: asserting path [servers beta ip]
    parser_test.go:31: 	comparing key [servers beta ip] by string representation because it's of type string
    parser_test.go:18: asserting path [servers beta dc]
    parser_test.go:31: 	comparing key [servers beta dc] by string representation because it's of type string
    parser_test.go:18: asserting path [clients]
    parser_test.go:28: 	comparing key [clients] by subtree assestion
    parser_test.go:18: asserting path [clients data]
    parser_test.go:31: 	comparing key [clients data] by string representation because it's of type []interface {}
    parser_test.go:18: asserting path [clients score]
    parser_test.go:31: 	comparing key [clients score] by string representation because it's of type float64
    parser_test.go:18: asserting path [title]
    parser_test.go:31: 	comparing key [title] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestParseFile (0.00s)
=== RUN   TestParseFileCRLF
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003673b0)(title = "TOML Example"
        
        [clients]
          data = [["gamma", "delta"], [1, 2]]
          score = 0.00000004
        
        [database]
          connection_max = 5000
          enabled = true
          ports = [8001, 8001, 8002]
          server = "192.168.1.1"
        
        [owner]
          bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
          dob = 1979-05-27T07:32:00Z
          name = "Tom Preston-Werner"
          organization = "GitHub"
        
        [servers]
        
          [servers.alpha]
            dc = "eqdc10"
            ip = "10.0.0.1"
        
          [servers.beta]
            dc = "eqdc10"
            ip = "10.0.0.2"
        )
    parser_test.go:18: asserting path [title]
    parser_test.go:31: 	comparing key [title] by string representation because it's of type string
    parser_test.go:18: asserting path [owner]
    parser_test.go:28: 	comparing key [owner] by subtree assestion
    parser_test.go:18: asserting path [owner bio]
    parser_test.go:31: 	comparing key [owner bio] by string representation because it's of type string
    parser_test.go:18: asserting path [owner dob]
    parser_test.go:31: 	comparing key [owner dob] by string representation because it's of type time.Time
    parser_test.go:18: asserting path [owner name]
    parser_test.go:31: 	comparing key [owner name] by string representation because it's of type string
    parser_test.go:18: asserting path [owner organization]
    parser_test.go:31: 	comparing key [owner organization] by string representation because it's of type string
    parser_test.go:18: asserting path [database]
    parser_test.go:28: 	comparing key [database] by subtree assestion
    parser_test.go:18: asserting path [database server]
    parser_test.go:31: 	comparing key [database server] by string representation because it's of type string
    parser_test.go:18: asserting path [database ports]
    parser_test.go:31: 	comparing key [database ports] by string representation because it's of type []interface {}
    parser_test.go:18: asserting path [database connection_max]
    parser_test.go:31: 	comparing key [database connection_max] by string representation because it's of type int64
    parser_test.go:18: asserting path [database enabled]
    parser_test.go:31: 	comparing key [database enabled] by string representation because it's of type bool
    parser_test.go:18: asserting path [servers]
    parser_test.go:28: 	comparing key [servers] by subtree assestion
    parser_test.go:18: asserting path [servers alpha]
    parser_test.go:28: 	comparing key [servers alpha] by subtree assestion
    parser_test.go:18: asserting path [servers alpha ip]
    parser_test.go:31: 	comparing key [servers alpha ip] by string representation because it's of type string
    parser_test.go:18: asserting path [servers alpha dc]
    parser_test.go:31: 	comparing key [servers alpha dc] by string representation because it's of type string
    parser_test.go:18: asserting path [servers beta]
    parser_test.go:28: 	comparing key [servers beta] by subtree assestion
    parser_test.go:18: asserting path [servers beta ip]
    parser_test.go:31: 	comparing key [servers beta ip] by string representation because it's of type string
    parser_test.go:18: asserting path [servers beta dc]
    parser_test.go:31: 	comparing key [servers beta dc] by string representation because it's of type string
    parser_test.go:18: asserting path [clients]
    parser_test.go:28: 	comparing key [clients] by subtree assestion
    parser_test.go:18: asserting path [clients data]
    parser_test.go:31: 	comparing key [clients data] by string representation because it's of type []interface {}
    parser_test.go:18: asserting path [clients score]
    parser_test.go:31: 	comparing key [clients score] by string representation because it's of type float64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestParseFileCRLF (0.00s)
=== RUN   TestParseKeyGroupArray
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000367950)(
        [foo]
        
          [[foo.bar]]
            a = 42
        
          [[foo.bar]]
            a = 69
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:28: 	comparing key [foo] by subtree assestion
    parser_test.go:18: asserting path [foo bar]
    parser_test.go:23: 	comparing key [foo bar] by array iteration
    parser_test.go:18: asserting path [foo bar a]
    parser_test.go:31: 	comparing key [foo bar a] by string representation because it's of type int64
    parser_test.go:18: asserting path [foo bar a]
    parser_test.go:31: 	comparing key [foo bar a] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestParseKeyGroupArray (0.00s)
=== RUN   TestParseKeyGroupArrayUnfinished
--- PASS: TestParseKeyGroupArrayUnfinished (0.00s)
=== RUN   TestParseKeyGroupArrayQueryExample
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000367da0)(
        [[book]]
          author = "Stephen King"
          title = "The Stand"
        
        [[book]]
          author = "Ernest Hemmingway"
          title = "For Whom the Bell Tolls"
        
        [[book]]
          author = "William Gibson"
          title = "Neuromancer"
        )
    parser_test.go:18: asserting path [book]
    parser_test.go:23: 	comparing key [book] by array iteration
    parser_test.go:18: asserting path [book title]
    parser_test.go:31: 	comparing key [book title] by string representation because it's of type string
    parser_test.go:18: asserting path [book author]
    parser_test.go:31: 	comparing key [book author] by string representation because it's of type string
    parser_test.go:18: asserting path [book title]
    parser_test.go:31: 	comparing key [book title] by string representation because it's of type string
    parser_test.go:18: asserting path [book author]
    parser_test.go:31: 	comparing key [book author] by string representation because it's of type string
    parser_test.go:18: asserting path [book title]
    parser_test.go:31: 	comparing key [book title] by string representation because it's of type string
    parser_test.go:18: asserting path [book author]
    parser_test.go:31: 	comparing key [book author] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestParseKeyGroupArrayQueryExample (0.00s)
=== RUN   TestParseKeyGroupArraySpec
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003ea150)(
        [[fruit]]
          name = "apple"
        
          [fruit.physical]
            color = "red"
            shape = "round"
        
        [[fruit]]
          name = "banana"
        )
    parser_test.go:18: asserting path [fruit]
    parser_test.go:23: 	comparing key [fruit] by array iteration
    parser_test.go:18: asserting path [fruit name]
    parser_test.go:31: 	comparing key [fruit name] by string representation because it's of type string
    parser_test.go:18: asserting path [fruit physical]
    parser_test.go:28: 	comparing key [fruit physical] by subtree assestion
    parser_test.go:18: asserting path [fruit physical color]
    parser_test.go:31: 	comparing key [fruit physical color] by string representation because it's of type string
    parser_test.go:18: asserting path [fruit physical shape]
    parser_test.go:31: 	comparing key [fruit physical shape] by string representation because it's of type string
    parser_test.go:18: asserting path [fruit name]
    parser_test.go:31: 	comparing key [fruit name] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
--- PASS: TestParseKeyGroupArraySpec (0.00s)
=== RUN   TestTomlValueStringRepresentation
--- PASS: TestTomlValueStringRepresentation (0.00s)
=== RUN   TestToStringMapStringString
--- PASS: TestToStringMapStringString (0.00s)
=== RUN   TestDocumentPositions
--- PASS: TestDocumentPositions (0.00s)
=== RUN   TestDocumentPositionsWithSpaces
--- PASS: TestDocumentPositionsWithSpaces (0.00s)
=== RUN   TestDocumentPositionsWithGroupArray
--- PASS: TestDocumentPositionsWithGroupArray (0.00s)
=== RUN   TestNestedTreePosition
--- PASS: TestNestedTreePosition (0.00s)
=== RUN   TestInvalidGroupArray
--- PASS: TestInvalidGroupArray (0.00s)
=== RUN   TestDoubleEqual
--- PASS: TestDoubleEqual (0.00s)
=== RUN   TestGroupArrayReassign
--- PASS: TestGroupArrayReassign (0.00s)
=== RUN   TestInvalidFloatParsing
--- PASS: TestInvalidFloatParsing (0.00s)
=== RUN   TestMapKeyIsNum
--- PASS: TestMapKeyIsNum (0.00s)
=== RUN   TestInvalidKeyInlineTable
--- PASS: TestInvalidKeyInlineTable (0.00s)
=== RUN   TestDottedKeys
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003eb140)(name = "Orange"
        
        [physical]
          color = "orange"
          shape = "round"
        
        [site]
          "google.com" = true
        )
    parser_test.go:18: asserting path [name]
    parser_test.go:31: 	comparing key [name] by string representation because it's of type string
    parser_test.go:18: asserting path [physical]
    parser_test.go:28: 	comparing key [physical] by subtree assestion
    parser_test.go:18: asserting path [physical color]
    parser_test.go:31: 	comparing key [physical color] by string representation because it's of type string
    parser_test.go:18: asserting path [physical shape]
    parser_test.go:31: 	comparing key [physical shape] by string representation because it's of type string
    parser_test.go:18: asserting path [site]
    parser_test.go:28: 	comparing key [site] by subtree assestion
    parser_test.go:18: asserting path [site google.com]
    parser_test.go:31: 	comparing key [site google.com] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
--- PASS: TestDottedKeys (0.00s)
=== RUN   TestInvalidDottedKeyEmptyGroup
--- PASS: TestInvalidDottedKeyEmptyGroup (0.00s)
=== RUN   TestAccidentalNewlines
--- PASS: TestAccidentalNewlines (0.00s)
=== RUN   TestUint
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003eb4d0)(hello = 18446744073709551615
        )
    parser_test.go:18: asserting path [hello]
    parser_test.go:31: 	comparing key [hello] by string representation because it's of type uint64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestUint (0.00s)
=== RUN   TestPositionString
--- PASS: TestPositionString (0.00s)
=== RUN   TestInvalid
--- PASS: TestInvalid (0.00s)
=== RUN   TestTokenStringer
--- PASS: TestTokenStringer (0.00s)
=== RUN   TestTokenString
--- PASS: TestTokenString (0.00s)
=== RUN   TestTomlHas
--- PASS: TestTomlHas (0.00s)
=== RUN   TestTomlGet
--- PASS: TestTomlGet (0.00s)
=== RUN   TestTomlGetArray
--- PASS: TestTomlGetArray (0.00s)
=== RUN   TestTomlGetDefault
--- PASS: TestTomlGetDefault (0.00s)
=== RUN   TestTomlHasPath
--- PASS: TestTomlHasPath (0.00s)
=== RUN   TestTomlDelete
--- PASS: TestTomlDelete (0.00s)
=== RUN   TestTomlDeleteUnparsableKey
--- PASS: TestTomlDeleteUnparsableKey (0.00s)
=== RUN   TestTomlDeleteNestedKey
--- PASS: TestTomlDeleteNestedKey (0.00s)
=== RUN   TestTomlDeleteNonexistentNestedKey
--- PASS: TestTomlDeleteNonexistentNestedKey (0.00s)
=== RUN   TestTomlGetPath
--- PASS: TestTomlGetPath (0.00s)
=== RUN   TestTomlGetArrayPath
=== RUN   TestTomlGetArrayPath/empty
=== RUN   TestTomlGetArrayPath/int64
--- PASS: TestTomlGetArrayPath (0.00s)
    --- PASS: TestTomlGetArrayPath/empty (0.00s)
    --- PASS: TestTomlGetArrayPath/int64 (0.00s)
=== RUN   TestTomlFromMap
--- PASS: TestTomlFromMap (0.00s)
=== RUN   TestLoadBytesBOM
--- PASS: TestLoadBytesBOM (0.00s)
=== RUN   TestInvalidDatetimeMalformedNoLeads
    toml_testgen_support_test.go:14: Input TOML:
        no-leads = 1987-7-05T17:45:00Z
--- PASS: TestInvalidDatetimeMalformedNoLeads (0.00s)
=== RUN   TestInvalidDatetimeMalformedNoSecs
    toml_testgen_support_test.go:14: Input TOML:
        no-secs = 1987-07-05T17:45Z
--- PASS: TestInvalidDatetimeMalformedNoSecs (0.00s)
=== RUN   TestInvalidDatetimeMalformedNoT
    toml_testgen_support_test.go:14: Input TOML:
        no-t = 1987-07-0517:45:00Z
--- PASS: TestInvalidDatetimeMalformedNoT (0.00s)
=== RUN   TestInvalidDatetimeMalformedWithMilli
    toml_testgen_support_test.go:14: Input TOML:
        with-milli = 1987-07-5T17:45:00.12Z
--- PASS: TestInvalidDatetimeMalformedWithMilli (0.00s)
=== RUN   TestInvalidDuplicateKeyTable
    toml_testgen_support_test.go:14: Input TOML:
        [fruit]
        type = "apple"
        
        [fruit.type]
        apple = "yes"
--- PASS: TestInvalidDuplicateKeyTable (0.00s)
=== RUN   TestInvalidDuplicateKeys
    toml_testgen_support_test.go:14: Input TOML:
        dupe = false
        dupe = true
--- PASS: TestInvalidDuplicateKeys (0.00s)
=== RUN   TestInvalidDuplicateTables
    toml_testgen_support_test.go:14: Input TOML:
        [a]
        [a]
--- PASS: TestInvalidDuplicateTables (0.00s)
=== RUN   TestInvalidEmptyImplicitTable
    toml_testgen_support_test.go:14: Input TOML:
        [naughty..naughty]
--- PASS: TestInvalidEmptyImplicitTable (0.00s)
=== RUN   TestInvalidEmptyTable
    toml_testgen_support_test.go:14: Input TOML:
        []
--- PASS: TestInvalidEmptyTable (0.00s)
=== RUN   TestInvalidFloatNoLeadingZero
    toml_testgen_support_test.go:14: Input TOML:
        answer = .12345
        neganswer = -.12345
--- PASS: TestInvalidFloatNoLeadingZero (0.00s)
=== RUN   TestInvalidFloatNoTrailingDigits
    toml_testgen_support_test.go:14: Input TOML:
        answer = 1.
        neganswer = -1.
--- PASS: TestInvalidFloatNoTrailingDigits (0.00s)
=== RUN   TestInvalidKeyEmpty
    toml_testgen_support_test.go:14: Input TOML:
         = 1
--- PASS: TestInvalidKeyEmpty (0.00s)
=== RUN   TestInvalidKeyHash
    toml_testgen_support_test.go:14: Input TOML:
        a# = 1
--- PASS: TestInvalidKeyHash (0.00s)
=== RUN   TestInvalidKeyNewline
    toml_testgen_support_test.go:14: Input TOML:
        a
        = 1
--- PASS: TestInvalidKeyNewline (0.00s)
=== RUN   TestInvalidKeyOpenBracket
    toml_testgen_support_test.go:14: Input TOML:
        [abc = 1
--- PASS: TestInvalidKeyOpenBracket (0.00s)
=== RUN   TestInvalidKeySingleOpenBracket
    toml_testgen_support_test.go:14: Input TOML:
        [
--- PASS: TestInvalidKeySingleOpenBracket (0.00s)
=== RUN   TestInvalidKeySpace
    toml_testgen_support_test.go:14: Input TOML:
        a b = 1
--- PASS: TestInvalidKeySpace (0.00s)
=== RUN   TestInvalidKeyStartBracket
    toml_testgen_support_test.go:14: Input TOML:
        [a]
        [xyz = 5
        [b]
--- PASS: TestInvalidKeyStartBracket (0.00s)
=== RUN   TestInvalidKeyTwoEquals
    toml_testgen_support_test.go:14: Input TOML:
        key= = 1
--- PASS: TestInvalidKeyTwoEquals (0.00s)
=== RUN   TestInvalidStringBadByteEscape
    toml_testgen_support_test.go:14: Input TOML:
        naughty = "\xAg"
--- PASS: TestInvalidStringBadByteEscape (0.00s)
=== RUN   TestInvalidStringBadEscape
    toml_testgen_support_test.go:14: Input TOML:
        invalid-escape = "This string has a bad \a escape character."
--- PASS: TestInvalidStringBadEscape (0.00s)
=== RUN   TestInvalidStringByteEscapes
    toml_testgen_support_test.go:14: Input TOML:
        answer = "\x33"
--- PASS: TestInvalidStringByteEscapes (0.00s)
=== RUN   TestInvalidStringNoClose
    toml_testgen_support_test.go:14: Input TOML:
        no-ending-quote = "One time, at band camp
--- PASS: TestInvalidStringNoClose (0.00s)
=== RUN   TestInvalidTableArrayImplicit
    toml_testgen_support_test.go:14: Input TOML:
        # This test is a bit tricky. It should fail because the first use of
        # `[[albums.songs]]` without first declaring `albums` implies that `albums`
        # must be a table. The alternative would be quite weird. Namely, it wouldn't
        # comply with the TOML spec: "Each double-bracketed sub-table will belong to 
        # the most *recently* defined table element *above* it."
        #
        # This is in contrast to the *valid* test, table-array-implicit where
        # `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared
        # later. (Although, `[albums]` could be.)
        [[albums.songs]]
        name = "Glory Days"
        
        [[albums]]
        name = "Born in the USA"
--- PASS: TestInvalidTableArrayImplicit (0.00s)
=== RUN   TestInvalidTableArrayMalformedBracket
    toml_testgen_support_test.go:14: Input TOML:
        [[albums]
        name = "Born to Run"
--- PASS: TestInvalidTableArrayMalformedBracket (0.00s)
=== RUN   TestInvalidTableArrayMalformedEmpty
    toml_testgen_support_test.go:14: Input TOML:
        [[]]
        name = "Born to Run"
--- PASS: TestInvalidTableArrayMalformedEmpty (0.00s)
=== RUN   TestInvalidTableEmpty
    toml_testgen_support_test.go:14: Input TOML:
        []
--- PASS: TestInvalidTableEmpty (0.00s)
=== RUN   TestInvalidTableNestedBracketsClose
    toml_testgen_support_test.go:14: Input TOML:
        [a]b]
        zyx = 42
--- PASS: TestInvalidTableNestedBracketsClose (0.00s)
=== RUN   TestInvalidTableNestedBracketsOpen
    toml_testgen_support_test.go:14: Input TOML:
        [a[b]
        zyx = 42
--- PASS: TestInvalidTableNestedBracketsOpen (0.00s)
=== RUN   TestInvalidTableWhitespace
    toml_testgen_support_test.go:14: Input TOML:
        [invalid key]
--- PASS: TestInvalidTableWhitespace (0.00s)
=== RUN   TestInvalidTableWithPound
    toml_testgen_support_test.go:14: Input TOML:
        [key#group]
        answer = 42
--- PASS: TestInvalidTableWithPound (0.00s)
=== RUN   TestInvalidTextAfterArrayEntries
    toml_testgen_support_test.go:14: Input TOML:
        array = [
          "Is there life after an array separator?", No
          "Entry"
        ]
--- PASS: TestInvalidTextAfterArrayEntries (0.00s)
=== RUN   TestInvalidTextAfterInteger
    toml_testgen_support_test.go:14: Input TOML:
        answer = 42 the ultimate answer?
--- PASS: TestInvalidTextAfterInteger (0.00s)
=== RUN   TestInvalidTextAfterString
    toml_testgen_support_test.go:14: Input TOML:
        string = "Is there life after strings?" No.
--- PASS: TestInvalidTextAfterString (0.00s)
=== RUN   TestInvalidTextAfterTable
    toml_testgen_support_test.go:14: Input TOML:
        [error] this shouldn't be here
--- PASS: TestInvalidTextAfterTable (0.00s)
=== RUN   TestInvalidTextBeforeArraySeparator
    toml_testgen_support_test.go:14: Input TOML:
        array = [
          "Is there life before an array separator?" No,
          "Entry"
        ]
--- PASS: TestInvalidTextBeforeArraySeparator (0.00s)
=== RUN   TestInvalidTextInArray
    toml_testgen_support_test.go:14: Input TOML:
        array = [
          "Entry 1",
          I don't belong,
          "Entry 2",
        ]
--- PASS: TestInvalidTextInArray (0.00s)
=== RUN   TestValidArrayEmpty
    toml_testgen_support_test.go:31: Input TOML:
        thevoid = [[[[[]]]]]
--- PASS: TestValidArrayEmpty (0.00s)
=== RUN   TestValidArrayNospaces
    toml_testgen_support_test.go:31: Input TOML:
        ints = [1,2,3]
--- PASS: TestValidArrayNospaces (0.00s)
=== RUN   TestValidArraysHetergeneous
    toml_testgen_support_test.go:31: Input TOML:
        mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]
--- PASS: TestValidArraysHetergeneous (0.00s)
=== RUN   TestValidArraysNested
    toml_testgen_support_test.go:31: Input TOML:
        nest = [["a"], ["b"]]
--- PASS: TestValidArraysNested (0.00s)
=== RUN   TestValidArrays
    toml_testgen_support_test.go:31: Input TOML:
        ints = [1, 2, 3]
        floats = [1.1, 2.1, 3.1]
        strings = ["a", "b", "c"]
        dates = [
          1987-07-05T17:45:00Z,
          1979-05-27T07:32:00Z,
          2006-06-01T11:00:00Z,
        ]
--- PASS: TestValidArrays (0.00s)
=== RUN   TestValidBool
    toml_testgen_support_test.go:31: Input TOML:
        t = true
        f = false
--- PASS: TestValidBool (0.00s)
=== RUN   TestValidCommentsEverywhere
    toml_testgen_support_test.go:31: Input TOML:
        # Top comment.
          # Top comment.
        # Top comment.
        
        # [no-extraneous-groups-please]
        
        [group] # Comment
        answer = 42 # Comment
        # no-extraneous-keys-please = 999
        # Inbetween comment.
        more = [ # Comment
          # What about multiple # comments?
          # Can you handle it?
          #
                  # Evil.
        # Evil.
          42, 42, # Comments within arrays are fun.
          # What about multiple # comments?
          # Can you handle it?
          #
                  # Evil.
        # Evil.
        # ] Did I fool you?
        ] # Hopefully not.
--- PASS: TestValidCommentsEverywhere (0.00s)
=== RUN   TestValidDatetime
    toml_testgen_support_test.go:31: Input TOML:
        bestdayever = 1987-07-05T17:45:00Z
--- PASS: TestValidDatetime (0.00s)
=== RUN   TestValidEmpty
    toml_testgen_support_test.go:31: Input TOML:
--- PASS: TestValidEmpty (0.00s)
=== RUN   TestValidExample
    toml_testgen_support_test.go:31: Input TOML:
        best-day-ever = 1987-07-05T17:45:00Z
        
        [numtheory]
        boring = false
        perfection = [6, 28, 496]
--- PASS: TestValidExample (0.00s)
=== RUN   TestValidFloat
    toml_testgen_support_test.go:31: Input TOML:
        pi = 3.14
        negpi = -3.14
--- PASS: TestValidFloat (0.00s)
=== RUN   TestValidImplicitAndExplicitAfter
    toml_testgen_support_test.go:31: Input TOML:
        [a.b.c]
        answer = 42
        
        [a]
        better = 43
--- PASS: TestValidImplicitAndExplicitAfter (0.00s)
=== RUN   TestValidImplicitAndExplicitBefore
    toml_testgen_support_test.go:31: Input TOML:
        [a]
        better = 43
        
        [a.b.c]
        answer = 42
--- PASS: TestValidImplicitAndExplicitBefore (0.00s)
=== RUN   TestValidImplicitGroups
    toml_testgen_support_test.go:31: Input TOML:
        [a.b.c]
        answer = 42
--- PASS: TestValidImplicitGroups (0.00s)
=== RUN   TestValidInteger
    toml_testgen_support_test.go:31: Input TOML:
        answer = 42
        neganswer = -42
--- PASS: TestValidInteger (0.00s)
=== RUN   TestValidKeyEqualsNospace
    toml_testgen_support_test.go:31: Input TOML:
        answer=42
--- PASS: TestValidKeyEqualsNospace (0.00s)
=== RUN   TestValidKeySpace
    toml_testgen_support_test.go:31: Input TOML:
        "a b" = 1
--- PASS: TestValidKeySpace (0.00s)
=== RUN   TestValidKeySpecialChars
    toml_testgen_support_test.go:31: Input TOML:
        "~!@$^&*()_+-`1234567890[]|/?><.,;:'" = 1
--- PASS: TestValidKeySpecialChars (0.00s)
=== RUN   TestValidLongFloat
    toml_testgen_support_test.go:31: Input TOML:
        longpi = 3.141592653589793
        neglongpi = -3.141592653589793
--- PASS: TestValidLongFloat (0.00s)
=== RUN   TestValidLongInteger
    toml_testgen_support_test.go:31: Input TOML:
        answer = 9223372036854775807
        neganswer = -9223372036854775808
--- PASS: TestValidLongInteger (0.00s)
=== RUN   TestValidMultilineString
    toml_testgen_support_test.go:31: Input TOML:
        multiline_empty_one = """"""
        multiline_empty_two = """
        """
        multiline_empty_three = """\
            """
        multiline_empty_four = """\
           \
           \
           """
        
        equivalent_one = "The quick brown fox jumps over the lazy dog."
        equivalent_two = """
        The quick brown \
        
        
          fox jumps over \
            the lazy dog."""
        
        equivalent_three = """\
               The quick brown \
               fox jumps over \
               the lazy dog.\
               """
--- PASS: TestValidMultilineString (0.00s)
=== RUN   TestValidRawMultilineString
    toml_testgen_support_test.go:31: Input TOML:
        oneline = '''This string has a ' quote character.'''
        firstnl = '''
        This string has a ' quote character.'''
        multiline = '''
        This string
        has ' a quote character
        and more than
        one newline
        in it.'''
--- PASS: TestValidRawMultilineString (0.00s)
=== RUN   TestValidRawString
    toml_testgen_support_test.go:31: Input TOML:
        backspace = 'This string has a \b backspace character.'
        tab = 'This string has a \t tab character.'
        newline = 'This string has a \n new line character.'
        formfeed = 'This string has a \f form feed character.'
        carriage = 'This string has a \r carriage return character.'
        slash = 'This string has a \/ slash character.'
        backslash = 'This string has a \\ backslash character.'
--- PASS: TestValidRawString (0.00s)
=== RUN   TestValidStringEmpty
    toml_testgen_support_test.go:31: Input TOML:
        answer = ""
--- PASS: TestValidStringEmpty (0.00s)
=== RUN   TestValidStringEscapes
    toml_testgen_support_test.go:31: Input TOML:
        backspace = "This string has a \b backspace character."
        tab = "This string has a \t tab character."
        newline = "This string has a \n new line character."
        formfeed = "This string has a \f form feed character."
        carriage = "This string has a \r carriage return character."
        quote = "This string has a \" quote character."
        backslash = "This string has a \\ backslash character."
        notunicode1 = "This string does not have a unicode \\u escape."
        notunicode2 = "This string does not have a unicode \u005Cu escape."
        notunicode3 = "This string does not have a unicode \\u0075 escape."
        notunicode4 = "This string does not have a unicode \\\u0075 escape."
--- PASS: TestValidStringEscapes (0.00s)
=== RUN   TestValidStringSimple
    toml_testgen_support_test.go:31: Input TOML:
        answer = "You are not drinking enough whisky."
--- PASS: TestValidStringSimple (0.00s)
=== RUN   TestValidStringWithPound
    toml_testgen_support_test.go:31: Input TOML:
        pound = "We see no # comments here."
        poundcomment = "But there are # some comments here." # Did I # mess you up?
--- PASS: TestValidStringWithPound (0.00s)
=== RUN   TestValidTableArrayImplicit
    toml_testgen_support_test.go:31: Input TOML:
        [[albums.songs]]
        name = "Glory Days"
--- PASS: TestValidTableArrayImplicit (0.00s)
=== RUN   TestValidTableArrayMany
    toml_testgen_support_test.go:31: Input TOML:
        [[people]]
        first_name = "Bruce"
        last_name = "Springsteen"
        
        [[people]]
        first_name = "Eric"
        last_name = "Clapton"
        
        [[people]]
        first_name = "Bob"
        last_name = "Seger"
--- PASS: TestValidTableArrayMany (0.00s)
=== RUN   TestValidTableArrayNest
    toml_testgen_support_test.go:31: Input TOML:
        [[albums]]
        name = "Born to Run"
        
          [[albums.songs]]
          name = "Jungleland"
        
          [[albums.songs]]
          name = "Meeting Across the River"
        
        [[albums]]
        name = "Born in the USA"
          
          [[albums.songs]]
          name = "Glory Days"
        
          [[albums.songs]]
          name = "Dancing in the Dark"
--- PASS: TestValidTableArrayNest (0.00s)
=== RUN   TestValidTableArrayOne
    toml_testgen_support_test.go:31: Input TOML:
        [[people]]
        first_name = "Bruce"
        last_name = "Springsteen"
--- PASS: TestValidTableArrayOne (0.00s)
=== RUN   TestValidTableEmpty
    toml_testgen_support_test.go:31: Input TOML:
        [a]
--- PASS: TestValidTableEmpty (0.00s)
=== RUN   TestValidTableSubEmpty
    toml_testgen_support_test.go:31: Input TOML:
        [a]
        [a.b]
--- PASS: TestValidTableSubEmpty (0.00s)
=== RUN   TestValidTableWhitespace
    toml_testgen_support_test.go:31: Input TOML:
        ["valid key"]
--- PASS: TestValidTableWhitespace (0.00s)
=== RUN   TestValidTableWithPound
    toml_testgen_support_test.go:31: Input TOML:
        ["key#group"]
        answer = 42
--- PASS: TestValidTableWithPound (0.00s)
=== RUN   TestValidUnicodeEscape
    toml_testgen_support_test.go:31: Input TOML:
        answer4 = "\u03B4"
        answer8 = "\U000003B4"
--- PASS: TestValidUnicodeEscape (0.00s)
=== RUN   TestValidUnicodeLiteral
    toml_testgen_support_test.go:31: Input TOML:
        answer = "δ"
--- PASS: TestValidUnicodeLiteral (0.00s)
=== RUN   TestTreeCreateToTree
    tomltree_create_test.go:38: validation ok .custom_string_map_key.custom as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .custom_string_map_key as *toml.Tree
    tomltree_create_test.go:38: validation ok .nested.foo as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .nested as *toml.Tree
    tomltree_create_test.go:38: validation ok .array_times as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .array as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .stringer as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .float32 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .int32 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .uint8 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .int8 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .uint32 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .a_string as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .time as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .int16 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .array_uint as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .array_table.0.sub_map as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .array_table.0 as *toml.Tree
    tomltree_create_test.go:38: validation ok .array_table as []*toml.Tree
    tomltree_create_test.go:38: validation ok .map_times.now as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .map_times as *toml.Tree
    tomltree_create_test.go:38: validation ok .uint16 as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .a_bool as *toml.tomlValue
    tomltree_create_test.go:38: validation ok .an_int as *toml.tomlValue
    tomltree_create_test.go:38: validation ok  as *toml.Tree
--- PASS: TestTreeCreateToTree (0.00s)
=== RUN   TestTreeCreateToTreeInvalidLeafType
--- PASS: TestTreeCreateToTreeInvalidLeafType (0.00s)
=== RUN   TestTreeCreateToTreeInvalidMapKeyType
--- PASS: TestTreeCreateToTreeInvalidMapKeyType (0.00s)
=== RUN   TestTreeCreateToTreeInvalidArrayMemberType
--- PASS: TestTreeCreateToTreeInvalidArrayMemberType (0.00s)
=== RUN   TestTreeCreateToTreeInvalidTableGroupType
--- PASS: TestTreeCreateToTreeInvalidTableGroupType (0.00s)
=== RUN   TestRoundTripArrayOfTables
--- PASS: TestRoundTripArrayOfTables (0.00s)
=== RUN   TestTomlSliceOfSlice
--- PASS: TestTomlSliceOfSlice (0.00s)
=== RUN   TestTomlSliceOfSliceOfSlice
--- PASS: TestTomlSliceOfSliceOfSlice (0.00s)
=== RUN   TestTomlSliceOfSliceInt
--- PASS: TestTomlSliceOfSliceInt (0.00s)
=== RUN   TestTomlSliceOfSliceInt64
--- PASS: TestTomlSliceOfSliceInt64 (0.00s)
=== RUN   TestTomlSliceOfSliceInt64FromMap
--- PASS: TestTomlSliceOfSliceInt64FromMap (0.00s)
=== RUN   TestTomlSliceOfSliceError
--- PASS: TestTomlSliceOfSliceError (0.00s)
=== RUN   TestTreeWriteToEmptyTable
--- PASS: TestTreeWriteToEmptyTable (0.00s)
=== RUN   TestTreeWriteToTomlString
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021e9f0)(
        [name]
          first = "Tom"
          last = "Preston-Werner"
        
        [points]
          x = 1
          y = 2
        )
    parser_test.go:18: asserting path [name]
    parser_test.go:28: 	comparing key [name] by subtree assestion
    parser_test.go:18: asserting path [name first]
    parser_test.go:31: 	comparing key [name first] by string representation because it's of type string
    parser_test.go:18: asserting path [name last]
    parser_test.go:31: 	comparing key [name last] by string representation because it's of type string
    parser_test.go:18: asserting path [points]
    parser_test.go:28: 	comparing key [points] by subtree assestion
    parser_test.go:18: asserting path [points x]
    parser_test.go:31: 	comparing key [points x] by string representation because it's of type int64
    parser_test.go:18: asserting path [points y]
    parser_test.go:31: 	comparing key [points y] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestTreeWriteToTomlString (0.00s)
=== RUN   TestTreeWriteToTomlStringSimple
--- PASS: TestTreeWriteToTomlStringSimple (0.00s)
=== RUN   TestTreeWriteToTomlStringKeysOrders
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021eff0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021f2c0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021f590)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021f860)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021fb30)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021fe00)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c8150)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c8420)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c86f0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c89c0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c8c90)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c8f60)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c9230)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c9500)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c97d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c9aa0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40002c9d70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034c0c0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034c390)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034c660)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034c930)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034cc00)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034ced0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034d1a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034d470)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034d740)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034da10)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400034dce0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6030)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6300)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d65d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d68a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d61b0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6480)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6750)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6ba0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d6e70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d7140)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d7410)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d76e0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d79b0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d7c80)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003d7f50)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000092c00)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000092ed0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40000931d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40000934a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000093770)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000093a40)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000093d10)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045e060)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045e330)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045e600)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045e8d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045eba0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045ee70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045f1a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045f470)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045f740)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045fa10)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400045fce0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000128030)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000128300)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000128600)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40001288d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000128ba0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000128e70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000129140)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000129410)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40001296e0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40001299b0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000129c80)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000129f50)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003be300)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003be600)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003be8d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bec00)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003beed0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bf1a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bf470)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bf740)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bfa10)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40003bfce0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470030)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470300)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004705d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004708a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470b70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000470e40)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471110)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004713e0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004716b0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x40004719b0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x4000471cb0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021e000)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021e2d0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021e5a0)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021e870)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021eb40)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:42: Finished tree assertion.
    tomltree_write_test.go:118: Intermediate string representation:
    tomltree_write_test.go:119: bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        
    parser_test.go:40: Asserting tree:
         (*toml.Tree)(0x400021ee70)(bar = "baz"
        foo = 1
        foobar = true
        
        [qux]
          bar = "baz2"
          foo = 1
        )
    parser_test.go:18: asserting path [qux]
    parser_test.go:28: 	comparing key [qux] by subtree assestion
    parser_test.go:18: asserting path [qux foo]
    parser_test.go:31: 	comparing key [qux foo] by string representation because it's of type int64
    parser_test.go:18: asserting path [qux bar]
    parser_test.go:31: 	comparing key [qux bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foobar]
    parser_test.go:31: 	comparing key [foobar] by string representation because it's of type bool
    parser_test.go:18: asserting path [bar]
    parser_test.go:31: 	comparing key [bar] by string representation because it's of type string
    parser_test.go:18: asserting path [foo]
    parser_test.go:31: 	comparing key [foo] by string representation because it's of type int64
    parser_test.go:42: Finished tree assertion.
--- PASS: TestTreeWriteToTomlStringKeysOrders (0.03s)
=== RUN   TestTreeWriteToMapSimple
--- PASS: TestTreeWriteToMapSimple (0.00s)
=== RUN   TestTreeWriteToInvalidTreeSimpleValue
--- PASS: TestTreeWriteToInvalidTreeSimpleValue (0.00s)
=== RUN   TestTreeWriteToInvalidTreeTomlValue
--- PASS: TestTreeWriteToInvalidTreeTomlValue (0.00s)
=== RUN   TestTreeWriteToInvalidTreeTomlValueArray
--- PASS: TestTreeWriteToInvalidTreeTomlValueArray (0.00s)
=== RUN   TestTreeWriteToFailingWriterInSimpleValue
--- PASS: TestTreeWriteToFailingWriterInSimpleValue (0.00s)
=== RUN   TestTreeWriteToFailingWriterInTable
--- PASS: TestTreeWriteToFailingWriterInTable (0.00s)
=== RUN   TestTreeWriteToFailingWriterInArray
--- PASS: TestTreeWriteToFailingWriterInArray (0.00s)
=== RUN   TestTreeWriteToMapExampleFile
--- PASS: TestTreeWriteToMapExampleFile (0.00s)
=== RUN   TestTreeWriteToMapWithTablesInMultipleChunks
--- PASS: TestTreeWriteToMapWithTablesInMultipleChunks (0.00s)
=== RUN   TestTreeWriteToMapWithArrayOfInlineTables
--- PASS: TestTreeWriteToMapWithArrayOfInlineTables (0.00s)
=== RUN   TestTreeWriteToMapWithTableInMixedArray
--- PASS: TestTreeWriteToMapWithTableInMixedArray (0.00s)
=== RUN   TestTreeWriteToFloat
--- PASS: TestTreeWriteToFloat (0.00s)
=== RUN   TestTreeWriteToSpecialFloat
--- PASS: TestTreeWriteToSpecialFloat (0.00s)
=== RUN   TestOrderedEmptyTrees
--- PASS: TestOrderedEmptyTrees (0.00s)
=== RUN   TestOrderedNonIncreasedLine
--- PASS: TestOrderedNonIncreasedLine (0.00s)
=== RUN   TestIssue290
--- PASS: TestIssue290 (0.00s)
=== RUN   Example_unmarshal
--- PASS: Example_unmarshal (0.00s)
=== RUN   ExampleMarshal
--- PASS: ExampleMarshal (0.00s)
=== RUN   ExampleUnmarshal
--- PASS: ExampleUnmarshal (0.00s)
=== RUN   ExampleEncoder_anonymous
--- PASS: ExampleEncoder_anonymous (0.00s)
PASS
ok  	github.com/pelletier/go-toml	0.111s
testing: warning: no tests to run
PASS
ok  	github.com/pelletier/go-toml/benchmark	0.014s [no tests to run]
=== RUN   TestProcessMainReadFromStdin
--- PASS: TestProcessMainReadFromStdin (0.00s)
=== RUN   TestProcessMainReadFromFile
--- PASS: TestProcessMainReadFromFile (0.00s)
=== RUN   TestProcessMainReadFromMissingFile
--- PASS: TestProcessMainReadFromMissingFile (0.00s)
PASS
ok  	github.com/pelletier/go-toml/cmd/jsontoml	0.014s
=== RUN   TestProcessMainReadFromStdin
--- PASS: TestProcessMainReadFromStdin (0.00s)
=== RUN   TestProcessMainReadFromFile
--- PASS: TestProcessMainReadFromFile (0.00s)
=== RUN   TestProcessMainReadFromMissingFile
--- PASS: TestProcessMainReadFromMissingFile (0.00s)
PASS
ok  	github.com/pelletier/go-toml/cmd/tomljson	0.011s
=== RUN   TestLexSpecialChars
--- PASS: TestLexSpecialChars (0.00s)
=== RUN   TestLexString
--- PASS: TestLexString (0.00s)
=== RUN   TestLexDoubleString
--- PASS: TestLexDoubleString (0.00s)
=== RUN   TestLexStringEscapes
--- PASS: TestLexStringEscapes (0.00s)
=== RUN   TestLexStringUnfinishedUnicode4
--- PASS: TestLexStringUnfinishedUnicode4 (0.00s)
=== RUN   TestLexStringUnfinishedUnicode8
--- PASS: TestLexStringUnfinishedUnicode8 (0.00s)
=== RUN   TestLexStringInvalidEscape
--- PASS: TestLexStringInvalidEscape (0.00s)
=== RUN   TestLexStringUnfinished
--- PASS: TestLexStringUnfinished (0.00s)
=== RUN   TestLexKey
--- PASS: TestLexKey (0.00s)
=== RUN   TestLexRecurse
--- PASS: TestLexRecurse (0.00s)
=== RUN   TestLexBracketKey
--- PASS: TestLexBracketKey (0.00s)
=== RUN   TestLexSpace
--- PASS: TestLexSpace (0.00s)
=== RUN   TestLexInteger
--- PASS: TestLexInteger (0.00s)
=== RUN   TestLexFloat
--- PASS: TestLexFloat (0.00s)
=== RUN   TestLexFloatWithMultipleDots
--- PASS: TestLexFloatWithMultipleDots (0.00s)
=== RUN   TestLexFloatLeadingDot
--- PASS: TestLexFloatLeadingDot (0.00s)
=== RUN   TestLexFloatWithTrailingDot
--- PASS: TestLexFloatWithTrailingDot (0.00s)
=== RUN   TestLexNumberWithoutDigit
--- PASS: TestLexNumberWithoutDigit (0.00s)
=== RUN   TestLexUnknown
--- PASS: TestLexUnknown (0.00s)
=== RUN   TestPathRoot
--- PASS: TestPathRoot (0.00s)
=== RUN   TestPathKey
--- PASS: TestPathKey (0.00s)
=== RUN   TestPathBracketKey
--- PASS: TestPathBracketKey (0.00s)
=== RUN   TestPathBracketStringKey
--- PASS: TestPathBracketStringKey (0.00s)
=== RUN   TestPathIndex
--- PASS: TestPathIndex (0.00s)
=== RUN   TestPathSliceStart
--- PASS: TestPathSliceStart (0.00s)
=== RUN   TestPathSliceStartEnd
--- PASS: TestPathSliceStartEnd (0.00s)
=== RUN   TestPathSliceStartEndColon
--- PASS: TestPathSliceStartEndColon (0.00s)
=== RUN   TestPathSliceStartStep
--- PASS: TestPathSliceStartStep (0.00s)
=== RUN   TestPathSliceEndStep
--- PASS: TestPathSliceEndStep (0.00s)
=== RUN   TestPathSliceStep
--- PASS: TestPathSliceStep (0.00s)
=== RUN   TestPathSliceAll
--- PASS: TestPathSliceAll (0.00s)
=== RUN   TestPathAny
--- PASS: TestPathAny (0.00s)
=== RUN   TestPathUnion
--- PASS: TestPathUnion (0.00s)
=== RUN   TestPathRecurse
--- PASS: TestPathRecurse (0.00s)
=== RUN   TestPathFilterExpr
--- PASS: TestPathFilterExpr (0.00s)
=== RUN   TestQueryRoot
--- PASS: TestQueryRoot (0.00s)
=== RUN   TestQueryKey
--- PASS: TestQueryKey (0.00s)
=== RUN   TestQueryKeyString
--- PASS: TestQueryKeyString (0.00s)
=== RUN   TestQueryKeyUnicodeString
--- PASS: TestQueryKeyUnicodeString (0.00s)
=== RUN   TestQueryIndexError1
--- PASS: TestQueryIndexError1 (0.00s)
=== RUN   TestQueryIndexError2
--- PASS: TestQueryIndexError2 (0.00s)
=== RUN   TestQueryIndex
--- PASS: TestQueryIndex (0.00s)
=== RUN   TestQueryIndexNegative
--- PASS: TestQueryIndexNegative (0.00s)
=== RUN   TestQueryIndexWrong
--- PASS: TestQueryIndexWrong (0.00s)
=== RUN   TestQueryIndexEmpty
--- PASS: TestQueryIndexEmpty (0.00s)
=== RUN   TestQueryIndexTree
--- PASS: TestQueryIndexTree (0.00s)
=== RUN   TestQuerySliceError1
--- PASS: TestQuerySliceError1 (0.00s)
=== RUN   TestQuerySliceError2
--- PASS: TestQuerySliceError2 (0.00s)
=== RUN   TestQuerySliceError3
--- PASS: TestQuerySliceError3 (0.00s)
=== RUN   TestQuerySliceRange
--- PASS: TestQuerySliceRange (0.00s)
=== RUN   TestQuerySliceStep
--- PASS: TestQuerySliceStep (0.00s)
=== RUN   TestQuerySliceStartNegative
--- PASS: TestQuerySliceStartNegative (0.00s)
=== RUN   TestQuerySliceEndNegative
--- PASS: TestQuerySliceEndNegative (0.00s)
=== RUN   TestQuerySliceStepNegative
--- PASS: TestQuerySliceStepNegative (0.00s)
=== RUN   TestQuerySliceStartOverRange
--- PASS: TestQuerySliceStartOverRange (0.00s)
=== RUN   TestQuerySliceStartOverRangeNegative
--- PASS: TestQuerySliceStartOverRangeNegative (0.00s)
=== RUN   TestQuerySliceEndOverRange
--- PASS: TestQuerySliceEndOverRange (0.00s)
=== RUN   TestQuerySliceEndOverRangeNegative
--- PASS: TestQuerySliceEndOverRangeNegative (0.00s)
=== RUN   TestQuerySliceWrongRange
--- PASS: TestQuerySliceWrongRange (0.00s)
=== RUN   TestQuerySliceWrongRangeNegative
--- PASS: TestQuerySliceWrongRangeNegative (0.00s)
=== RUN   TestQuerySliceEmpty
--- PASS: TestQuerySliceEmpty (0.00s)
=== RUN   TestQuerySliceTree
--- PASS: TestQuerySliceTree (0.00s)
=== RUN   TestQueryAny
--- PASS: TestQueryAny (0.00s)
=== RUN   TestQueryUnionSimple
--- PASS: TestQueryUnionSimple (0.00s)
=== RUN   TestQueryRecursionAll
--- PASS: TestQueryRecursionAll (0.00s)
=== RUN   TestQueryRecursionUnionSimple
--- PASS: TestQueryRecursionUnionSimple (0.00s)
=== RUN   TestQueryFilterFn
--- PASS: TestQueryFilterFn (0.00s)
=== RUN   TestQueryExample
--- PASS: TestQueryExample (0.00s)
=== RUN   TestQueryReadmeExample
--- PASS: TestQueryReadmeExample (0.00s)
=== RUN   TestQueryPathNotPresent
--- PASS: TestQueryPathNotPresent (0.00s)
=== RUN   TestTomlQuery
--- PASS: TestTomlQuery (0.00s)
PASS
ok  	github.com/pelletier/go-toml/query	0.018s
   create-stamp debian/debhelper-build-stamp
   dh_testroot -O--buildsystem=golang
   dh_prep -O--buildsystem=golang
   dh_auto_install -O--buildsystem=golang
	cd obj-aarch64-linux-gnu && mkdir -p /build/reproducible-path/golang-github-pelletier-go-toml-1.9.5/debian/tmp/usr
	cd obj-aarch64-linux-gnu && cp -r bin /build/reproducible-path/golang-github-pelletier-go-toml-1.9.5/debian/tmp/usr
   dh_install -O--buildsystem=golang
   dh_installdocs -O--buildsystem=golang
   dh_installchangelogs -O--buildsystem=golang
   dh_installman -O--buildsystem=golang
   dh_installsystemduser -O--buildsystem=golang
   dh_perl -O--buildsystem=golang
   dh_link -O--buildsystem=golang
   dh_strip_nondeterminism -O--buildsystem=golang
   dh_compress -O--buildsystem=golang
   dh_fixperms -O--buildsystem=golang
   dh_missing -O--buildsystem=golang
   dh_strip -a -O--buildsystem=golang
dh_strip: warning: Could not find the BuildID in debian/golang-github-pelletier-go-toml/usr/bin/tomll
dh_strip: warning: Could not find the BuildID in debian/golang-github-pelletier-go-toml/usr/bin/jsontoml
dh_strip: warning: Could not find the BuildID in debian/golang-github-pelletier-go-toml/usr/bin/tomljson
   dh_makeshlibs -a -O--buildsystem=golang
   dh_shlibdeps -a -O--buildsystem=golang
   dh_installdeb -O--buildsystem=golang
   dh_golang -O--buildsystem=golang
   dh_gencontrol -O--buildsystem=golang
dpkg-gencontrol: warning: Depends field of package golang-github-pelletier-go-toml: substitution variable ${shlibs:Depends} used, but is not defined
   dh_md5sums -O--buildsystem=golang
   dh_builddeb -O--buildsystem=golang
dpkg-deb: building package 'golang-github-pelletier-go-toml-dev' in '../golang-github-pelletier-go-toml-dev_1.9.5-1_all.deb'.
dpkg-deb: building package 'golang-github-pelletier-go-toml' in '../golang-github-pelletier-go-toml_1.9.5-1_arm64.deb'.
 dpkg-genbuildinfo --build=binary -O../golang-github-pelletier-go-toml_1.9.5-1_arm64.buildinfo
 dpkg-genchanges --build=binary -O../golang-github-pelletier-go-toml_1.9.5-1_arm64.changes
dpkg-genchanges: info: binary-only upload (no source code included)
 dpkg-source --after-build .
dpkg-buildpackage: info: binary-only upload (no source included)
dpkg-genchanges: info: including full source code in upload
I: copying local configuration
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/B01_cleanup starting
I: user script /srv/workspace/pbuilder/3681646/tmp/hooks/B01_cleanup finished
I: unmounting dev/ptmx filesystem
I: unmounting dev/pts filesystem
I: unmounting dev/shm filesystem
I: unmounting proc filesystem
I: unmounting sys filesystem
I: cleaning the build env 
I: removing directory /srv/workspace/pbuilder/3681646 and its subdirectories
I: Current time: Sat Feb 14 07:11:28 +14 2026
I: pbuilder-time-stamp: 1771002688