diff --git a/.devenv/devenv.json b/.devenv/devenv.json
deleted file mode 100644
index 7af2219e23d2c5ce48c8eaca4b87083a1e28d2bc..0000000000000000000000000000000000000000
--- a/.devenv/devenv.json
+++ /dev/null
@@ -1 +0,0 @@
-{"inputs": {"nixpkgs": {"url": "github:nixos/nixpkgs/nixos-23.05"}, "version": {"url": "git+https://gitlab.schukai.com/oss/utilities/version.git", "flake": true}}, "allowUnfree": false}
\ No newline at end of file
diff --git a/.devenv/flake.json b/.devenv/flake.json
deleted file mode 100644
index 5d482a5bbd5d7a75c010718f146cf25069fd7e84..0000000000000000000000000000000000000000
--- a/.devenv/flake.json
+++ /dev/null
@@ -1 +0,0 @@
-{"nixpkgs": {"url": "github:nixos/nixpkgs/nixos-23.05"}, "version": {"url": "git+https://gitlab.schukai.com/oss/utilities/version.git", "flake": true}}
\ No newline at end of file
diff --git a/.devenv/gc/shell b/.devenv/gc/shell
deleted file mode 120000
index f11c4320b0a521b52b867c04c51f618f9880b18a..0000000000000000000000000000000000000000
--- a/.devenv/gc/shell
+++ /dev/null
@@ -1 +0,0 @@
-shell-3-link
\ No newline at end of file
diff --git a/.devenv/gc/shell-3-link b/.devenv/gc/shell-3-link
deleted file mode 120000
index c1733c71cc006c212761a3cd9ee9bbd81f54d474..0000000000000000000000000000000000000000
--- a/.devenv/gc/shell-3-link
+++ /dev/null
@@ -1 +0,0 @@
-/nix/store/zj0y62aimrc2m5cn3pbd7hasvvr6ypjz-devenv-shell-env
\ No newline at end of file
diff --git a/.devenv/imports.txt b/.devenv/imports.txt
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/profile b/.devenv/profile
deleted file mode 120000
index c21b37d55ab94af3088dfa3c668ef5da8a5e52ac..0000000000000000000000000000000000000000
--- a/.devenv/profile
+++ /dev/null
@@ -1 +0,0 @@
-/nix/store/ishxkjwm6m1nq2dzailw41xw5rczf6hi-devenv-profile
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/list
deleted file mode 100644
index 56130fb3a196dbde484abf6b391a877c97a27e65..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/list
+++ /dev/null
@@ -1 +0,0 @@
-v1.1.1
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/v1.1.1.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/v1.1.1.mod
deleted file mode 100644
index 4fcfe43e06a6b90f3d6399923ab2910948d1e189..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/agnivade/levenshtein/@v/v1.1.1.mod
+++ /dev/null
@@ -1,8 +0,0 @@
-module github.com/agnivade/levenshtein
-
-go 1.13
-
-require (
- github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0
- github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/list
deleted file mode 100644
index d2ece779df51ee5c1e1ee070cf3e9fbc7f6e1249..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/list
+++ /dev/null
@@ -1 +0,0 @@
-v0.0.0-20160628152529-48b4e1c0c4d0
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/v0.0.0-20160628152529-48b4e1c0c4d0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/v0.0.0-20160628152529-48b4e1c0c4d0.mod
deleted file mode 100644
index 0381ddbd269274896b3c49aa9c13108d8223ac85..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/arbovm/levenshtein/@v/v0.0.0-20160628152529-48b4e1c0c4d0.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/arbovm/levenshtein
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/list
deleted file mode 100644
index 1af0c4839a68970beee98dcfa9e92e362d2acc47..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/list
+++ /dev/null
@@ -1,2 +0,0 @@
-v1.1.0
-v1.1.1
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.0.mod
deleted file mode 100644
index 5e4b0f5d76bd8d75827d6f6213ddac3867ea7c7f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.0.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/davecgh/go-spew
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.info b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.info
deleted file mode 100644
index 064450325a3e412e4e6aa1dab102b9a088a12ba1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.info
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"v1.1.1","Time":"2018-02-21T23:26:28Z"}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.lock b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.mod
deleted file mode 100644
index 5e4b0f5d76bd8d75827d6f6213ddac3867ea7c7f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/davecgh/go-spew
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.zip b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.zip
deleted file mode 100644
index 826238ef3eedd456c73cfdc4745f803b2ceadf1d..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.ziphash b/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.ziphash
deleted file mode 100644
index b36e08e152c37bc8c384014a97919d6ab2ccc809..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/davecgh/go-spew/@v/v1.1.1.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/list
deleted file mode 100644
index 262cda8ddb32bd0c15ce0fdd702915adb861e953..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/list
+++ /dev/null
@@ -1 +0,0 @@
-v0.0.0-20200323201526-dd97f9abfb48
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/v0.0.0-20200323201526-dd97f9abfb48.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/v0.0.0-20200323201526-dd97f9abfb48.mod
deleted file mode 100644
index ac53d95ad2a72d228fe484e5c2ad7027eb30a771..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/dgryski/trifles/@v/v0.0.0-20200323201526-dd97f9abfb48.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/dgryski/trifles
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/list
deleted file mode 100644
index 0ec25f7505c14bad77f34453b2730417ab431293..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/list
+++ /dev/null
@@ -1 +0,0 @@
-v1.0.0
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.info b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.info
deleted file mode 100644
index 79e89a9dc36b007623304516e74d8d3b180fe8da..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.info
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"v1.0.0","Time":"2016-01-10T10:55:54Z"}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.lock b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.mod
deleted file mode 100644
index a03051fbb4abe6b03543466452b69ddfea30bdd6..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/pmezard/go-difflib
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.zip b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.zip
deleted file mode 100644
index 5ad7d64ca4bbb8488f50c1f7c72a5a5f46473740..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.ziphash b/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.ziphash
deleted file mode 100644
index 6ae1402668a8bd0b5b81fcb62be6dbd9879f810e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/pmezard/go-difflib/@v/v1.0.0.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/list
deleted file mode 100644
index 008f082617158a0fb10437aea7bee1a1de0b7ce0..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/list
+++ /dev/null
@@ -1,3 +0,0 @@
-v0.1.0
-v0.4.0
-v0.5.0
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.1.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.1.0.mod
deleted file mode 100644
index cbaa421141f1018bb1159f3d3512faef6982392b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.1.0.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/stretchr/objx
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.4.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.4.0.mod
deleted file mode 100644
index 45a55d27e47c32eeec13b49572fa0c1c5fb120e1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.4.0.mod
+++ /dev/null
@@ -1,8 +0,0 @@
-module github.com/stretchr/objx
-
-go 1.12
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/stretchr/testify v1.7.1
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.5.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.5.0.mod
deleted file mode 100644
index eeb2cb3c04a08bcfb6291e8957a02fd5387a3eee..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/objx/@v/v0.5.0.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module github.com/stretchr/objx
-
-go 1.12
-
-require github.com/stretchr/testify v1.8.0
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/list b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/list
deleted file mode 100644
index b7cdaf459d40d61beb71e96a861386092f1a1223..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/list
+++ /dev/null
@@ -1,3 +0,0 @@
-v1.7.1
-v1.8.0
-v1.8.2
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.7.1.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.7.1.mod
deleted file mode 100644
index ed0b50bf919e4cd375c78f49f5e648c850c9d8fe..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.7.1.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module github.com/stretchr/testify
-
-go 1.13
-
-require (
- github.com/davecgh/go-spew v1.1.0
- github.com/pmezard/go-difflib v1.0.0
- github.com/stretchr/objx v0.1.0
- gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.0.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.0.mod
deleted file mode 100644
index c5d3e889041eac82862d42c6562b548309f4f0c5..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.0.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module github.com/stretchr/testify
-
-go 1.13
-
-require (
- github.com/davecgh/go-spew v1.1.1
- github.com/pmezard/go-difflib v1.0.0
- github.com/stretchr/objx v0.4.0
- gopkg.in/yaml.v3 v3.0.1
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.info b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.info
deleted file mode 100644
index e1271a74081363ed6be70c22f30779104fbdf13b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.info
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"v1.8.2","Time":"2023-02-25T12:46:30Z","Origin":{"VCS":"git","URL":"https://github.com/stretchr/testify","Ref":"refs/tags/v1.8.2","Hash":"f36bfe3c337aa95c86f04c721acdbafb5ffb1611"}}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.lock b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.mod b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.mod
deleted file mode 100644
index 3fe9bab670c5e6ad956dceff38315b494412a429..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module github.com/stretchr/testify
-
-go 1.13
-
-require (
- github.com/davecgh/go-spew v1.1.1
- github.com/pmezard/go-difflib v1.0.0
- github.com/stretchr/objx v0.5.0
- gopkg.in/yaml.v3 v3.0.1
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.zip b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.zip
deleted file mode 100644
index 3ac4e13886c8a3f35ac7849fdf8c5a47adcdd33a..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.ziphash b/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.ziphash
deleted file mode 100644
index c8b115565d55de721b2fc9761eadd38f0912e074..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/github.com/stretchr/testify/@v/v1.8.2.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/list b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/list
deleted file mode 100644
index 4cf63512bca84b050829b8237b31745fc6337be0..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/list
+++ /dev/null
@@ -1,2 +0,0 @@
-v0.5.2
-v0.8.1
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.lock b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.mod b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.mod
deleted file mode 100644
index 2d2e207e6c216db5da1864b237829dd0213f4d48..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-
-go 1.19
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/stretchr/testify v1.8.0 // indirect
- gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.zip b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.zip
deleted file mode 100644
index b6a41fad614b0f44456f67c3204ee93445dc5722..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.ziphash b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.ziphash
deleted file mode 100644
index cb5dd9469cee803d5b22eaed0723252088e03620..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.5.2.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:R+dL2NJCM+AQNPK4DPDmfvx1eomi1Xb1dl0XKEFj7Ek=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.info b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.info
deleted file mode 100644
index c8b194c44cae0cc6268e90068b1e994a6f94ab1d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.info
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"v0.8.1","Time":"2023-09-16T08:48:21Z","Origin":{"VCS":"git","URL":"https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder.git","Ref":"refs/tags/v0.8.1","Hash":"aa99843ec5a11ae8ac4af99f6ce2052ad410d716"}}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.lock b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.mod b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.mod
deleted file mode 100644
index f1f0841c1e1bef35c1eea035cb525543cae38066..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.mod
+++ /dev/null
@@ -1,11 +0,0 @@
-module gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-
-go 1.20
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/google/gofuzz v1.2.0 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/stretchr/testify v1.8.0 // indirect
- gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.zip b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.zip
deleted file mode 100644
index 50b322712529a1e100d1cacb90f35c6a41fc555b..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.ziphash b/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.ziphash
deleted file mode 100644
index 6eb60449450712a4f4c687ab03ce4115aeae8f73..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/@v/v0.8.1.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:A3KvLvu4rV3OstgEn6xHulhQaXawVvzFzbafYHWHUfs=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/list b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/list
deleted file mode 100644
index d4c3e4343e7bb55326ad6cde0b9f91f5f0b47309..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/list
+++ /dev/null
@@ -1 +0,0 @@
-v0.0.0-20161208181325-20d25e280405
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/v0.0.0-20161208181325-20d25e280405.mod b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/v0.0.0-20161208181325-20d25e280405.mod
deleted file mode 100644
index 7cec6a030d4bf297003d9b5a8d77db5b8810d1a1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/check.v1/@v/v0.0.0-20161208181325-20d25e280405.mod
+++ /dev/null
@@ -1 +0,0 @@
-module gopkg.in/check.v1
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/list b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/list
deleted file mode 100644
index 2c0cc3370e175fcd9b9435d446f321051f64c192..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/list
+++ /dev/null
@@ -1,2 +0,0 @@
-v3.0.0-20200313102051-9f266ea9e77c
-v3.0.1
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.0-20200313102051-9f266ea9e77c.mod b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.0-20200313102051-9f266ea9e77c.mod
deleted file mode 100644
index f407ea3213edc12392275945f8291202b0712c9d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.0-20200313102051-9f266ea9e77c.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module "gopkg.in/yaml.v3"
-
-require (
- "gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.info b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.info
deleted file mode 100644
index 590bbd3826eac0cee63e39779c8722c3d4d2999f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.info
+++ /dev/null
@@ -1 +0,0 @@
-{"Version":"v3.0.1","Time":"2022-05-27T08:35:30Z"}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.lock b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.mod b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.mod
deleted file mode 100644
index f407ea3213edc12392275945f8291202b0712c9d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module "gopkg.in/yaml.v3"
-
-require (
- "gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405
-)
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.zip b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.zip
deleted file mode 100644
index 14e5f8611f725d670dd1d408ced2c4f47e4869c7..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.zip and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.ziphash b/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.ziphash
deleted file mode 100644
index 1220d156404ed9b5d9aef1bc9e727685d2d84573..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/gopkg.in/yaml.v3/@v/v3.0.1.ziphash
+++ /dev/null
@@ -1 +0,0 @@
-h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/lookup/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1 b/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/lookup/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1
deleted file mode 100644
index 66c1c22f16f528ac3ebbf704defc66d07c9b2304..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/lookup/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1
+++ /dev/null
@@ -1,9 +0,0 @@
-19632712
-gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.8.1 h1:A3KvLvu4rV3OstgEn6xHulhQaXawVvzFzbafYHWHUfs=
-gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.8.1/go.mod h1:MqCBFv7DXKoBE2rZDc51LGvl2QI7Kz0D+XkQ0izj+ws=
-
-go.sum database tree
-19632713
-+dFqIiCep9PFS2o8VBuGFtkBBGfUWWNR5ZdeHkgmu9k=
-
-— sum.golang.org Az3griAQL5WUYUZsThtGZu3lOLHLrxWK0YS6TDTBr7TJUTmogfpY1Hyrv21yIzVzvlSSsoq4A1vGmP1Se1EmBw8IcgQ=
diff --git a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/0/x076/690.p/73 b/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/0/x076/690.p/73
deleted file mode 100644
index d26c0100c2798b8ac5723cbd3c2e40773132972e..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/0/x076/690.p/73 and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/1/299.p/146 b/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/1/299.p/146
deleted file mode 100644
index fc9c844ae605cf14f394812ddfd08db01c537e8b..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/1/299.p/146 and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/2/001.p/43 b/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/2/001.p/43
deleted file mode 100644
index eb5d9393463e6672ac460bab415ac1fce97cfb05..0000000000000000000000000000000000000000
Binary files a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/2/001.p/43 and /dev/null differ
diff --git a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/3/000.p/1 b/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/3/000.p/1
deleted file mode 100644
index 1664933b963fc2d16304c0fbb9f217ed88b95c89..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/cache/download/sumdb/sum.golang.org/tile/8/3/000.p/1
+++ /dev/null
@@ -1,2 +0,0 @@
-o
-�@m�%q��T `�ow! ^�Z�{��ˍ��v
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/cache/lock b/.devenv/state/go/pkg/mod/cache/lock
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.gitignore b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.gitignore
deleted file mode 100644
index 00268614f04567605359c96e714e834db9cebab6..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.gitignore
+++ /dev/null
@@ -1,22 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.travis.yml b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.travis.yml
deleted file mode 100644
index 1f4cbf5425dc0804b9ca1112e8a54a5e1346db25..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/.travis.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-language: go
-go_import_path: github.com/davecgh/go-spew
-go:
- - 1.6.x
- - 1.7.x
- - 1.8.x
- - 1.9.x
- - 1.10.x
- - tip
-sudo: false
-install:
- - go get -v github.com/alecthomas/gometalinter
- - gometalinter --install
-script:
- - export PATH=$PATH:$HOME/gopath/bin
- - export GORACE="halt_on_error=1"
- - test -z "$(gometalinter --disable-all
- --enable=gofmt
- --enable=golint
- --enable=vet
- --enable=gosimple
- --enable=unconvert
- --deadline=4m ./spew | tee /dev/stderr)"
- - go test -v -race -tags safe ./spew
- - go test -v -race -tags testcgo ./spew -covermode=atomic -coverprofile=profile.cov
-after_success:
- - go get -v github.com/mattn/goveralls
- - goveralls -coverprofile=profile.cov -service=travis-ci
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/LICENSE b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/LICENSE
deleted file mode 100644
index bc52e96f2b0ea97cc450e2fefbbb4cc430d1ac5a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/README.md b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/README.md
deleted file mode 100644
index f6ed02c3b672fa9c70ce790bc7f34bb957e61643..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/README.md
+++ /dev/null
@@ -1,201 +0,0 @@
-go-spew
-=======
-
-[](https://travis-ci.org/davecgh/go-spew)
-[](http://copyfree.org)
-[](https://coveralls.io/r/davecgh/go-spew?branch=master)
-
-Go-spew implements a deep pretty printer for Go data structures to aid in
-debugging. A comprehensive suite of tests with 100% test coverage is provided
-to ensure proper functionality. See `test_coverage.txt` for the gocov coverage
-report. Go-spew is licensed under the liberal ISC license, so it may be used in
-open source or commercial projects.
-
-If you're interested in reading about how this package came to life and some
-of the challenges involved in providing a deep pretty printer, there is a blog
-post about it
-[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).
-
-## Documentation
-
-[](http://godoc.org/github.com/davecgh/go-spew/spew)
-
-Full `go doc` style documentation for the project can be viewed online without
-installing this package by using the excellent GoDoc site here:
-http://godoc.org/github.com/davecgh/go-spew/spew
-
-You can also view the documentation locally once the package is installed with
-the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
-http://localhost:6060/pkg/github.com/davecgh/go-spew/spew
-
-## Installation
-
-```bash
-$ go get -u github.com/davecgh/go-spew/spew
-```
-
-## Quick Start
-
-Add this import line to the file you're working in:
-
-```Go
-import "github.com/davecgh/go-spew/spew"
-```
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-
-```Go
-spew.Dump(myVar1, myVar2, ...)
-spew.Fdump(someWriter, myVar1, myVar2, ...)
-str := spew.Sdump(myVar1, myVar2, ...)
-```
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most
-compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types
-and pointer addresses):
-
-```Go
-spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-```
-
-## Debugging a Web Application Example
-
-Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.
-
-```Go
-package main
-
-import (
- "fmt"
- "html"
- "net/http"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-func handler(w http.ResponseWriter, r *http.Request) {
- w.Header().Set("Content-Type", "text/html")
- fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
- fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")
-}
-
-func main() {
- http.HandleFunc("/", handler)
- http.ListenAndServe(":8080", nil)
-}
-```
-
-## Sample Dump Output
-
-```
-(main.Foo) {
- unexportedField: (*main.Bar)(0xf84002e210)({
- flag: (main.Flag) flagTwo,
- data: (uintptr) <nil>
- }),
- ExportedField: (map[interface {}]interface {}) {
- (string) "one": (bool) true
- }
-}
-([]uint8) {
- 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
- 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
- 00000020 31 32 |12|
-}
-```
-
-## Sample Formatter Output
-
-Double pointer to a uint8:
-```
- %v: <**>5
- %+v: <**>(0xf8400420d0->0xf8400420c8)5
- %#v: (**uint8)5
- %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-```
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-```
- %v: <*>{1 <*><shown>}
- %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
- %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
- %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-```
-
-## Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type. For
-convenience, all of the top-level functions use a global state available via the
-spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions. This allows concurrent configuration
-options. See the ConfigState documentation for more details.
-
-```
-* Indent
- String to use for each indentation level for Dump functions.
- It is a single space by default. A popular alternative is "\t".
-
-* MaxDepth
- Maximum number of levels to descend into nested data structures.
- There is no limit by default.
-
-* DisableMethods
- Disables invocation of error and Stringer interface methods.
- Method invocation is enabled by default.
-
-* DisablePointerMethods
- Disables invocation of error and Stringer interface methods on types
- which only accept pointer receivers from non-pointer variables. This option
- relies on access to the unsafe package, so it will not have any effect when
- running in environments without access to the unsafe package such as Google
- App Engine or with the "safe" build tag specified.
- Pointer method invocation is enabled by default.
-
-* DisablePointerAddresses
- DisablePointerAddresses specifies whether to disable the printing of
- pointer addresses. This is useful when diffing data structures in tests.
-
-* DisableCapacities
- DisableCapacities specifies whether to disable the printing of capacities
- for arrays, slices, maps and channels. This is useful when diffing data
- structures in tests.
-
-* ContinueOnMethod
- Enables recursion into types after invoking error and Stringer interface
- methods. Recursion after method invocation is disabled by default.
-
-* SortKeys
- Specifies map keys should be sorted before being printed. Use
- this to have a more deterministic, diffable output. Note that
- only native types (bool, int, uint, floats, uintptr and string)
- and types which implement error or Stringer interfaces are supported,
- with other types sorted according to the reflect.Value.String() output
- which guarantees display stability. Natural map order is used by
- default.
-
-* SpewKeys
- SpewKeys specifies that, as a last resort attempt, map keys should be
- spewed to strings and sorted by those strings. This is only considered
- if SortKeys is true.
-
-```
-
-## Unsafe Package Dependency
-
-This package relies on the unsafe package to perform some of the more advanced
-features, however it also supports a "limited" mode which allows it to work in
-environments where the unsafe package is not available. By default, it will
-operate in this mode on Google App Engine and when compiled with GopherJS. The
-"safe" build tag may also be specified to force the package to build without
-using the unsafe package.
-
-## License
-
-Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/cov_report.sh b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/cov_report.sh
deleted file mode 100644
index 9579497e4115f7e90e1adf99417ddb65d113e532..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/cov_report.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/sh
-
-# This script uses gocov to generate a test coverage report.
-# The gocov tool my be obtained with the following command:
-# go get github.com/axw/gocov/gocov
-#
-# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
-
-# Check for gocov.
-if ! type gocov >/dev/null 2>&1; then
- echo >&2 "This script requires the gocov tool."
- echo >&2 "You may obtain it with the following command:"
- echo >&2 "go get github.com/axw/gocov/gocov"
- exit 1
-fi
-
-# Only run the cgo tests if gcc is installed.
-if type gcc >/dev/null 2>&1; then
- (cd spew && gocov test -tags testcgo | gocov report)
-else
- (cd spew && gocov test | gocov report)
-fi
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypass.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypass.go
deleted file mode 100644
index 792994785e36ca74c5545a0d93a2cdecda006678..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypass.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is not running on Google App Engine, compiled by GopherJS, and
-// "-tags safe" is not added to the go build command line. The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// Go versions prior to 1.4 are disabled because they use a different layout
-// for interfaces which make the implementation of unsafeReflectValue more complex.
-// +build !js,!appengine,!safe,!disableunsafe,go1.4
-
-package spew
-
-import (
- "reflect"
- "unsafe"
-)
-
-const (
- // UnsafeDisabled is a build-time constant which specifies whether or
- // not access to the unsafe package is available.
- UnsafeDisabled = false
-
- // ptrSize is the size of a pointer on the current arch.
- ptrSize = unsafe.Sizeof((*byte)(nil))
-)
-
-type flag uintptr
-
-var (
- // flagRO indicates whether the value field of a reflect.Value
- // is read-only.
- flagRO flag
-
- // flagAddr indicates whether the address of the reflect.Value's
- // value may be taken.
- flagAddr flag
-)
-
-// flagKindMask holds the bits that make up the kind
-// part of the flags field. In all the supported versions,
-// it is in the lower 5 bits.
-const flagKindMask = flag(0x1f)
-
-// Different versions of Go have used different
-// bit layouts for the flags type. This table
-// records the known combinations.
-var okFlags = []struct {
- ro, addr flag
-}{{
- // From Go 1.4 to 1.5
- ro: 1 << 5,
- addr: 1 << 7,
-}, {
- // Up to Go tip.
- ro: 1<<5 | 1<<6,
- addr: 1 << 8,
-}}
-
-var flagValOffset = func() uintptr {
- field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
- if !ok {
- panic("reflect.Value has no flag field")
- }
- return field.Offset
-}()
-
-// flagField returns a pointer to the flag field of a reflect.Value.
-func flagField(v *reflect.Value) *flag {
- return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
-}
-
-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
-// the typical safety restrictions preventing access to unaddressable and
-// unexported data. It works by digging the raw pointer to the underlying
-// value out of the protected value and generating a new unprotected (unsafe)
-// reflect.Value to it.
-//
-// This allows us to check for implementations of the Stringer and error
-// interfaces to be used for pretty printing ordinarily unaddressable and
-// inaccessible values such as unexported struct fields.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
- if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
- return v
- }
- flagFieldPtr := flagField(&v)
- *flagFieldPtr &^= flagRO
- *flagFieldPtr |= flagAddr
- return v
-}
-
-// Sanity checks against future reflect package changes
-// to the type or semantics of the Value.flag field.
-func init() {
- field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
- if !ok {
- panic("reflect.Value has no flag field")
- }
- if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
- panic("reflect.Value flag field has changed kind")
- }
- type t0 int
- var t struct {
- A t0
- // t0 will have flagEmbedRO set.
- t0
- // a will have flagStickyRO set
- a t0
- }
- vA := reflect.ValueOf(t).FieldByName("A")
- va := reflect.ValueOf(t).FieldByName("a")
- vt0 := reflect.ValueOf(t).FieldByName("t0")
-
- // Infer flagRO from the difference between the flags
- // for the (otherwise identical) fields in t.
- flagPublic := *flagField(&vA)
- flagWithRO := *flagField(&va) | *flagField(&vt0)
- flagRO = flagPublic ^ flagWithRO
-
- // Infer flagAddr from the difference between a value
- // taken from a pointer and not.
- vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
- flagNoPtr := *flagField(&vA)
- flagPtr := *flagField(&vPtrA)
- flagAddr = flagNoPtr ^ flagPtr
-
- // Check that the inferred flags tally with one of the known versions.
- for _, f := range okFlags {
- if flagRO == f.ro && flagAddr == f.addr {
- return
- }
- }
- panic("reflect.Value read-only flag has changed semantics")
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypasssafe.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypasssafe.go
deleted file mode 100644
index 205c28d68c474e4497e6aa1ce8b9fdeb260f4586..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/bypasssafe.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is running on Google App Engine, compiled by GopherJS, or
-// "-tags safe" is added to the go build command line. The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build js appengine safe disableunsafe !go1.4
-
-package spew
-
-import "reflect"
-
-const (
- // UnsafeDisabled is a build-time constant which specifies whether or
- // not access to the unsafe package is available.
- UnsafeDisabled = true
-)
-
-// unsafeReflectValue typically converts the passed reflect.Value into a one
-// that bypasses the typical safety restrictions preventing access to
-// unaddressable and unexported data. However, doing this relies on access to
-// the unsafe package. This is a stub version which simply returns the passed
-// reflect.Value when the unsafe package is not available.
-func unsafeReflectValue(v reflect.Value) reflect.Value {
- return v
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common.go
deleted file mode 100644
index 1be8ce9457612e02a64c01b2321d087ebd6415f2..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common.go
+++ /dev/null
@@ -1,341 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
- "bytes"
- "fmt"
- "io"
- "reflect"
- "sort"
- "strconv"
-)
-
-// Some constants in the form of bytes to avoid string overhead. This mirrors
-// the technique used in the fmt package.
-var (
- panicBytes = []byte("(PANIC=")
- plusBytes = []byte("+")
- iBytes = []byte("i")
- trueBytes = []byte("true")
- falseBytes = []byte("false")
- interfaceBytes = []byte("(interface {})")
- commaNewlineBytes = []byte(",\n")
- newlineBytes = []byte("\n")
- openBraceBytes = []byte("{")
- openBraceNewlineBytes = []byte("{\n")
- closeBraceBytes = []byte("}")
- asteriskBytes = []byte("*")
- colonBytes = []byte(":")
- colonSpaceBytes = []byte(": ")
- openParenBytes = []byte("(")
- closeParenBytes = []byte(")")
- spaceBytes = []byte(" ")
- pointerChainBytes = []byte("->")
- nilAngleBytes = []byte("<nil>")
- maxNewlineBytes = []byte("<max depth reached>\n")
- maxShortBytes = []byte("<max>")
- circularBytes = []byte("<already shown>")
- circularShortBytes = []byte("<shown>")
- invalidAngleBytes = []byte("<invalid>")
- openBracketBytes = []byte("[")
- closeBracketBytes = []byte("]")
- percentBytes = []byte("%")
- precisionBytes = []byte(".")
- openAngleBytes = []byte("<")
- closeAngleBytes = []byte(">")
- openMapBytes = []byte("map[")
- closeMapBytes = []byte("]")
- lenEqualsBytes = []byte("len=")
- capEqualsBytes = []byte("cap=")
-)
-
-// hexDigits is used to map a decimal value to a hex digit.
-var hexDigits = "0123456789abcdef"
-
-// catchPanic handles any panics that might occur during the handleMethods
-// calls.
-func catchPanic(w io.Writer, v reflect.Value) {
- if err := recover(); err != nil {
- w.Write(panicBytes)
- fmt.Fprintf(w, "%v", err)
- w.Write(closeParenBytes)
- }
-}
-
-// handleMethods attempts to call the Error and String methods on the underlying
-// type the passed reflect.Value represents and outputes the result to Writer w.
-//
-// It handles panics in any called methods by catching and displaying the error
-// as the formatted value.
-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
- // We need an interface to check if the type implements the error or
- // Stringer interface. However, the reflect package won't give us an
- // interface on certain things like unexported struct fields in order
- // to enforce visibility rules. We use unsafe, when it's available,
- // to bypass these restrictions since this package does not mutate the
- // values.
- if !v.CanInterface() {
- if UnsafeDisabled {
- return false
- }
-
- v = unsafeReflectValue(v)
- }
-
- // Choose whether or not to do error and Stringer interface lookups against
- // the base type or a pointer to the base type depending on settings.
- // Technically calling one of these methods with a pointer receiver can
- // mutate the value, however, types which choose to satisify an error or
- // Stringer interface with a pointer receiver should not be mutating their
- // state inside these interface methods.
- if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
- v = unsafeReflectValue(v)
- }
- if v.CanAddr() {
- v = v.Addr()
- }
-
- // Is it an error or Stringer?
- switch iface := v.Interface().(type) {
- case error:
- defer catchPanic(w, v)
- if cs.ContinueOnMethod {
- w.Write(openParenBytes)
- w.Write([]byte(iface.Error()))
- w.Write(closeParenBytes)
- w.Write(spaceBytes)
- return false
- }
-
- w.Write([]byte(iface.Error()))
- return true
-
- case fmt.Stringer:
- defer catchPanic(w, v)
- if cs.ContinueOnMethod {
- w.Write(openParenBytes)
- w.Write([]byte(iface.String()))
- w.Write(closeParenBytes)
- w.Write(spaceBytes)
- return false
- }
- w.Write([]byte(iface.String()))
- return true
- }
- return false
-}
-
-// printBool outputs a boolean value as true or false to Writer w.
-func printBool(w io.Writer, val bool) {
- if val {
- w.Write(trueBytes)
- } else {
- w.Write(falseBytes)
- }
-}
-
-// printInt outputs a signed integer value to Writer w.
-func printInt(w io.Writer, val int64, base int) {
- w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// printUint outputs an unsigned integer value to Writer w.
-func printUint(w io.Writer, val uint64, base int) {
- w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// printFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func printFloat(w io.Writer, val float64, precision int) {
- w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// printComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func printComplex(w io.Writer, c complex128, floatPrecision int) {
- r := real(c)
- w.Write(openParenBytes)
- w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
- i := imag(c)
- if i >= 0 {
- w.Write(plusBytes)
- }
- w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
- w.Write(iBytes)
- w.Write(closeParenBytes)
-}
-
-// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
-// prefix to Writer w.
-func printHexPtr(w io.Writer, p uintptr) {
- // Null pointer.
- num := uint64(p)
- if num == 0 {
- w.Write(nilAngleBytes)
- return
- }
-
- // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
- buf := make([]byte, 18)
-
- // It's simpler to construct the hex string right to left.
- base := uint64(16)
- i := len(buf) - 1
- for num >= base {
- buf[i] = hexDigits[num%base]
- num /= base
- i--
- }
- buf[i] = hexDigits[num]
-
- // Add '0x' prefix.
- i--
- buf[i] = 'x'
- i--
- buf[i] = '0'
-
- // Strip unused leading bytes.
- buf = buf[i:]
- w.Write(buf)
-}
-
-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
-// elements to be sorted.
-type valuesSorter struct {
- values []reflect.Value
- strings []string // either nil or same len and values
- cs *ConfigState
-}
-
-// newValuesSorter initializes a valuesSorter instance, which holds a set of
-// surrogate keys on which the data should be sorted. It uses flags in
-// ConfigState to decide if and how to populate those surrogate keys.
-func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
- vs := &valuesSorter{values: values, cs: cs}
- if canSortSimply(vs.values[0].Kind()) {
- return vs
- }
- if !cs.DisableMethods {
- vs.strings = make([]string, len(values))
- for i := range vs.values {
- b := bytes.Buffer{}
- if !handleMethods(cs, &b, vs.values[i]) {
- vs.strings = nil
- break
- }
- vs.strings[i] = b.String()
- }
- }
- if vs.strings == nil && cs.SpewKeys {
- vs.strings = make([]string, len(values))
- for i := range vs.values {
- vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
- }
- }
- return vs
-}
-
-// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
-// directly, or whether it should be considered for sorting by surrogate keys
-// (if the ConfigState allows it).
-func canSortSimply(kind reflect.Kind) bool {
- // This switch parallels valueSortLess, except for the default case.
- switch kind {
- case reflect.Bool:
- return true
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
- return true
- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
- return true
- case reflect.Float32, reflect.Float64:
- return true
- case reflect.String:
- return true
- case reflect.Uintptr:
- return true
- case reflect.Array:
- return true
- }
- return false
-}
-
-// Len returns the number of values in the slice. It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Len() int {
- return len(s.values)
-}
-
-// Swap swaps the values at the passed indices. It is part of the
-// sort.Interface implementation.
-func (s *valuesSorter) Swap(i, j int) {
- s.values[i], s.values[j] = s.values[j], s.values[i]
- if s.strings != nil {
- s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
- }
-}
-
-// valueSortLess returns whether the first value should sort before the second
-// value. It is used by valueSorter.Less as part of the sort.Interface
-// implementation.
-func valueSortLess(a, b reflect.Value) bool {
- switch a.Kind() {
- case reflect.Bool:
- return !a.Bool() && b.Bool()
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
- return a.Int() < b.Int()
- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
- return a.Uint() < b.Uint()
- case reflect.Float32, reflect.Float64:
- return a.Float() < b.Float()
- case reflect.String:
- return a.String() < b.String()
- case reflect.Uintptr:
- return a.Uint() < b.Uint()
- case reflect.Array:
- // Compare the contents of both arrays.
- l := a.Len()
- for i := 0; i < l; i++ {
- av := a.Index(i)
- bv := b.Index(i)
- if av.Interface() == bv.Interface() {
- continue
- }
- return valueSortLess(av, bv)
- }
- }
- return a.String() < b.String()
-}
-
-// Less returns whether the value at index i should sort before the
-// value at index j. It is part of the sort.Interface implementation.
-func (s *valuesSorter) Less(i, j int) bool {
- if s.strings == nil {
- return valueSortLess(s.values[i], s.values[j])
- }
- return s.strings[i] < s.strings[j]
-}
-
-// sortValues is a sort function that handles both native types and any type that
-// can be converted to error or Stringer. Other inputs are sorted according to
-// their Value.String() value to ensure display stability.
-func sortValues(values []reflect.Value, cs *ConfigState) {
- if len(values) == 0 {
- return
- }
- sort.Sort(newValuesSorter(values, cs))
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common_test.go
deleted file mode 100644
index 0f5ce47dcaf6c4fa8768a6655340a381195d691c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/common_test.go
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew_test
-
-import (
- "fmt"
- "reflect"
- "testing"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-// custom type to test Stinger interface on non-pointer receiver.
-type stringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with non-pointer receivers.
-func (s stringer) String() string {
- return "stringer " + string(s)
-}
-
-// custom type to test Stinger interface on pointer receiver.
-type pstringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with only pointer receivers.
-func (s *pstringer) String() string {
- return "stringer " + string(*s)
-}
-
-// xref1 and xref2 are cross referencing structs for testing circular reference
-// detection.
-type xref1 struct {
- ps2 *xref2
-}
-type xref2 struct {
- ps1 *xref1
-}
-
-// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
-// reference for testing detection.
-type indirCir1 struct {
- ps2 *indirCir2
-}
-type indirCir2 struct {
- ps3 *indirCir3
-}
-type indirCir3 struct {
- ps1 *indirCir1
-}
-
-// embed is used to test embedded structures.
-type embed struct {
- a string
-}
-
-// embedwrap is used to test embedded structures.
-type embedwrap struct {
- *embed
- e *embed
-}
-
-// panicer is used to intentionally cause a panic for testing spew properly
-// handles them
-type panicer int
-
-func (p panicer) String() string {
- panic("test panic")
-}
-
-// customError is used to test custom error interface invocation.
-type customError int
-
-func (e customError) Error() string {
- return fmt.Sprintf("error: %d", int(e))
-}
-
-// stringizeWants converts a slice of wanted test output into a format suitable
-// for a test error message.
-func stringizeWants(wants []string) string {
- s := ""
- for i, want := range wants {
- if i > 0 {
- s += fmt.Sprintf("want%d: %s", i+1, want)
- } else {
- s += "want: " + want
- }
- }
- return s
-}
-
-// testFailed returns whether or not a test failed by checking if the result
-// of the test is in the slice of wanted strings.
-func testFailed(result string, wants []string) bool {
- for _, want := range wants {
- if result == want {
- return false
- }
- }
- return true
-}
-
-type sortableStruct struct {
- x int
-}
-
-func (ss sortableStruct) String() string {
- return fmt.Sprintf("ss.%d", ss.x)
-}
-
-type unsortableStruct struct {
- x int
-}
-
-type sortTestCase struct {
- input []reflect.Value
- expected []reflect.Value
-}
-
-func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {
- getInterfaces := func(values []reflect.Value) []interface{} {
- interfaces := []interface{}{}
- for _, v := range values {
- interfaces = append(interfaces, v.Interface())
- }
- return interfaces
- }
-
- for _, test := range tests {
- spew.SortValues(test.input, cs)
- // reflect.DeepEqual cannot really make sense of reflect.Value,
- // probably because of all the pointer tricks. For instance,
- // v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
- // instead.
- input := getInterfaces(test.input)
- expected := getInterfaces(test.expected)
- if !reflect.DeepEqual(input, expected) {
- t.Errorf("Sort mismatch:\n %v != %v", input, expected)
- }
- }
-}
-
-// TestSortValues ensures the sort functionality for relect.Value based sorting
-// works as intended.
-func TestSortValues(t *testing.T) {
- v := reflect.ValueOf
-
- a := v("a")
- b := v("b")
- c := v("c")
- embedA := v(embed{"a"})
- embedB := v(embed{"b"})
- embedC := v(embed{"c"})
- tests := []sortTestCase{
- // No values.
- {
- []reflect.Value{},
- []reflect.Value{},
- },
- // Bools.
- {
- []reflect.Value{v(false), v(true), v(false)},
- []reflect.Value{v(false), v(false), v(true)},
- },
- // Ints.
- {
- []reflect.Value{v(2), v(1), v(3)},
- []reflect.Value{v(1), v(2), v(3)},
- },
- // Uints.
- {
- []reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
- []reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
- },
- // Floats.
- {
- []reflect.Value{v(2.0), v(1.0), v(3.0)},
- []reflect.Value{v(1.0), v(2.0), v(3.0)},
- },
- // Strings.
- {
- []reflect.Value{b, a, c},
- []reflect.Value{a, b, c},
- },
- // Array
- {
- []reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},
- []reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},
- },
- // Uintptrs.
- {
- []reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
- []reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
- },
- // SortableStructs.
- {
- // Note: not sorted - DisableMethods is set.
- []reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
- []reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
- },
- // UnsortableStructs.
- {
- // Note: not sorted - SpewKeys is false.
- []reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
- []reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
- },
- // Invalid.
- {
- []reflect.Value{embedB, embedA, embedC},
- []reflect.Value{embedB, embedA, embedC},
- },
- }
- cs := spew.ConfigState{DisableMethods: true, SpewKeys: false}
- helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithMethods ensures the sort functionality for relect.Value
-// based sorting works as intended when using string methods.
-func TestSortValuesWithMethods(t *testing.T) {
- v := reflect.ValueOf
-
- a := v("a")
- b := v("b")
- c := v("c")
- tests := []sortTestCase{
- // Ints.
- {
- []reflect.Value{v(2), v(1), v(3)},
- []reflect.Value{v(1), v(2), v(3)},
- },
- // Strings.
- {
- []reflect.Value{b, a, c},
- []reflect.Value{a, b, c},
- },
- // SortableStructs.
- {
- []reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
- []reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
- },
- // UnsortableStructs.
- {
- // Note: not sorted - SpewKeys is false.
- []reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
- []reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
- },
- }
- cs := spew.ConfigState{DisableMethods: false, SpewKeys: false}
- helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithSpew ensures the sort functionality for relect.Value
-// based sorting works as intended when using spew to stringify keys.
-func TestSortValuesWithSpew(t *testing.T) {
- v := reflect.ValueOf
-
- a := v("a")
- b := v("b")
- c := v("c")
- tests := []sortTestCase{
- // Ints.
- {
- []reflect.Value{v(2), v(1), v(3)},
- []reflect.Value{v(1), v(2), v(3)},
- },
- // Strings.
- {
- []reflect.Value{b, a, c},
- []reflect.Value{a, b, c},
- },
- // SortableStructs.
- {
- []reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
- []reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
- },
- // UnsortableStructs.
- {
- []reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
- []reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},
- },
- }
- cs := spew.ConfigState{DisableMethods: true, SpewKeys: true}
- helpTestSortValues(tests, &cs, t)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/config.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/config.go
deleted file mode 100644
index 2e3d22f312026ff2c863bbffcbc88b7f6fb942f5..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/config.go
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
- "bytes"
- "fmt"
- "io"
- "os"
-)
-
-// ConfigState houses the configuration options used by spew to format and
-// display values. There is a global instance, Config, that is used to control
-// all top-level Formatter and Dump functionality. Each ConfigState instance
-// provides methods equivalent to the top-level functions.
-//
-// The zero value for ConfigState provides no indentation. You would typically
-// want to set it to a space or a tab.
-//
-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
-// with default settings. See the documentation of NewDefaultConfig for default
-// values.
-type ConfigState struct {
- // Indent specifies the string to use for each indentation level. The
- // global config instance that all top-level functions use set this to a
- // single space by default. If you would like more indentation, you might
- // set this to a tab with "\t" or perhaps two spaces with " ".
- Indent string
-
- // MaxDepth controls the maximum number of levels to descend into nested
- // data structures. The default, 0, means there is no limit.
- //
- // NOTE: Circular data structures are properly detected, so it is not
- // necessary to set this value unless you specifically want to limit deeply
- // nested data structures.
- MaxDepth int
-
- // DisableMethods specifies whether or not error and Stringer interfaces are
- // invoked for types that implement them.
- DisableMethods bool
-
- // DisablePointerMethods specifies whether or not to check for and invoke
- // error and Stringer interfaces on types which only accept a pointer
- // receiver when the current type is not a pointer.
- //
- // NOTE: This might be an unsafe action since calling one of these methods
- // with a pointer receiver could technically mutate the value, however,
- // in practice, types which choose to satisify an error or Stringer
- // interface with a pointer receiver should not be mutating their state
- // inside these interface methods. As a result, this option relies on
- // access to the unsafe package, so it will not have any effect when
- // running in environments without access to the unsafe package such as
- // Google App Engine or with the "safe" build tag specified.
- DisablePointerMethods bool
-
- // DisablePointerAddresses specifies whether to disable the printing of
- // pointer addresses. This is useful when diffing data structures in tests.
- DisablePointerAddresses bool
-
- // DisableCapacities specifies whether to disable the printing of capacities
- // for arrays, slices, maps and channels. This is useful when diffing
- // data structures in tests.
- DisableCapacities bool
-
- // ContinueOnMethod specifies whether or not recursion should continue once
- // a custom error or Stringer interface is invoked. The default, false,
- // means it will print the results of invoking the custom error or Stringer
- // interface and return immediately instead of continuing to recurse into
- // the internals of the data type.
- //
- // NOTE: This flag does not have any effect if method invocation is disabled
- // via the DisableMethods or DisablePointerMethods options.
- ContinueOnMethod bool
-
- // SortKeys specifies map keys should be sorted before being printed. Use
- // this to have a more deterministic, diffable output. Note that only
- // native types (bool, int, uint, floats, uintptr and string) and types
- // that support the error or Stringer interfaces (if methods are
- // enabled) are supported, with other types sorted according to the
- // reflect.Value.String() output which guarantees display stability.
- SortKeys bool
-
- // SpewKeys specifies that, as a last resort attempt, map keys should
- // be spewed to strings and sorted by those strings. This is only
- // considered if SortKeys is true.
- SpewKeys bool
-}
-
-// Config is the active configuration of the top-level functions.
-// The configuration can be changed by modifying the contents of spew.Config.
-var Config = ConfigState{Indent: " "}
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the formatted string as a value that satisfies error. See NewFormatter
-// for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
- return fmt.Errorf(format, c.convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
- return fmt.Fprint(w, c.convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
- return fmt.Fprintf(w, format, c.convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a Formatter interface returned by c.NewFormatter. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
- return fmt.Fprintln(w, c.convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
- return fmt.Print(c.convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
- return fmt.Printf(format, c.convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
- return fmt.Println(c.convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprint(a ...interface{}) string {
- return fmt.Sprint(c.convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a Formatter interface returned by c.NewFormatter. It returns
-// the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
- return fmt.Sprintf(format, c.convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a Formatter interface returned by c.NewFormatter. It
-// returns the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
-func (c *ConfigState) Sprintln(a ...interface{}) string {
- return fmt.Sprintln(c.convertArgs(a)...)
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface. As a result, it integrates cleanly with standard fmt package
-printing functions. The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
-combinations. Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting. In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly. It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-c.Printf, c.Println, or c.Printf.
-*/
-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
- return newFormatter(c, v)
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w. It formats
-// exactly the same as Dump.
-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
- fdump(c, w, a...)
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value. It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
- * Pointers are dereferenced and followed
- * Circular data structures are detected and handled properly
- * Custom Stringer/error interfaces are optionally invoked, including
- on unexported types
- * Custom types which only implement the Stringer/error interfaces via
- a pointer receiver are optionally invoked when passing non-pointer
- variables
- * Byte arrays and slices are dumped like the hexdump -C command which
- includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by modifying the public members
-of c. See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func (c *ConfigState) Dump(a ...interface{}) {
- fdump(c, os.Stdout, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func (c *ConfigState) Sdump(a ...interface{}) string {
- var buf bytes.Buffer
- fdump(c, &buf, a...)
- return buf.String()
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a spew Formatter interface using
-// the ConfigState associated with s.
-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
- formatters = make([]interface{}, len(args))
- for index, arg := range args {
- formatters[index] = newFormatter(c, arg)
- }
- return formatters
-}
-
-// NewDefaultConfig returns a ConfigState with the following default settings.
-//
-// Indent: " "
-// MaxDepth: 0
-// DisableMethods: false
-// DisablePointerMethods: false
-// ContinueOnMethod: false
-// SortKeys: false
-func NewDefaultConfig() *ConfigState {
- return &ConfigState{Indent: " "}
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/doc.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/doc.go
deleted file mode 100644
index aacaac6f1e1e936ee0022c00e139756c9bdc2b3e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/doc.go
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Package spew implements a deep pretty printer for Go data structures to aid in
-debugging.
-
-A quick overview of the additional features spew provides over the built-in
-printing facilities for Go data types are as follows:
-
- * Pointers are dereferenced and followed
- * Circular data structures are detected and handled properly
- * Custom Stringer/error interfaces are optionally invoked, including
- on unexported types
- * Custom types which only implement the Stringer/error interfaces via
- a pointer receiver are optionally invoked when passing non-pointer
- variables
- * Byte arrays and slices are dumped like the hexdump -C command which
- includes offsets, byte values in hex, and ASCII output (only when using
- Dump style)
-
-There are two different approaches spew allows for dumping Go data structures:
-
- * Dump style which prints with newlines, customizable indentation,
- and additional debug information such as types and all pointer addresses
- used to indirect to the final value
- * A custom Formatter interface that integrates cleanly with the standard fmt
- package and replaces %v, %+v, %#v, and %#+v to provide inline printing
- similar to the default %v while providing the additional functionality
- outlined above and passing unsupported format verbs such as %x and %q
- along to fmt
-
-Quick Start
-
-This section demonstrates how to quickly get started with spew. See the
-sections below for further details on formatting and configuration options.
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
- spew.Dump(myVar1, myVar2, ...)
- spew.Fdump(someWriter, myVar1, myVar2, ...)
- str := spew.Sdump(myVar1, myVar2, ...)
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with
-%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
-%#+v (adds types and pointer addresses):
- spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
- spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
- spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
- spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type. For
-convenience, all of the top-level functions use a global state available
-via the spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions. This allows concurrent configuration
-options. See the ConfigState documentation for more details.
-
-The following configuration options are available:
- * Indent
- String to use for each indentation level for Dump functions.
- It is a single space by default. A popular alternative is "\t".
-
- * MaxDepth
- Maximum number of levels to descend into nested data structures.
- There is no limit by default.
-
- * DisableMethods
- Disables invocation of error and Stringer interface methods.
- Method invocation is enabled by default.
-
- * DisablePointerMethods
- Disables invocation of error and Stringer interface methods on types
- which only accept pointer receivers from non-pointer variables.
- Pointer method invocation is enabled by default.
-
- * DisablePointerAddresses
- DisablePointerAddresses specifies whether to disable the printing of
- pointer addresses. This is useful when diffing data structures in tests.
-
- * DisableCapacities
- DisableCapacities specifies whether to disable the printing of
- capacities for arrays, slices, maps and channels. This is useful when
- diffing data structures in tests.
-
- * ContinueOnMethod
- Enables recursion into types after invoking error and Stringer interface
- methods. Recursion after method invocation is disabled by default.
-
- * SortKeys
- Specifies map keys should be sorted before being printed. Use
- this to have a more deterministic, diffable output. Note that
- only native types (bool, int, uint, floats, uintptr and string)
- and types which implement error or Stringer interfaces are
- supported with other types sorted according to the
- reflect.Value.String() output which guarantees display
- stability. Natural map order is used by default.
-
- * SpewKeys
- Specifies that, as a last resort attempt, map keys should be
- spewed to strings and sorted by those strings. This is only
- considered if SortKeys is true.
-
-Dump Usage
-
-Simply call spew.Dump with a list of variables you want to dump:
-
- spew.Dump(myVar1, myVar2, ...)
-
-You may also call spew.Fdump if you would prefer to output to an arbitrary
-io.Writer. For example, to dump to standard error:
-
- spew.Fdump(os.Stderr, myVar1, myVar2, ...)
-
-A third option is to call spew.Sdump to get the formatted output as a string:
-
- str := spew.Sdump(myVar1, myVar2, ...)
-
-Sample Dump Output
-
-See the Dump example for details on the setup of the types and variables being
-shown here.
-
- (main.Foo) {
- unexportedField: (*main.Bar)(0xf84002e210)({
- flag: (main.Flag) flagTwo,
- data: (uintptr) <nil>
- }),
- ExportedField: (map[interface {}]interface {}) (len=1) {
- (string) (len=3) "one": (bool) true
- }
- }
-
-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
-command as shown.
- ([]uint8) (len=32 cap=32) {
- 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
- 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
- 00000020 31 32 |12|
- }
-
-Custom Formatter
-
-Spew provides a custom formatter that implements the fmt.Formatter interface
-so that it integrates cleanly with standard fmt package printing functions. The
-formatter is useful for inline printing of smaller data types similar to the
-standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations. Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting. In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Custom Formatter Usage
-
-The simplest way to make use of the spew custom formatter is to call one of the
-convenience functions such as spew.Printf, spew.Println, or spew.Printf. The
-functions have syntax you are most likely already familiar with:
-
- spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
- spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
- spew.Println(myVar, myVar2)
- spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
- spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-
-See the Index for the full list convenience functions.
-
-Sample Formatter Output
-
-Double pointer to a uint8:
- %v: <**>5
- %+v: <**>(0xf8400420d0->0xf8400420c8)5
- %#v: (**uint8)5
- %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
- %v: <*>{1 <*><shown>}
- %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
- %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
- %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-
-See the Printf example for details on the setup of variables being shown
-here.
-
-Errors
-
-Since it is possible for custom Stringer/error interfaces to panic, spew
-detects them and handles them internally by printing the panic information
-inline with the output. Since spew is intended to provide deep pretty printing
-capabilities on structures, it intentionally does not return any errors.
-*/
-package spew
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump.go
deleted file mode 100644
index f78d89fc1f6c454df58cd1e346817db6e30c4299..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump.go
+++ /dev/null
@@ -1,509 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
- "bytes"
- "encoding/hex"
- "fmt"
- "io"
- "os"
- "reflect"
- "regexp"
- "strconv"
- "strings"
-)
-
-var (
- // uint8Type is a reflect.Type representing a uint8. It is used to
- // convert cgo types to uint8 slices for hexdumping.
- uint8Type = reflect.TypeOf(uint8(0))
-
- // cCharRE is a regular expression that matches a cgo char.
- // It is used to detect character arrays to hexdump them.
- cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
-
- // cUnsignedCharRE is a regular expression that matches a cgo unsigned
- // char. It is used to detect unsigned character arrays to hexdump
- // them.
- cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
-
- // cUint8tCharRE is a regular expression that matches a cgo uint8_t.
- // It is used to detect uint8_t arrays to hexdump them.
- cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
-)
-
-// dumpState contains information about the state of a dump operation.
-type dumpState struct {
- w io.Writer
- depth int
- pointers map[uintptr]int
- ignoreNextType bool
- ignoreNextIndent bool
- cs *ConfigState
-}
-
-// indent performs indentation according to the depth level and cs.Indent
-// option.
-func (d *dumpState) indent() {
- if d.ignoreNextIndent {
- d.ignoreNextIndent = false
- return
- }
- d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
- if v.Kind() == reflect.Interface && !v.IsNil() {
- v = v.Elem()
- }
- return v
-}
-
-// dumpPtr handles formatting of pointers by indirecting them as necessary.
-func (d *dumpState) dumpPtr(v reflect.Value) {
- // Remove pointers at or below the current depth from map used to detect
- // circular refs.
- for k, depth := range d.pointers {
- if depth >= d.depth {
- delete(d.pointers, k)
- }
- }
-
- // Keep list of all dereferenced pointers to show later.
- pointerChain := make([]uintptr, 0)
-
- // Figure out how many levels of indirection there are by dereferencing
- // pointers and unpacking interfaces down the chain while detecting circular
- // references.
- nilFound := false
- cycleFound := false
- indirects := 0
- ve := v
- for ve.Kind() == reflect.Ptr {
- if ve.IsNil() {
- nilFound = true
- break
- }
- indirects++
- addr := ve.Pointer()
- pointerChain = append(pointerChain, addr)
- if pd, ok := d.pointers[addr]; ok && pd < d.depth {
- cycleFound = true
- indirects--
- break
- }
- d.pointers[addr] = d.depth
-
- ve = ve.Elem()
- if ve.Kind() == reflect.Interface {
- if ve.IsNil() {
- nilFound = true
- break
- }
- ve = ve.Elem()
- }
- }
-
- // Display type information.
- d.w.Write(openParenBytes)
- d.w.Write(bytes.Repeat(asteriskBytes, indirects))
- d.w.Write([]byte(ve.Type().String()))
- d.w.Write(closeParenBytes)
-
- // Display pointer information.
- if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
- d.w.Write(openParenBytes)
- for i, addr := range pointerChain {
- if i > 0 {
- d.w.Write(pointerChainBytes)
- }
- printHexPtr(d.w, addr)
- }
- d.w.Write(closeParenBytes)
- }
-
- // Display dereferenced value.
- d.w.Write(openParenBytes)
- switch {
- case nilFound:
- d.w.Write(nilAngleBytes)
-
- case cycleFound:
- d.w.Write(circularBytes)
-
- default:
- d.ignoreNextType = true
- d.dump(ve)
- }
- d.w.Write(closeParenBytes)
-}
-
-// dumpSlice handles formatting of arrays and slices. Byte (uint8 under
-// reflection) arrays and slices are dumped in hexdump -C fashion.
-func (d *dumpState) dumpSlice(v reflect.Value) {
- // Determine whether this type should be hex dumped or not. Also,
- // for types which should be hexdumped, try to use the underlying data
- // first, then fall back to trying to convert them to a uint8 slice.
- var buf []uint8
- doConvert := false
- doHexDump := false
- numEntries := v.Len()
- if numEntries > 0 {
- vt := v.Index(0).Type()
- vts := vt.String()
- switch {
- // C types that need to be converted.
- case cCharRE.MatchString(vts):
- fallthrough
- case cUnsignedCharRE.MatchString(vts):
- fallthrough
- case cUint8tCharRE.MatchString(vts):
- doConvert = true
-
- // Try to use existing uint8 slices and fall back to converting
- // and copying if that fails.
- case vt.Kind() == reflect.Uint8:
- // We need an addressable interface to convert the type
- // to a byte slice. However, the reflect package won't
- // give us an interface on certain things like
- // unexported struct fields in order to enforce
- // visibility rules. We use unsafe, when available, to
- // bypass these restrictions since this package does not
- // mutate the values.
- vs := v
- if !vs.CanInterface() || !vs.CanAddr() {
- vs = unsafeReflectValue(vs)
- }
- if !UnsafeDisabled {
- vs = vs.Slice(0, numEntries)
-
- // Use the existing uint8 slice if it can be
- // type asserted.
- iface := vs.Interface()
- if slice, ok := iface.([]uint8); ok {
- buf = slice
- doHexDump = true
- break
- }
- }
-
- // The underlying data needs to be converted if it can't
- // be type asserted to a uint8 slice.
- doConvert = true
- }
-
- // Copy and convert the underlying type if needed.
- if doConvert && vt.ConvertibleTo(uint8Type) {
- // Convert and copy each element into a uint8 byte
- // slice.
- buf = make([]uint8, numEntries)
- for i := 0; i < numEntries; i++ {
- vv := v.Index(i)
- buf[i] = uint8(vv.Convert(uint8Type).Uint())
- }
- doHexDump = true
- }
- }
-
- // Hexdump the entire slice as needed.
- if doHexDump {
- indent := strings.Repeat(d.cs.Indent, d.depth)
- str := indent + hex.Dump(buf)
- str = strings.Replace(str, "\n", "\n"+indent, -1)
- str = strings.TrimRight(str, d.cs.Indent)
- d.w.Write([]byte(str))
- return
- }
-
- // Recursively call dump for each item.
- for i := 0; i < numEntries; i++ {
- d.dump(d.unpackValue(v.Index(i)))
- if i < (numEntries - 1) {
- d.w.Write(commaNewlineBytes)
- } else {
- d.w.Write(newlineBytes)
- }
- }
-}
-
-// dump is the main workhorse for dumping a value. It uses the passed reflect
-// value to figure out what kind of object we are dealing with and formats it
-// appropriately. It is a recursive function, however circular data structures
-// are detected and handled properly.
-func (d *dumpState) dump(v reflect.Value) {
- // Handle invalid reflect values immediately.
- kind := v.Kind()
- if kind == reflect.Invalid {
- d.w.Write(invalidAngleBytes)
- return
- }
-
- // Handle pointers specially.
- if kind == reflect.Ptr {
- d.indent()
- d.dumpPtr(v)
- return
- }
-
- // Print type information unless already handled elsewhere.
- if !d.ignoreNextType {
- d.indent()
- d.w.Write(openParenBytes)
- d.w.Write([]byte(v.Type().String()))
- d.w.Write(closeParenBytes)
- d.w.Write(spaceBytes)
- }
- d.ignoreNextType = false
-
- // Display length and capacity if the built-in len and cap functions
- // work with the value's kind and the len/cap itself is non-zero.
- valueLen, valueCap := 0, 0
- switch v.Kind() {
- case reflect.Array, reflect.Slice, reflect.Chan:
- valueLen, valueCap = v.Len(), v.Cap()
- case reflect.Map, reflect.String:
- valueLen = v.Len()
- }
- if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
- d.w.Write(openParenBytes)
- if valueLen != 0 {
- d.w.Write(lenEqualsBytes)
- printInt(d.w, int64(valueLen), 10)
- }
- if !d.cs.DisableCapacities && valueCap != 0 {
- if valueLen != 0 {
- d.w.Write(spaceBytes)
- }
- d.w.Write(capEqualsBytes)
- printInt(d.w, int64(valueCap), 10)
- }
- d.w.Write(closeParenBytes)
- d.w.Write(spaceBytes)
- }
-
- // Call Stringer/error interfaces if they exist and the handle methods flag
- // is enabled
- if !d.cs.DisableMethods {
- if (kind != reflect.Invalid) && (kind != reflect.Interface) {
- if handled := handleMethods(d.cs, d.w, v); handled {
- return
- }
- }
- }
-
- switch kind {
- case reflect.Invalid:
- // Do nothing. We should never get here since invalid has already
- // been handled above.
-
- case reflect.Bool:
- printBool(d.w, v.Bool())
-
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
- printInt(d.w, v.Int(), 10)
-
- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
- printUint(d.w, v.Uint(), 10)
-
- case reflect.Float32:
- printFloat(d.w, v.Float(), 32)
-
- case reflect.Float64:
- printFloat(d.w, v.Float(), 64)
-
- case reflect.Complex64:
- printComplex(d.w, v.Complex(), 32)
-
- case reflect.Complex128:
- printComplex(d.w, v.Complex(), 64)
-
- case reflect.Slice:
- if v.IsNil() {
- d.w.Write(nilAngleBytes)
- break
- }
- fallthrough
-
- case reflect.Array:
- d.w.Write(openBraceNewlineBytes)
- d.depth++
- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
- d.indent()
- d.w.Write(maxNewlineBytes)
- } else {
- d.dumpSlice(v)
- }
- d.depth--
- d.indent()
- d.w.Write(closeBraceBytes)
-
- case reflect.String:
- d.w.Write([]byte(strconv.Quote(v.String())))
-
- case reflect.Interface:
- // The only time we should get here is for nil interfaces due to
- // unpackValue calls.
- if v.IsNil() {
- d.w.Write(nilAngleBytes)
- }
-
- case reflect.Ptr:
- // Do nothing. We should never get here since pointers have already
- // been handled above.
-
- case reflect.Map:
- // nil maps should be indicated as different than empty maps
- if v.IsNil() {
- d.w.Write(nilAngleBytes)
- break
- }
-
- d.w.Write(openBraceNewlineBytes)
- d.depth++
- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
- d.indent()
- d.w.Write(maxNewlineBytes)
- } else {
- numEntries := v.Len()
- keys := v.MapKeys()
- if d.cs.SortKeys {
- sortValues(keys, d.cs)
- }
- for i, key := range keys {
- d.dump(d.unpackValue(key))
- d.w.Write(colonSpaceBytes)
- d.ignoreNextIndent = true
- d.dump(d.unpackValue(v.MapIndex(key)))
- if i < (numEntries - 1) {
- d.w.Write(commaNewlineBytes)
- } else {
- d.w.Write(newlineBytes)
- }
- }
- }
- d.depth--
- d.indent()
- d.w.Write(closeBraceBytes)
-
- case reflect.Struct:
- d.w.Write(openBraceNewlineBytes)
- d.depth++
- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
- d.indent()
- d.w.Write(maxNewlineBytes)
- } else {
- vt := v.Type()
- numFields := v.NumField()
- for i := 0; i < numFields; i++ {
- d.indent()
- vtf := vt.Field(i)
- d.w.Write([]byte(vtf.Name))
- d.w.Write(colonSpaceBytes)
- d.ignoreNextIndent = true
- d.dump(d.unpackValue(v.Field(i)))
- if i < (numFields - 1) {
- d.w.Write(commaNewlineBytes)
- } else {
- d.w.Write(newlineBytes)
- }
- }
- }
- d.depth--
- d.indent()
- d.w.Write(closeBraceBytes)
-
- case reflect.Uintptr:
- printHexPtr(d.w, uintptr(v.Uint()))
-
- case reflect.UnsafePointer, reflect.Chan, reflect.Func:
- printHexPtr(d.w, v.Pointer())
-
- // There were not any other types at the time this code was written, but
- // fall back to letting the default fmt package handle it in case any new
- // types are added.
- default:
- if v.CanInterface() {
- fmt.Fprintf(d.w, "%v", v.Interface())
- } else {
- fmt.Fprintf(d.w, "%v", v.String())
- }
- }
-}
-
-// fdump is a helper function to consolidate the logic from the various public
-// methods which take varying writers and config states.
-func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
- for _, arg := range a {
- if arg == nil {
- w.Write(interfaceBytes)
- w.Write(spaceBytes)
- w.Write(nilAngleBytes)
- w.Write(newlineBytes)
- continue
- }
-
- d := dumpState{w: w, cs: cs}
- d.pointers = make(map[uintptr]int)
- d.dump(reflect.ValueOf(arg))
- d.w.Write(newlineBytes)
- }
-}
-
-// Fdump formats and displays the passed arguments to io.Writer w. It formats
-// exactly the same as Dump.
-func Fdump(w io.Writer, a ...interface{}) {
- fdump(&Config, w, a...)
-}
-
-// Sdump returns a string with the passed arguments formatted exactly the same
-// as Dump.
-func Sdump(a ...interface{}) string {
- var buf bytes.Buffer
- fdump(&Config, &buf, a...)
- return buf.String()
-}
-
-/*
-Dump displays the passed parameters to standard out with newlines, customizable
-indentation, and additional debug information such as complete types and all
-pointer addresses used to indirect to the final value. It provides the
-following features over the built-in printing facilities provided by the fmt
-package:
-
- * Pointers are dereferenced and followed
- * Circular data structures are detected and handled properly
- * Custom Stringer/error interfaces are optionally invoked, including
- on unexported types
- * Custom types which only implement the Stringer/error interfaces via
- a pointer receiver are optionally invoked when passing non-pointer
- variables
- * Byte arrays and slices are dumped like the hexdump -C command which
- includes offsets, byte values in hex, and ASCII output
-
-The configuration options are controlled by an exported package global,
-spew.Config. See ConfigState for options documentation.
-
-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
-get the formatted result as a string.
-*/
-func Dump(a ...interface{}) {
- fdump(&Config, os.Stdout, a...)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump_test.go
deleted file mode 100644
index 4a31a2ee37fe536c16666e01b405a83a1760e7fa..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dump_test.go
+++ /dev/null
@@ -1,1042 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Test Summary:
-NOTE: For each test, a nil pointer, a single pointer and double pointer to the
-base test element are also tested to ensure proper indirection across all types.
-
-- Max int8, int16, int32, int64, int
-- Max uint8, uint16, uint32, uint64, uint
-- Boolean true and false
-- Standard complex64 and complex128
-- Array containing standard ints
-- Array containing type with custom formatter on pointer receiver only
-- Array containing interfaces
-- Array containing bytes
-- Slice containing standard float32 values
-- Slice containing type with custom formatter on pointer receiver only
-- Slice containing interfaces
-- Slice containing bytes
-- Nil slice
-- Standard string
-- Nil interface
-- Sub-interface
-- Map with string keys and int vals
-- Map with custom formatter type on pointer receiver only keys and vals
-- Map with interface keys and values
-- Map with nil interface value
-- Struct with primitives
-- Struct that contains another struct
-- Struct that contains custom type with Stringer pointer interface via both
- exported and unexported fields
-- Struct that contains embedded struct and field to same struct
-- Uintptr to 0 (null pointer)
-- Uintptr address of real variable
-- Unsafe.Pointer to 0 (null pointer)
-- Unsafe.Pointer to address of real variable
-- Nil channel
-- Standard int channel
-- Function with no params and no returns
-- Function with param and no returns
-- Function with multiple params and multiple returns
-- Struct that is circular through self referencing
-- Structs that are circular through cross referencing
-- Structs that are indirectly circular
-- Type that panics in its Stringer interface
-*/
-
-package spew_test
-
-import (
- "bytes"
- "fmt"
- "testing"
- "unsafe"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-// dumpTest is used to describe a test to be performed against the Dump method.
-type dumpTest struct {
- in interface{}
- wants []string
-}
-
-// dumpTests houses all of the tests to be performed against the Dump method.
-var dumpTests = make([]dumpTest, 0)
-
-// addDumpTest is a helper method to append the passed input and desired result
-// to dumpTests
-func addDumpTest(in interface{}, wants ...string) {
- test := dumpTest{in, wants}
- dumpTests = append(dumpTests, test)
-}
-
-func addIntDumpTests() {
- // Max int8.
- v := int8(127)
- nv := (*int8)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "int8"
- vs := "127"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Max int16.
- v2 := int16(32767)
- nv2 := (*int16)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "int16"
- v2s := "32767"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-
- // Max int32.
- v3 := int32(2147483647)
- nv3 := (*int32)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "int32"
- v3s := "2147483647"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-
- // Max int64.
- v4 := int64(9223372036854775807)
- nv4 := (*int64)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "int64"
- v4s := "9223372036854775807"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
-
- // Max int.
- v5 := int(2147483647)
- nv5 := (*int)(nil)
- pv5 := &v5
- v5Addr := fmt.Sprintf("%p", pv5)
- pv5Addr := fmt.Sprintf("%p", &pv5)
- v5t := "int"
- v5s := "2147483647"
- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
-}
-
-func addUintDumpTests() {
- // Max uint8.
- v := uint8(255)
- nv := (*uint8)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "uint8"
- vs := "255"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Max uint16.
- v2 := uint16(65535)
- nv2 := (*uint16)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uint16"
- v2s := "65535"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-
- // Max uint32.
- v3 := uint32(4294967295)
- nv3 := (*uint32)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "uint32"
- v3s := "4294967295"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-
- // Max uint64.
- v4 := uint64(18446744073709551615)
- nv4 := (*uint64)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "uint64"
- v4s := "18446744073709551615"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
-
- // Max uint.
- v5 := uint(4294967295)
- nv5 := (*uint)(nil)
- pv5 := &v5
- v5Addr := fmt.Sprintf("%p", pv5)
- pv5Addr := fmt.Sprintf("%p", &pv5)
- v5t := "uint"
- v5s := "4294967295"
- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
-}
-
-func addBoolDumpTests() {
- // Boolean true.
- v := bool(true)
- nv := (*bool)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "bool"
- vs := "true"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Boolean false.
- v2 := bool(false)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "bool"
- v2s := "false"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
-}
-
-func addFloatDumpTests() {
- // Standard float32.
- v := float32(3.1415)
- nv := (*float32)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "float32"
- vs := "3.1415"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Standard float64.
- v2 := float64(3.1415926)
- nv2 := (*float64)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "float64"
- v2s := "3.1415926"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-}
-
-func addComplexDumpTests() {
- // Standard complex64.
- v := complex(float32(6), -2)
- nv := (*complex64)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "complex64"
- vs := "(6-2i)"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Standard complex128.
- v2 := complex(float64(-6), 2)
- nv2 := (*complex128)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "complex128"
- v2s := "(-6+2i)"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-}
-
-func addArrayDumpTests() {
- // Array containing standard ints.
- v := [3]int{1, 2, 3}
- vLen := fmt.Sprintf("%d", len(v))
- vCap := fmt.Sprintf("%d", cap(v))
- nv := (*[3]int)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "int"
- vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 1,\n (" +
- vt + ") 2,\n (" + vt + ") 3\n}"
- addDumpTest(v, "([3]"+vt+") "+vs+"\n")
- addDumpTest(pv, "(*[3]"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**[3]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*[3]"+vt+")(<nil>)\n")
-
- // Array containing type with custom formatter on pointer receiver only.
- v2i0 := pstringer("1")
- v2i1 := pstringer("2")
- v2i2 := pstringer("3")
- v2 := [3]pstringer{v2i0, v2i1, v2i2}
- v2i0Len := fmt.Sprintf("%d", len(v2i0))
- v2i1Len := fmt.Sprintf("%d", len(v2i1))
- v2i2Len := fmt.Sprintf("%d", len(v2i2))
- v2Len := fmt.Sprintf("%d", len(v2))
- v2Cap := fmt.Sprintf("%d", cap(v2))
- nv2 := (*[3]pstringer)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.pstringer"
- v2sp := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
- ") (len=" + v2i0Len + ") stringer 1,\n (" + v2t +
- ") (len=" + v2i1Len + ") stringer 2,\n (" + v2t +
- ") (len=" + v2i2Len + ") " + "stringer 3\n}"
- v2s := v2sp
- if spew.UnsafeDisabled {
- v2s = "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
- ") (len=" + v2i0Len + ") \"1\",\n (" + v2t + ") (len=" +
- v2i1Len + ") \"2\",\n (" + v2t + ") (len=" + v2i2Len +
- ") " + "\"3\"\n}"
- }
- addDumpTest(v2, "([3]"+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*[3]"+v2t+")("+v2Addr+")("+v2sp+")\n")
- addDumpTest(&pv2, "(**[3]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2sp+")\n")
- addDumpTest(nv2, "(*[3]"+v2t+")(<nil>)\n")
-
- // Array containing interfaces.
- v3i0 := "one"
- v3 := [3]interface{}{v3i0, int(2), uint(3)}
- v3i0Len := fmt.Sprintf("%d", len(v3i0))
- v3Len := fmt.Sprintf("%d", len(v3))
- v3Cap := fmt.Sprintf("%d", cap(v3))
- nv3 := (*[3]interface{})(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "[3]interface {}"
- v3t2 := "string"
- v3t3 := "int"
- v3t4 := "uint"
- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
- "(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
- v3t4 + ") 3\n}"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-
- // Array containing bytes.
- v4 := [34]byte{
- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
- 0x31, 0x32,
- }
- v4Len := fmt.Sprintf("%d", len(v4))
- v4Cap := fmt.Sprintf("%d", cap(v4))
- nv4 := (*[34]byte)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "[34]uint8"
- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
- "{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
- " |............... |\n" +
- " 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
- " |!\"#$%&'()*+,-./0|\n" +
- " 00000020 31 32 " +
- " |12|\n}"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
-}
-
-func addSliceDumpTests() {
- // Slice containing standard float32 values.
- v := []float32{3.14, 6.28, 12.56}
- vLen := fmt.Sprintf("%d", len(v))
- vCap := fmt.Sprintf("%d", cap(v))
- nv := (*[]float32)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "float32"
- vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 3.14,\n (" +
- vt + ") 6.28,\n (" + vt + ") 12.56\n}"
- addDumpTest(v, "([]"+vt+") "+vs+"\n")
- addDumpTest(pv, "(*[]"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**[]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*[]"+vt+")(<nil>)\n")
-
- // Slice containing type with custom formatter on pointer receiver only.
- v2i0 := pstringer("1")
- v2i1 := pstringer("2")
- v2i2 := pstringer("3")
- v2 := []pstringer{v2i0, v2i1, v2i2}
- v2i0Len := fmt.Sprintf("%d", len(v2i0))
- v2i1Len := fmt.Sprintf("%d", len(v2i1))
- v2i2Len := fmt.Sprintf("%d", len(v2i2))
- v2Len := fmt.Sprintf("%d", len(v2))
- v2Cap := fmt.Sprintf("%d", cap(v2))
- nv2 := (*[]pstringer)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.pstringer"
- v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
- v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
- ") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
- "stringer 3\n}"
- addDumpTest(v2, "([]"+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*[]"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**[]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*[]"+v2t+")(<nil>)\n")
-
- // Slice containing interfaces.
- v3i0 := "one"
- v3 := []interface{}{v3i0, int(2), uint(3), nil}
- v3i0Len := fmt.Sprintf("%d", len(v3i0))
- v3Len := fmt.Sprintf("%d", len(v3))
- v3Cap := fmt.Sprintf("%d", cap(v3))
- nv3 := (*[]interface{})(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "[]interface {}"
- v3t2 := "string"
- v3t3 := "int"
- v3t4 := "uint"
- v3t5 := "interface {}"
- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
- "(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
- v3t4 + ") 3,\n (" + v3t5 + ") <nil>\n}"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-
- // Slice containing bytes.
- v4 := []byte{
- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
- 0x31, 0x32,
- }
- v4Len := fmt.Sprintf("%d", len(v4))
- v4Cap := fmt.Sprintf("%d", cap(v4))
- nv4 := (*[]byte)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "[]uint8"
- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
- "{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
- " |............... |\n" +
- " 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
- " |!\"#$%&'()*+,-./0|\n" +
- " 00000020 31 32 " +
- " |12|\n}"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
-
- // Nil slice.
- v5 := []int(nil)
- nv5 := (*[]int)(nil)
- pv5 := &v5
- v5Addr := fmt.Sprintf("%p", pv5)
- pv5Addr := fmt.Sprintf("%p", &pv5)
- v5t := "[]int"
- v5s := "<nil>"
- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
-}
-
-func addStringDumpTests() {
- // Standard string.
- v := "test"
- vLen := fmt.Sprintf("%d", len(v))
- nv := (*string)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "string"
- vs := "(len=" + vLen + ") \"test\""
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-}
-
-func addInterfaceDumpTests() {
- // Nil interface.
- var v interface{}
- nv := (*interface{})(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "interface {}"
- vs := "<nil>"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Sub-interface.
- v2 := interface{}(uint16(65535))
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uint16"
- v2s := "65535"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
-}
-
-func addMapDumpTests() {
- // Map with string keys and int vals.
- k := "one"
- kk := "two"
- m := map[string]int{k: 1, kk: 2}
- klen := fmt.Sprintf("%d", len(k)) // not kLen to shut golint up
- kkLen := fmt.Sprintf("%d", len(kk))
- mLen := fmt.Sprintf("%d", len(m))
- nilMap := map[string]int(nil)
- nm := (*map[string]int)(nil)
- pm := &m
- mAddr := fmt.Sprintf("%p", pm)
- pmAddr := fmt.Sprintf("%p", &pm)
- mt := "map[string]int"
- mt1 := "string"
- mt2 := "int"
- ms := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + klen + ") " +
- "\"one\": (" + mt2 + ") 1,\n (" + mt1 + ") (len=" + kkLen +
- ") \"two\": (" + mt2 + ") 2\n}"
- ms2 := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + kkLen + ") " +
- "\"two\": (" + mt2 + ") 2,\n (" + mt1 + ") (len=" + klen +
- ") \"one\": (" + mt2 + ") 1\n}"
- addDumpTest(m, "("+mt+") "+ms+"\n", "("+mt+") "+ms2+"\n")
- addDumpTest(pm, "(*"+mt+")("+mAddr+")("+ms+")\n",
- "(*"+mt+")("+mAddr+")("+ms2+")\n")
- addDumpTest(&pm, "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms+")\n",
- "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms2+")\n")
- addDumpTest(nm, "(*"+mt+")(<nil>)\n")
- addDumpTest(nilMap, "("+mt+") <nil>\n")
-
- // Map with custom formatter type on pointer receiver only keys and vals.
- k2 := pstringer("one")
- v2 := pstringer("1")
- m2 := map[pstringer]pstringer{k2: v2}
- k2Len := fmt.Sprintf("%d", len(k2))
- v2Len := fmt.Sprintf("%d", len(v2))
- m2Len := fmt.Sprintf("%d", len(m2))
- nilMap2 := map[pstringer]pstringer(nil)
- nm2 := (*map[pstringer]pstringer)(nil)
- pm2 := &m2
- m2Addr := fmt.Sprintf("%p", pm2)
- pm2Addr := fmt.Sprintf("%p", &pm2)
- m2t := "map[spew_test.pstringer]spew_test.pstringer"
- m2t1 := "spew_test.pstringer"
- m2t2 := "spew_test.pstringer"
- m2s := "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len + ") " +
- "stringer one: (" + m2t2 + ") (len=" + v2Len + ") stringer 1\n}"
- if spew.UnsafeDisabled {
- m2s = "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len +
- ") " + "\"one\": (" + m2t2 + ") (len=" + v2Len +
- ") \"1\"\n}"
- }
- addDumpTest(m2, "("+m2t+") "+m2s+"\n")
- addDumpTest(pm2, "(*"+m2t+")("+m2Addr+")("+m2s+")\n")
- addDumpTest(&pm2, "(**"+m2t+")("+pm2Addr+"->"+m2Addr+")("+m2s+")\n")
- addDumpTest(nm2, "(*"+m2t+")(<nil>)\n")
- addDumpTest(nilMap2, "("+m2t+") <nil>\n")
-
- // Map with interface keys and values.
- k3 := "one"
- k3Len := fmt.Sprintf("%d", len(k3))
- m3 := map[interface{}]interface{}{k3: 1}
- m3Len := fmt.Sprintf("%d", len(m3))
- nilMap3 := map[interface{}]interface{}(nil)
- nm3 := (*map[interface{}]interface{})(nil)
- pm3 := &m3
- m3Addr := fmt.Sprintf("%p", pm3)
- pm3Addr := fmt.Sprintf("%p", &pm3)
- m3t := "map[interface {}]interface {}"
- m3t1 := "string"
- m3t2 := "int"
- m3s := "(len=" + m3Len + ") {\n (" + m3t1 + ") (len=" + k3Len + ") " +
- "\"one\": (" + m3t2 + ") 1\n}"
- addDumpTest(m3, "("+m3t+") "+m3s+"\n")
- addDumpTest(pm3, "(*"+m3t+")("+m3Addr+")("+m3s+")\n")
- addDumpTest(&pm3, "(**"+m3t+")("+pm3Addr+"->"+m3Addr+")("+m3s+")\n")
- addDumpTest(nm3, "(*"+m3t+")(<nil>)\n")
- addDumpTest(nilMap3, "("+m3t+") <nil>\n")
-
- // Map with nil interface value.
- k4 := "nil"
- k4Len := fmt.Sprintf("%d", len(k4))
- m4 := map[string]interface{}{k4: nil}
- m4Len := fmt.Sprintf("%d", len(m4))
- nilMap4 := map[string]interface{}(nil)
- nm4 := (*map[string]interface{})(nil)
- pm4 := &m4
- m4Addr := fmt.Sprintf("%p", pm4)
- pm4Addr := fmt.Sprintf("%p", &pm4)
- m4t := "map[string]interface {}"
- m4t1 := "string"
- m4t2 := "interface {}"
- m4s := "(len=" + m4Len + ") {\n (" + m4t1 + ") (len=" + k4Len + ")" +
- " \"nil\": (" + m4t2 + ") <nil>\n}"
- addDumpTest(m4, "("+m4t+") "+m4s+"\n")
- addDumpTest(pm4, "(*"+m4t+")("+m4Addr+")("+m4s+")\n")
- addDumpTest(&pm4, "(**"+m4t+")("+pm4Addr+"->"+m4Addr+")("+m4s+")\n")
- addDumpTest(nm4, "(*"+m4t+")(<nil>)\n")
- addDumpTest(nilMap4, "("+m4t+") <nil>\n")
-}
-
-func addStructDumpTests() {
- // Struct with primitives.
- type s1 struct {
- a int8
- b uint8
- }
- v := s1{127, 255}
- nv := (*s1)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.s1"
- vt2 := "int8"
- vt3 := "uint8"
- vs := "{\n a: (" + vt2 + ") 127,\n b: (" + vt3 + ") 255\n}"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Struct that contains another struct.
- type s2 struct {
- s1 s1
- b bool
- }
- v2 := s2{s1{127, 255}, true}
- nv2 := (*s2)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.s2"
- v2t2 := "spew_test.s1"
- v2t3 := "int8"
- v2t4 := "uint8"
- v2t5 := "bool"
- v2s := "{\n s1: (" + v2t2 + ") {\n a: (" + v2t3 + ") 127,\n b: (" +
- v2t4 + ") 255\n },\n b: (" + v2t5 + ") true\n}"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-
- // Struct that contains custom type with Stringer pointer interface via both
- // exported and unexported fields.
- type s3 struct {
- s pstringer
- S pstringer
- }
- v3 := s3{"test", "test2"}
- nv3 := (*s3)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "spew_test.s3"
- v3t2 := "spew_test.pstringer"
- v3s := "{\n s: (" + v3t2 + ") (len=4) stringer test,\n S: (" + v3t2 +
- ") (len=5) stringer test2\n}"
- v3sp := v3s
- if spew.UnsafeDisabled {
- v3s = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
- v3t2 + ") (len=5) \"test2\"\n}"
- v3sp = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
- v3t2 + ") (len=5) stringer test2\n}"
- }
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3sp+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3sp+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-
- // Struct that contains embedded struct and field to same struct.
- e := embed{"embedstr"}
- eLen := fmt.Sprintf("%d", len("embedstr"))
- v4 := embedwrap{embed: &e, e: &e}
- nv4 := (*embedwrap)(nil)
- pv4 := &v4
- eAddr := fmt.Sprintf("%p", &e)
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "spew_test.embedwrap"
- v4t2 := "spew_test.embed"
- v4t3 := "string"
- v4s := "{\n embed: (*" + v4t2 + ")(" + eAddr + ")({\n a: (" + v4t3 +
- ") (len=" + eLen + ") \"embedstr\"\n }),\n e: (*" + v4t2 +
- ")(" + eAddr + ")({\n a: (" + v4t3 + ") (len=" + eLen + ")" +
- " \"embedstr\"\n })\n}"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
-}
-
-func addUintptrDumpTests() {
- // Null pointer.
- v := uintptr(0)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "uintptr"
- vs := "<nil>"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
-
- // Address of real variable.
- i := 1
- v2 := uintptr(unsafe.Pointer(&i))
- nv2 := (*uintptr)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uintptr"
- v2s := fmt.Sprintf("%p", &i)
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-}
-
-func addUnsafePointerDumpTests() {
- // Null pointer.
- v := unsafe.Pointer(nil)
- nv := (*unsafe.Pointer)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "unsafe.Pointer"
- vs := "<nil>"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Address of real variable.
- i := 1
- v2 := unsafe.Pointer(&i)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "unsafe.Pointer"
- v2s := fmt.Sprintf("%p", &i)
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-}
-
-func addChanDumpTests() {
- // Nil channel.
- var v chan int
- pv := &v
- nv := (*chan int)(nil)
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "chan int"
- vs := "<nil>"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Real channel.
- v2 := make(chan int)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "chan int"
- v2s := fmt.Sprintf("%p", v2)
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
-}
-
-func addFuncDumpTests() {
- // Function with no params and no returns.
- v := addIntDumpTests
- nv := (*func())(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "func()"
- vs := fmt.Sprintf("%p", v)
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-
- // Function with param and no returns.
- v2 := TestDump
- nv2 := (*func(*testing.T))(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "func(*testing.T)"
- v2s := fmt.Sprintf("%p", v2)
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
-
- // Function with multiple params and multiple returns.
- var v3 = func(i int, s string) (b bool, err error) {
- return true, nil
- }
- nv3 := (*func(int, string) (bool, error))(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "func(int, string) (bool, error)"
- v3s := fmt.Sprintf("%p", v3)
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
-}
-
-func addCircularDumpTests() {
- // Struct that is circular through self referencing.
- type circular struct {
- c *circular
- }
- v := circular{nil}
- v.c = &v
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.circular"
- vs := "{\n c: (*" + vt + ")(" + vAddr + ")({\n c: (*" + vt + ")(" +
- vAddr + ")(<already shown>)\n })\n}"
- vs2 := "{\n c: (*" + vt + ")(" + vAddr + ")(<already shown>)\n}"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs2+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs2+")\n")
-
- // Structs that are circular through cross referencing.
- v2 := xref1{nil}
- ts2 := xref2{&v2}
- v2.ps2 = &ts2
- pv2 := &v2
- ts2Addr := fmt.Sprintf("%p", &ts2)
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.xref1"
- v2t2 := "spew_test.xref2"
- v2s := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
- ")(" + v2Addr + ")({\n ps2: (*" + v2t2 + ")(" + ts2Addr +
- ")(<already shown>)\n })\n })\n}"
- v2s2 := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
- ")(" + v2Addr + ")(<already shown>)\n })\n}"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s2+")\n")
- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s2+")\n")
-
- // Structs that are indirectly circular.
- v3 := indirCir1{nil}
- tic2 := indirCir2{nil}
- tic3 := indirCir3{&v3}
- tic2.ps3 = &tic3
- v3.ps2 = &tic2
- pv3 := &v3
- tic2Addr := fmt.Sprintf("%p", &tic2)
- tic3Addr := fmt.Sprintf("%p", &tic3)
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "spew_test.indirCir1"
- v3t2 := "spew_test.indirCir2"
- v3t3 := "spew_test.indirCir3"
- v3s := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
- ")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
- ")({\n ps2: (*" + v3t2 + ")(" + tic2Addr +
- ")(<already shown>)\n })\n })\n })\n}"
- v3s2 := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
- ")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
- ")(<already shown>)\n })\n })\n}"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s2+")\n")
- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s2+")\n")
-}
-
-func addPanicDumpTests() {
- // Type that panics in its Stringer interface.
- v := panicer(127)
- nv := (*panicer)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.panicer"
- vs := "(PANIC=test panic)127"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-}
-
-func addErrorDumpTests() {
- // Type that has a custom Error interface.
- v := customError(127)
- nv := (*customError)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.customError"
- vs := "error: 127"
- addDumpTest(v, "("+vt+") "+vs+"\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
-}
-
-// TestDump executes all of the tests described by dumpTests.
-func TestDump(t *testing.T) {
- // Setup tests.
- addIntDumpTests()
- addUintDumpTests()
- addBoolDumpTests()
- addFloatDumpTests()
- addComplexDumpTests()
- addArrayDumpTests()
- addSliceDumpTests()
- addStringDumpTests()
- addInterfaceDumpTests()
- addMapDumpTests()
- addStructDumpTests()
- addUintptrDumpTests()
- addUnsafePointerDumpTests()
- addChanDumpTests()
- addFuncDumpTests()
- addCircularDumpTests()
- addPanicDumpTests()
- addErrorDumpTests()
- addCgoDumpTests()
-
- t.Logf("Running %d tests", len(dumpTests))
- for i, test := range dumpTests {
- buf := new(bytes.Buffer)
- spew.Fdump(buf, test.in)
- s := buf.String()
- if testFailed(s, test.wants) {
- t.Errorf("Dump #%d\n got: %s %s", i, s, stringizeWants(test.wants))
- continue
- }
- }
-}
-
-func TestDumpSortedKeys(t *testing.T) {
- cfg := spew.ConfigState{SortKeys: true}
- s := cfg.Sdump(map[int]string{1: "1", 3: "3", 2: "2"})
- expected := "(map[int]string) (len=3) {\n(int) 1: (string) (len=1) " +
- "\"1\",\n(int) 2: (string) (len=1) \"2\",\n(int) 3: (string) " +
- "(len=1) \"3\"\n" +
- "}\n"
- if s != expected {
- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
- }
-
- s = cfg.Sdump(map[stringer]int{"1": 1, "3": 3, "2": 2})
- expected = "(map[spew_test.stringer]int) (len=3) {\n" +
- "(spew_test.stringer) (len=1) stringer 1: (int) 1,\n" +
- "(spew_test.stringer) (len=1) stringer 2: (int) 2,\n" +
- "(spew_test.stringer) (len=1) stringer 3: (int) 3\n" +
- "}\n"
- if s != expected {
- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
- }
-
- s = cfg.Sdump(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
- expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
- "(spew_test.pstringer) (len=1) stringer 1: (int) 1,\n" +
- "(spew_test.pstringer) (len=1) stringer 2: (int) 2,\n" +
- "(spew_test.pstringer) (len=1) stringer 3: (int) 3\n" +
- "}\n"
- if spew.UnsafeDisabled {
- expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
- "(spew_test.pstringer) (len=1) \"1\": (int) 1,\n" +
- "(spew_test.pstringer) (len=1) \"2\": (int) 2,\n" +
- "(spew_test.pstringer) (len=1) \"3\": (int) 3\n" +
- "}\n"
- }
- if s != expected {
- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
- }
-
- s = cfg.Sdump(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
- expected = "(map[spew_test.customError]int) (len=3) {\n" +
- "(spew_test.customError) error: 1: (int) 1,\n" +
- "(spew_test.customError) error: 2: (int) 2,\n" +
- "(spew_test.customError) error: 3: (int) 3\n" +
- "}\n"
- if s != expected {
- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
- }
-
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpcgo_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpcgo_test.go
deleted file mode 100644
index 108baa55f1db47eddda32520e97d8a10c405ca5a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpcgo_test.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when both cgo is supported and "-tags testcgo" is added to the go test
-// command line. This means the cgo tests are only added (and hence run) when
-// specifially requested. This configuration is used because spew itself
-// does not require cgo to run even though it does handle certain cgo types
-// specially. Rather than forcing all clients to require cgo and an external
-// C compiler just to run the tests, this scheme makes them optional.
-// +build cgo,testcgo
-
-package spew_test
-
-import (
- "fmt"
-
- "github.com/davecgh/go-spew/spew/testdata"
-)
-
-func addCgoDumpTests() {
- // C char pointer.
- v := testdata.GetCgoCharPointer()
- nv := testdata.GetCgoNullCharPointer()
- pv := &v
- vcAddr := fmt.Sprintf("%p", v)
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "*testdata._Ctype_char"
- vs := "116"
- addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
- addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
- addDumpTest(nv, "("+vt+")(<nil>)\n")
-
- // C char array.
- v2, v2l, v2c := testdata.GetCgoCharArray()
- v2Len := fmt.Sprintf("%d", v2l)
- v2Cap := fmt.Sprintf("%d", v2c)
- v2t := "[6]testdata._Ctype_char"
- v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
- "{\n 00000000 74 65 73 74 32 00 " +
- " |test2.|\n}"
- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
-
- // C unsigned char array.
- v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
- v3Len := fmt.Sprintf("%d", v3l)
- v3Cap := fmt.Sprintf("%d", v3c)
- v3t := "[6]testdata._Ctype_unsignedchar"
- v3t2 := "[6]testdata._Ctype_uchar"
- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
- "{\n 00000000 74 65 73 74 33 00 " +
- " |test3.|\n}"
- addDumpTest(v3, "("+v3t+") "+v3s+"\n", "("+v3t2+") "+v3s+"\n")
-
- // C signed char array.
- v4, v4l, v4c := testdata.GetCgoSignedCharArray()
- v4Len := fmt.Sprintf("%d", v4l)
- v4Cap := fmt.Sprintf("%d", v4c)
- v4t := "[6]testdata._Ctype_schar"
- v4t2 := "testdata._Ctype_schar"
- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
- "{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
- ") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
- ") 0\n}"
- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
-
- // C uint8_t array.
- v5, v5l, v5c := testdata.GetCgoUint8tArray()
- v5Len := fmt.Sprintf("%d", v5l)
- v5Cap := fmt.Sprintf("%d", v5c)
- v5t := "[6]testdata._Ctype_uint8_t"
- v5t2 := "[6]testdata._Ctype_uchar"
- v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
- "{\n 00000000 74 65 73 74 35 00 " +
- " |test5.|\n}"
- addDumpTest(v5, "("+v5t+") "+v5s+"\n", "("+v5t2+") "+v5s+"\n")
-
- // C typedefed unsigned char array.
- v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
- v6Len := fmt.Sprintf("%d", v6l)
- v6Cap := fmt.Sprintf("%d", v6c)
- v6t := "[6]testdata._Ctype_custom_uchar_t"
- v6t2 := "[6]testdata._Ctype_uchar"
- v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
- "{\n 00000000 74 65 73 74 36 00 " +
- " |test6.|\n}"
- addDumpTest(v6, "("+v6t+") "+v6s+"\n", "("+v6t2+") "+v6s+"\n")
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpnocgo_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpnocgo_test.go
deleted file mode 100644
index 52a0971fb3f1f4c712d485ddc64f918567d508ab..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/dumpnocgo_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2013 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when either cgo is not supported or "-tags testcgo" is not added to the go
-// test command line. This file intentionally does not setup any cgo tests in
-// this scenario.
-// +build !cgo !testcgo
-
-package spew_test
-
-func addCgoDumpTests() {
- // Don't add any tests for cgo since this file is only compiled when
- // there should not be any cgo tests.
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/example_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/example_test.go
deleted file mode 100644
index c6ec8c6d59e0169f58fec1c92ce1b2a3205c4bf5..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/example_test.go
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew_test
-
-import (
- "fmt"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-type Flag int
-
-const (
- flagOne Flag = iota
- flagTwo
-)
-
-var flagStrings = map[Flag]string{
- flagOne: "flagOne",
- flagTwo: "flagTwo",
-}
-
-func (f Flag) String() string {
- if s, ok := flagStrings[f]; ok {
- return s
- }
- return fmt.Sprintf("Unknown flag (%d)", int(f))
-}
-
-type Bar struct {
- data uintptr
-}
-
-type Foo struct {
- unexportedField Bar
- ExportedField map[interface{}]interface{}
-}
-
-// This example demonstrates how to use Dump to dump variables to stdout.
-func ExampleDump() {
- // The following package level declarations are assumed for this example:
- /*
- type Flag int
-
- const (
- flagOne Flag = iota
- flagTwo
- )
-
- var flagStrings = map[Flag]string{
- flagOne: "flagOne",
- flagTwo: "flagTwo",
- }
-
- func (f Flag) String() string {
- if s, ok := flagStrings[f]; ok {
- return s
- }
- return fmt.Sprintf("Unknown flag (%d)", int(f))
- }
-
- type Bar struct {
- data uintptr
- }
-
- type Foo struct {
- unexportedField Bar
- ExportedField map[interface{}]interface{}
- }
- */
-
- // Setup some sample data structures for the example.
- bar := Bar{uintptr(0)}
- s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
- f := Flag(5)
- b := []byte{
- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
- 0x31, 0x32,
- }
-
- // Dump!
- spew.Dump(s1, f, b)
-
- // Output:
- // (spew_test.Foo) {
- // unexportedField: (spew_test.Bar) {
- // data: (uintptr) <nil>
- // },
- // ExportedField: (map[interface {}]interface {}) (len=1) {
- // (string) (len=3) "one": (bool) true
- // }
- // }
- // (spew_test.Flag) Unknown flag (5)
- // ([]uint8) (len=34 cap=34) {
- // 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
- // 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
- // 00000020 31 32 |12|
- // }
- //
-}
-
-// This example demonstrates how to use Printf to display a variable with a
-// format string and inline formatting.
-func ExamplePrintf() {
- // Create a double pointer to a uint 8.
- ui8 := uint8(5)
- pui8 := &ui8
- ppui8 := &pui8
-
- // Create a circular data type.
- type circular struct {
- ui8 uint8
- c *circular
- }
- c := circular{ui8: 1}
- c.c = &c
-
- // Print!
- spew.Printf("ppui8: %v\n", ppui8)
- spew.Printf("circular: %v\n", c)
-
- // Output:
- // ppui8: <**>5
- // circular: {1 <*>{1 <*><shown>}}
-}
-
-// This example demonstrates how to use a ConfigState.
-func ExampleConfigState() {
- // Modify the indent level of the ConfigState only. The global
- // configuration is not modified.
- scs := spew.ConfigState{Indent: "\t"}
-
- // Output using the ConfigState instance.
- v := map[string]int{"one": 1}
- scs.Printf("v: %v\n", v)
- scs.Dump(v)
-
- // Output:
- // v: map[one:1]
- // (map[string]int) (len=1) {
- // (string) (len=3) "one": (int) 1
- // }
-}
-
-// This example demonstrates how to use ConfigState.Dump to dump variables to
-// stdout
-func ExampleConfigState_Dump() {
- // See the top-level Dump example for details on the types used in this
- // example.
-
- // Create two ConfigState instances with different indentation.
- scs := spew.ConfigState{Indent: "\t"}
- scs2 := spew.ConfigState{Indent: " "}
-
- // Setup some sample data structures for the example.
- bar := Bar{uintptr(0)}
- s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
-
- // Dump using the ConfigState instances.
- scs.Dump(s1)
- scs2.Dump(s1)
-
- // Output:
- // (spew_test.Foo) {
- // unexportedField: (spew_test.Bar) {
- // data: (uintptr) <nil>
- // },
- // ExportedField: (map[interface {}]interface {}) (len=1) {
- // (string) (len=3) "one": (bool) true
- // }
- // }
- // (spew_test.Foo) {
- // unexportedField: (spew_test.Bar) {
- // data: (uintptr) <nil>
- // },
- // ExportedField: (map[interface {}]interface {}) (len=1) {
- // (string) (len=3) "one": (bool) true
- // }
- // }
- //
-}
-
-// This example demonstrates how to use ConfigState.Printf to display a variable
-// with a format string and inline formatting.
-func ExampleConfigState_Printf() {
- // See the top-level Dump example for details on the types used in this
- // example.
-
- // Create two ConfigState instances and modify the method handling of the
- // first ConfigState only.
- scs := spew.NewDefaultConfig()
- scs2 := spew.NewDefaultConfig()
- scs.DisableMethods = true
-
- // Alternatively
- // scs := spew.ConfigState{Indent: " ", DisableMethods: true}
- // scs2 := spew.ConfigState{Indent: " "}
-
- // This is of type Flag which implements a Stringer and has raw value 1.
- f := flagTwo
-
- // Dump using the ConfigState instances.
- scs.Printf("f: %v\n", f)
- scs2.Printf("f: %v\n", f)
-
- // Output:
- // f: 1
- // f: flagTwo
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format.go
deleted file mode 100644
index b04edb7d7ac278ae0b873a1335f37822a00bfd7c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format.go
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "strconv"
- "strings"
-)
-
-// supportedFlags is a list of all the character flags supported by fmt package.
-const supportedFlags = "0-+# "
-
-// formatState implements the fmt.Formatter interface and contains information
-// about the state of a formatting operation. The NewFormatter function can
-// be used to get a new Formatter which can be used directly as arguments
-// in standard fmt package printing calls.
-type formatState struct {
- value interface{}
- fs fmt.State
- depth int
- pointers map[uintptr]int
- ignoreNextType bool
- cs *ConfigState
-}
-
-// buildDefaultFormat recreates the original format string without precision
-// and width information to pass in to fmt.Sprintf in the case of an
-// unrecognized type. Unless new types are added to the language, this
-// function won't ever be called.
-func (f *formatState) buildDefaultFormat() (format string) {
- buf := bytes.NewBuffer(percentBytes)
-
- for _, flag := range supportedFlags {
- if f.fs.Flag(int(flag)) {
- buf.WriteRune(flag)
- }
- }
-
- buf.WriteRune('v')
-
- format = buf.String()
- return format
-}
-
-// constructOrigFormat recreates the original format string including precision
-// and width information to pass along to the standard fmt package. This allows
-// automatic deferral of all format strings this package doesn't support.
-func (f *formatState) constructOrigFormat(verb rune) (format string) {
- buf := bytes.NewBuffer(percentBytes)
-
- for _, flag := range supportedFlags {
- if f.fs.Flag(int(flag)) {
- buf.WriteRune(flag)
- }
- }
-
- if width, ok := f.fs.Width(); ok {
- buf.WriteString(strconv.Itoa(width))
- }
-
- if precision, ok := f.fs.Precision(); ok {
- buf.Write(precisionBytes)
- buf.WriteString(strconv.Itoa(precision))
- }
-
- buf.WriteRune(verb)
-
- format = buf.String()
- return format
-}
-
-// unpackValue returns values inside of non-nil interfaces when possible and
-// ensures that types for values which have been unpacked from an interface
-// are displayed when the show types flag is also set.
-// This is useful for data types like structs, arrays, slices, and maps which
-// can contain varying types packed inside an interface.
-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
- if v.Kind() == reflect.Interface {
- f.ignoreNextType = false
- if !v.IsNil() {
- v = v.Elem()
- }
- }
- return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (f *formatState) formatPtr(v reflect.Value) {
- // Display nil if top level pointer is nil.
- showTypes := f.fs.Flag('#')
- if v.IsNil() && (!showTypes || f.ignoreNextType) {
- f.fs.Write(nilAngleBytes)
- return
- }
-
- // Remove pointers at or below the current depth from map used to detect
- // circular refs.
- for k, depth := range f.pointers {
- if depth >= f.depth {
- delete(f.pointers, k)
- }
- }
-
- // Keep list of all dereferenced pointers to possibly show later.
- pointerChain := make([]uintptr, 0)
-
- // Figure out how many levels of indirection there are by derferencing
- // pointers and unpacking interfaces down the chain while detecting circular
- // references.
- nilFound := false
- cycleFound := false
- indirects := 0
- ve := v
- for ve.Kind() == reflect.Ptr {
- if ve.IsNil() {
- nilFound = true
- break
- }
- indirects++
- addr := ve.Pointer()
- pointerChain = append(pointerChain, addr)
- if pd, ok := f.pointers[addr]; ok && pd < f.depth {
- cycleFound = true
- indirects--
- break
- }
- f.pointers[addr] = f.depth
-
- ve = ve.Elem()
- if ve.Kind() == reflect.Interface {
- if ve.IsNil() {
- nilFound = true
- break
- }
- ve = ve.Elem()
- }
- }
-
- // Display type or indirection level depending on flags.
- if showTypes && !f.ignoreNextType {
- f.fs.Write(openParenBytes)
- f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
- f.fs.Write([]byte(ve.Type().String()))
- f.fs.Write(closeParenBytes)
- } else {
- if nilFound || cycleFound {
- indirects += strings.Count(ve.Type().String(), "*")
- }
- f.fs.Write(openAngleBytes)
- f.fs.Write([]byte(strings.Repeat("*", indirects)))
- f.fs.Write(closeAngleBytes)
- }
-
- // Display pointer information depending on flags.
- if f.fs.Flag('+') && (len(pointerChain) > 0) {
- f.fs.Write(openParenBytes)
- for i, addr := range pointerChain {
- if i > 0 {
- f.fs.Write(pointerChainBytes)
- }
- printHexPtr(f.fs, addr)
- }
- f.fs.Write(closeParenBytes)
- }
-
- // Display dereferenced value.
- switch {
- case nilFound:
- f.fs.Write(nilAngleBytes)
-
- case cycleFound:
- f.fs.Write(circularShortBytes)
-
- default:
- f.ignoreNextType = true
- f.format(ve)
- }
-}
-
-// format is the main workhorse for providing the Formatter interface. It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately. It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (f *formatState) format(v reflect.Value) {
- // Handle invalid reflect values immediately.
- kind := v.Kind()
- if kind == reflect.Invalid {
- f.fs.Write(invalidAngleBytes)
- return
- }
-
- // Handle pointers specially.
- if kind == reflect.Ptr {
- f.formatPtr(v)
- return
- }
-
- // Print type information unless already handled elsewhere.
- if !f.ignoreNextType && f.fs.Flag('#') {
- f.fs.Write(openParenBytes)
- f.fs.Write([]byte(v.Type().String()))
- f.fs.Write(closeParenBytes)
- }
- f.ignoreNextType = false
-
- // Call Stringer/error interfaces if they exist and the handle methods
- // flag is enabled.
- if !f.cs.DisableMethods {
- if (kind != reflect.Invalid) && (kind != reflect.Interface) {
- if handled := handleMethods(f.cs, f.fs, v); handled {
- return
- }
- }
- }
-
- switch kind {
- case reflect.Invalid:
- // Do nothing. We should never get here since invalid has already
- // been handled above.
-
- case reflect.Bool:
- printBool(f.fs, v.Bool())
-
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
- printInt(f.fs, v.Int(), 10)
-
- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
- printUint(f.fs, v.Uint(), 10)
-
- case reflect.Float32:
- printFloat(f.fs, v.Float(), 32)
-
- case reflect.Float64:
- printFloat(f.fs, v.Float(), 64)
-
- case reflect.Complex64:
- printComplex(f.fs, v.Complex(), 32)
-
- case reflect.Complex128:
- printComplex(f.fs, v.Complex(), 64)
-
- case reflect.Slice:
- if v.IsNil() {
- f.fs.Write(nilAngleBytes)
- break
- }
- fallthrough
-
- case reflect.Array:
- f.fs.Write(openBracketBytes)
- f.depth++
- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
- f.fs.Write(maxShortBytes)
- } else {
- numEntries := v.Len()
- for i := 0; i < numEntries; i++ {
- if i > 0 {
- f.fs.Write(spaceBytes)
- }
- f.ignoreNextType = true
- f.format(f.unpackValue(v.Index(i)))
- }
- }
- f.depth--
- f.fs.Write(closeBracketBytes)
-
- case reflect.String:
- f.fs.Write([]byte(v.String()))
-
- case reflect.Interface:
- // The only time we should get here is for nil interfaces due to
- // unpackValue calls.
- if v.IsNil() {
- f.fs.Write(nilAngleBytes)
- }
-
- case reflect.Ptr:
- // Do nothing. We should never get here since pointers have already
- // been handled above.
-
- case reflect.Map:
- // nil maps should be indicated as different than empty maps
- if v.IsNil() {
- f.fs.Write(nilAngleBytes)
- break
- }
-
- f.fs.Write(openMapBytes)
- f.depth++
- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
- f.fs.Write(maxShortBytes)
- } else {
- keys := v.MapKeys()
- if f.cs.SortKeys {
- sortValues(keys, f.cs)
- }
- for i, key := range keys {
- if i > 0 {
- f.fs.Write(spaceBytes)
- }
- f.ignoreNextType = true
- f.format(f.unpackValue(key))
- f.fs.Write(colonBytes)
- f.ignoreNextType = true
- f.format(f.unpackValue(v.MapIndex(key)))
- }
- }
- f.depth--
- f.fs.Write(closeMapBytes)
-
- case reflect.Struct:
- numFields := v.NumField()
- f.fs.Write(openBraceBytes)
- f.depth++
- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
- f.fs.Write(maxShortBytes)
- } else {
- vt := v.Type()
- for i := 0; i < numFields; i++ {
- if i > 0 {
- f.fs.Write(spaceBytes)
- }
- vtf := vt.Field(i)
- if f.fs.Flag('+') || f.fs.Flag('#') {
- f.fs.Write([]byte(vtf.Name))
- f.fs.Write(colonBytes)
- }
- f.format(f.unpackValue(v.Field(i)))
- }
- }
- f.depth--
- f.fs.Write(closeBraceBytes)
-
- case reflect.Uintptr:
- printHexPtr(f.fs, uintptr(v.Uint()))
-
- case reflect.UnsafePointer, reflect.Chan, reflect.Func:
- printHexPtr(f.fs, v.Pointer())
-
- // There were not any other types at the time this code was written, but
- // fall back to letting the default fmt package handle it if any get added.
- default:
- format := f.buildDefaultFormat()
- if v.CanInterface() {
- fmt.Fprintf(f.fs, format, v.Interface())
- } else {
- fmt.Fprintf(f.fs, format, v.String())
- }
- }
-}
-
-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
-// details.
-func (f *formatState) Format(fs fmt.State, verb rune) {
- f.fs = fs
-
- // Use standard formatting for verbs that are not v.
- if verb != 'v' {
- format := f.constructOrigFormat(verb)
- fmt.Fprintf(fs, format, f.value)
- return
- }
-
- if f.value == nil {
- if fs.Flag('#') {
- fs.Write(interfaceBytes)
- }
- fs.Write(nilAngleBytes)
- return
- }
-
- f.format(reflect.ValueOf(f.value))
-}
-
-// newFormatter is a helper function to consolidate the logic from the various
-// public methods which take varying config states.
-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
- fs := &formatState{value: v, cs: cs}
- fs.pointers = make(map[uintptr]int)
- return fs
-}
-
-/*
-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
-interface. As a result, it integrates cleanly with standard fmt package
-printing functions. The formatter is useful for inline printing of smaller data
-types similar to the standard %v format specifier.
-
-The custom formatter only responds to the %v (most compact), %+v (adds pointer
-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
-combinations. Any other verbs such as %x and %q will be sent to the the
-standard fmt package for formatting. In addition, the custom formatter ignores
-the width and precision arguments (however they will still work on the format
-specifiers not handled by the custom formatter).
-
-Typically this function shouldn't be called directly. It is much easier to make
-use of the custom formatter by calling one of the convenience functions such as
-Printf, Println, or Fprintf.
-*/
-func NewFormatter(v interface{}) fmt.Formatter {
- return newFormatter(&Config, v)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format_test.go
deleted file mode 100644
index 87ee9651e363b2872cdbf57ed225d5143b6c3a04..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/format_test.go
+++ /dev/null
@@ -1,1558 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-Test Summary:
-NOTE: For each test, a nil pointer, a single pointer and double pointer to the
-base test element are also tested to ensure proper indirection across all types.
-
-- Max int8, int16, int32, int64, int
-- Max uint8, uint16, uint32, uint64, uint
-- Boolean true and false
-- Standard complex64 and complex128
-- Array containing standard ints
-- Array containing type with custom formatter on pointer receiver only
-- Array containing interfaces
-- Slice containing standard float32 values
-- Slice containing type with custom formatter on pointer receiver only
-- Slice containing interfaces
-- Nil slice
-- Standard string
-- Nil interface
-- Sub-interface
-- Map with string keys and int vals
-- Map with custom formatter type on pointer receiver only keys and vals
-- Map with interface keys and values
-- Map with nil interface value
-- Struct with primitives
-- Struct that contains another struct
-- Struct that contains custom type with Stringer pointer interface via both
- exported and unexported fields
-- Struct that contains embedded struct and field to same struct
-- Uintptr to 0 (null pointer)
-- Uintptr address of real variable
-- Unsafe.Pointer to 0 (null pointer)
-- Unsafe.Pointer to address of real variable
-- Nil channel
-- Standard int channel
-- Function with no params and no returns
-- Function with param and no returns
-- Function with multiple params and multiple returns
-- Struct that is circular through self referencing
-- Structs that are circular through cross referencing
-- Structs that are indirectly circular
-- Type that panics in its Stringer interface
-- Type that has a custom Error interface
-- %x passthrough with uint
-- %#x passthrough with uint
-- %f passthrough with precision
-- %f passthrough with width and precision
-- %d passthrough with width
-- %q passthrough with string
-*/
-
-package spew_test
-
-import (
- "bytes"
- "fmt"
- "testing"
- "unsafe"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-// formatterTest is used to describe a test to be performed against NewFormatter.
-type formatterTest struct {
- format string
- in interface{}
- wants []string
-}
-
-// formatterTests houses all of the tests to be performed against NewFormatter.
-var formatterTests = make([]formatterTest, 0)
-
-// addFormatterTest is a helper method to append the passed input and desired
-// result to formatterTests.
-func addFormatterTest(format string, in interface{}, wants ...string) {
- test := formatterTest{format, in, wants}
- formatterTests = append(formatterTests, test)
-}
-
-func addIntFormatterTests() {
- // Max int8.
- v := int8(127)
- nv := (*int8)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "int8"
- vs := "127"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Max int16.
- v2 := int16(32767)
- nv2 := (*int16)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "int16"
- v2s := "32767"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Max int32.
- v3 := int32(2147483647)
- nv3 := (*int32)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "int32"
- v3s := "2147483647"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
-
- // Max int64.
- v4 := int64(9223372036854775807)
- nv4 := (*int64)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "int64"
- v4s := "9223372036854775807"
- addFormatterTest("%v", v4, v4s)
- addFormatterTest("%v", pv4, "<*>"+v4s)
- addFormatterTest("%v", &pv4, "<**>"+v4s)
- addFormatterTest("%v", nv4, "<nil>")
- addFormatterTest("%+v", v4, v4s)
- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
-
- // Max int.
- v5 := int(2147483647)
- nv5 := (*int)(nil)
- pv5 := &v5
- v5Addr := fmt.Sprintf("%p", pv5)
- pv5Addr := fmt.Sprintf("%p", &pv5)
- v5t := "int"
- v5s := "2147483647"
- addFormatterTest("%v", v5, v5s)
- addFormatterTest("%v", pv5, "<*>"+v5s)
- addFormatterTest("%v", &pv5, "<**>"+v5s)
- addFormatterTest("%v", nv5, "<nil>")
- addFormatterTest("%+v", v5, v5s)
- addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
- addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
- addFormatterTest("%+v", nv5, "<nil>")
- addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
- addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
- addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
- addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
- addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
- addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
- addFormatterTest("%#+v", nv5, "(*"+v5t+")"+"<nil>")
-}
-
-func addUintFormatterTests() {
- // Max uint8.
- v := uint8(255)
- nv := (*uint8)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "uint8"
- vs := "255"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Max uint16.
- v2 := uint16(65535)
- nv2 := (*uint16)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uint16"
- v2s := "65535"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Max uint32.
- v3 := uint32(4294967295)
- nv3 := (*uint32)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "uint32"
- v3s := "4294967295"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
-
- // Max uint64.
- v4 := uint64(18446744073709551615)
- nv4 := (*uint64)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "uint64"
- v4s := "18446744073709551615"
- addFormatterTest("%v", v4, v4s)
- addFormatterTest("%v", pv4, "<*>"+v4s)
- addFormatterTest("%v", &pv4, "<**>"+v4s)
- addFormatterTest("%v", nv4, "<nil>")
- addFormatterTest("%+v", v4, v4s)
- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
-
- // Max uint.
- v5 := uint(4294967295)
- nv5 := (*uint)(nil)
- pv5 := &v5
- v5Addr := fmt.Sprintf("%p", pv5)
- pv5Addr := fmt.Sprintf("%p", &pv5)
- v5t := "uint"
- v5s := "4294967295"
- addFormatterTest("%v", v5, v5s)
- addFormatterTest("%v", pv5, "<*>"+v5s)
- addFormatterTest("%v", &pv5, "<**>"+v5s)
- addFormatterTest("%v", nv5, "<nil>")
- addFormatterTest("%+v", v5, v5s)
- addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
- addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
- addFormatterTest("%+v", nv5, "<nil>")
- addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
- addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
- addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
- addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
- addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
- addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
-}
-
-func addBoolFormatterTests() {
- // Boolean true.
- v := bool(true)
- nv := (*bool)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "bool"
- vs := "true"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Boolean false.
- v2 := bool(false)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "bool"
- v2s := "false"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
-}
-
-func addFloatFormatterTests() {
- // Standard float32.
- v := float32(3.1415)
- nv := (*float32)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "float32"
- vs := "3.1415"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Standard float64.
- v2 := float64(3.1415926)
- nv2 := (*float64)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "float64"
- v2s := "3.1415926"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-}
-
-func addComplexFormatterTests() {
- // Standard complex64.
- v := complex(float32(6), -2)
- nv := (*complex64)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "complex64"
- vs := "(6-2i)"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Standard complex128.
- v2 := complex(float64(-6), 2)
- nv2 := (*complex128)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "complex128"
- v2s := "(-6+2i)"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-}
-
-func addArrayFormatterTests() {
- // Array containing standard ints.
- v := [3]int{1, 2, 3}
- nv := (*[3]int)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "[3]int"
- vs := "[1 2 3]"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Array containing type with custom formatter on pointer receiver only.
- v2 := [3]pstringer{"1", "2", "3"}
- nv2 := (*[3]pstringer)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "[3]spew_test.pstringer"
- v2sp := "[stringer 1 stringer 2 stringer 3]"
- v2s := v2sp
- if spew.UnsafeDisabled {
- v2s = "[1 2 3]"
- }
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2sp)
- addFormatterTest("%v", &pv2, "<**>"+v2sp)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2sp)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2sp)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2sp)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2sp)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2sp)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2sp)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Array containing interfaces.
- v3 := [3]interface{}{"one", int(2), uint(3)}
- nv3 := (*[3]interface{})(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "[3]interface {}"
- v3t2 := "string"
- v3t3 := "int"
- v3t4 := "uint"
- v3s := "[one 2 3]"
- v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3]"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
-}
-
-func addSliceFormatterTests() {
- // Slice containing standard float32 values.
- v := []float32{3.14, 6.28, 12.56}
- nv := (*[]float32)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "[]float32"
- vs := "[3.14 6.28 12.56]"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Slice containing type with custom formatter on pointer receiver only.
- v2 := []pstringer{"1", "2", "3"}
- nv2 := (*[]pstringer)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "[]spew_test.pstringer"
- v2s := "[stringer 1 stringer 2 stringer 3]"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Slice containing interfaces.
- v3 := []interface{}{"one", int(2), uint(3), nil}
- nv3 := (*[]interface{})(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "[]interface {}"
- v3t2 := "string"
- v3t3 := "int"
- v3t4 := "uint"
- v3t5 := "interface {}"
- v3s := "[one 2 3 <nil>]"
- v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3 (" + v3t5 +
- ")<nil>]"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
-
- // Nil slice.
- var v4 []int
- nv4 := (*[]int)(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "[]int"
- v4s := "<nil>"
- addFormatterTest("%v", v4, v4s)
- addFormatterTest("%v", pv4, "<*>"+v4s)
- addFormatterTest("%v", &pv4, "<**>"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%+v", v4, v4s)
- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
-}
-
-func addStringFormatterTests() {
- // Standard string.
- v := "test"
- nv := (*string)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "string"
- vs := "test"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-}
-
-func addInterfaceFormatterTests() {
- // Nil interface.
- var v interface{}
- nv := (*interface{})(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "interface {}"
- vs := "<nil>"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Sub-interface.
- v2 := interface{}(uint16(65535))
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uint16"
- v2s := "65535"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
-}
-
-func addMapFormatterTests() {
- // Map with string keys and int vals.
- v := map[string]int{"one": 1, "two": 2}
- nilMap := map[string]int(nil)
- nv := (*map[string]int)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "map[string]int"
- vs := "map[one:1 two:2]"
- vs2 := "map[two:2 one:1]"
- addFormatterTest("%v", v, vs, vs2)
- addFormatterTest("%v", pv, "<*>"+vs, "<*>"+vs2)
- addFormatterTest("%v", &pv, "<**>"+vs, "<**>"+vs2)
- addFormatterTest("%+v", nilMap, "<nil>")
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs, vs2)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs, "<*>("+vAddr+")"+vs2)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs,
- "<**>("+pvAddr+"->"+vAddr+")"+vs2)
- addFormatterTest("%+v", nilMap, "<nil>")
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs, "(*"+vt+")"+vs2)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs, "(**"+vt+")"+vs2)
- addFormatterTest("%#v", nilMap, "("+vt+")"+"<nil>")
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs,
- "(*"+vt+")("+vAddr+")"+vs2)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs,
- "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs2)
- addFormatterTest("%#+v", nilMap, "("+vt+")"+"<nil>")
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Map with custom formatter type on pointer receiver only keys and vals.
- v2 := map[pstringer]pstringer{"one": "1"}
- nv2 := (*map[pstringer]pstringer)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "map[spew_test.pstringer]spew_test.pstringer"
- v2s := "map[stringer one:stringer 1]"
- if spew.UnsafeDisabled {
- v2s = "map[one:1]"
- }
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Map with interface keys and values.
- v3 := map[interface{}]interface{}{"one": 1}
- nv3 := (*map[interface{}]interface{})(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "map[interface {}]interface {}"
- v3t1 := "string"
- v3t2 := "int"
- v3s := "map[one:1]"
- v3s2 := "map[(" + v3t1 + ")one:(" + v3t2 + ")1]"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
-
- // Map with nil interface value
- v4 := map[string]interface{}{"nil": nil}
- nv4 := (*map[string]interface{})(nil)
- pv4 := &v4
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "map[string]interface {}"
- v4t1 := "interface {}"
- v4s := "map[nil:<nil>]"
- v4s2 := "map[nil:(" + v4t1 + ")<nil>]"
- addFormatterTest("%v", v4, v4s)
- addFormatterTest("%v", pv4, "<*>"+v4s)
- addFormatterTest("%v", &pv4, "<**>"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%+v", v4, v4s)
- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%#v", v4, "("+v4t+")"+v4s2)
- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s2)
- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s2)
- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s2)
- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s2)
- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s2)
- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
-}
-
-func addStructFormatterTests() {
- // Struct with primitives.
- type s1 struct {
- a int8
- b uint8
- }
- v := s1{127, 255}
- nv := (*s1)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.s1"
- vt2 := "int8"
- vt3 := "uint8"
- vs := "{127 255}"
- vs2 := "{a:127 b:255}"
- vs3 := "{a:(" + vt2 + ")127 b:(" + vt3 + ")255}"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs2)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs2)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs2)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs3)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs3)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs3)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs3)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs3)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs3)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Struct that contains another struct.
- type s2 struct {
- s1 s1
- b bool
- }
- v2 := s2{s1{127, 255}, true}
- nv2 := (*s2)(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.s2"
- v2t2 := "spew_test.s1"
- v2t3 := "int8"
- v2t4 := "uint8"
- v2t5 := "bool"
- v2s := "{{127 255} true}"
- v2s2 := "{s1:{a:127 b:255} b:true}"
- v2s3 := "{s1:(" + v2t2 + "){a:(" + v2t3 + ")127 b:(" + v2t4 + ")255} b:(" +
- v2t5 + ")true}"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s2)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s2)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s2)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s3)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s3)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s3)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s3)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s3)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s3)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Struct that contains custom type with Stringer pointer interface via both
- // exported and unexported fields.
- type s3 struct {
- s pstringer
- S pstringer
- }
- v3 := s3{"test", "test2"}
- nv3 := (*s3)(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "spew_test.s3"
- v3t2 := "spew_test.pstringer"
- v3s := "{stringer test stringer test2}"
- v3sp := v3s
- v3s2 := "{s:stringer test S:stringer test2}"
- v3s2p := v3s2
- v3s3 := "{s:(" + v3t2 + ")stringer test S:(" + v3t2 + ")stringer test2}"
- v3s3p := v3s3
- if spew.UnsafeDisabled {
- v3s = "{test test2}"
- v3sp = "{test stringer test2}"
- v3s2 = "{s:test S:test2}"
- v3s2p = "{s:test S:stringer test2}"
- v3s3 = "{s:(" + v3t2 + ")test S:(" + v3t2 + ")test2}"
- v3s3p = "{s:(" + v3t2 + ")test S:(" + v3t2 + ")stringer test2}"
- }
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3sp)
- addFormatterTest("%v", &pv3, "<**>"+v3sp)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s2)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s2p)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s2p)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s3)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s3p)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s3p)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s3)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s3p)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s3p)
- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
-
- // Struct that contains embedded struct and field to same struct.
- e := embed{"embedstr"}
- v4 := embedwrap{embed: &e, e: &e}
- nv4 := (*embedwrap)(nil)
- pv4 := &v4
- eAddr := fmt.Sprintf("%p", &e)
- v4Addr := fmt.Sprintf("%p", pv4)
- pv4Addr := fmt.Sprintf("%p", &pv4)
- v4t := "spew_test.embedwrap"
- v4t2 := "spew_test.embed"
- v4t3 := "string"
- v4s := "{<*>{embedstr} <*>{embedstr}}"
- v4s2 := "{embed:<*>(" + eAddr + "){a:embedstr} e:<*>(" + eAddr +
- "){a:embedstr}}"
- v4s3 := "{embed:(*" + v4t2 + "){a:(" + v4t3 + ")embedstr} e:(*" + v4t2 +
- "){a:(" + v4t3 + ")embedstr}}"
- v4s4 := "{embed:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 +
- ")embedstr} e:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 + ")embedstr}}"
- addFormatterTest("%v", v4, v4s)
- addFormatterTest("%v", pv4, "<*>"+v4s)
- addFormatterTest("%v", &pv4, "<**>"+v4s)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%+v", v4, v4s2)
- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s2)
- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s2)
- addFormatterTest("%+v", nv4, "<nil>")
- addFormatterTest("%#v", v4, "("+v4t+")"+v4s3)
- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s3)
- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s3)
- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s4)
- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s4)
- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s4)
- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
-}
-
-func addUintptrFormatterTests() {
- // Null pointer.
- v := uintptr(0)
- nv := (*uintptr)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "uintptr"
- vs := "<nil>"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Address of real variable.
- i := 1
- v2 := uintptr(unsafe.Pointer(&i))
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "uintptr"
- v2s := fmt.Sprintf("%p", &i)
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
-}
-
-func addUnsafePointerFormatterTests() {
- // Null pointer.
- v := unsafe.Pointer(nil)
- nv := (*unsafe.Pointer)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "unsafe.Pointer"
- vs := "<nil>"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Address of real variable.
- i := 1
- v2 := unsafe.Pointer(&i)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "unsafe.Pointer"
- v2s := fmt.Sprintf("%p", &i)
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
-}
-
-func addChanFormatterTests() {
- // Nil channel.
- var v chan int
- pv := &v
- nv := (*chan int)(nil)
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "chan int"
- vs := "<nil>"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Real channel.
- v2 := make(chan int)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "chan int"
- v2s := fmt.Sprintf("%p", v2)
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
-}
-
-func addFuncFormatterTests() {
- // Function with no params and no returns.
- v := addIntFormatterTests
- nv := (*func())(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "func()"
- vs := fmt.Sprintf("%p", v)
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-
- // Function with param and no returns.
- v2 := TestFormatter
- nv2 := (*func(*testing.T))(nil)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "func(*testing.T)"
- v2s := fmt.Sprintf("%p", v2)
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s)
- addFormatterTest("%v", &pv2, "<**>"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%+v", v2, v2s)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%+v", nv2, "<nil>")
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
-
- // Function with multiple params and multiple returns.
- var v3 = func(i int, s string) (b bool, err error) {
- return true, nil
- }
- nv3 := (*func(int, string) (bool, error))(nil)
- pv3 := &v3
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "func(int, string) (bool, error)"
- v3s := fmt.Sprintf("%p", v3)
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s)
- addFormatterTest("%v", &pv3, "<**>"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%+v", v3, v3s)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%+v", nv3, "<nil>")
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
-}
-
-func addCircularFormatterTests() {
- // Struct that is circular through self referencing.
- type circular struct {
- c *circular
- }
- v := circular{nil}
- v.c = &v
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.circular"
- vs := "{<*>{<*><shown>}}"
- vs2 := "{<*><shown>}"
- vs3 := "{c:<*>(" + vAddr + "){c:<*>(" + vAddr + ")<shown>}}"
- vs4 := "{c:<*>(" + vAddr + ")<shown>}"
- vs5 := "{c:(*" + vt + "){c:(*" + vt + ")<shown>}}"
- vs6 := "{c:(*" + vt + ")<shown>}"
- vs7 := "{c:(*" + vt + ")(" + vAddr + "){c:(*" + vt + ")(" + vAddr +
- ")<shown>}}"
- vs8 := "{c:(*" + vt + ")(" + vAddr + ")<shown>}"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs2)
- addFormatterTest("%v", &pv, "<**>"+vs2)
- addFormatterTest("%+v", v, vs3)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs4)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs4)
- addFormatterTest("%#v", v, "("+vt+")"+vs5)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs6)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs6)
- addFormatterTest("%#+v", v, "("+vt+")"+vs7)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs8)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs8)
-
- // Structs that are circular through cross referencing.
- v2 := xref1{nil}
- ts2 := xref2{&v2}
- v2.ps2 = &ts2
- pv2 := &v2
- ts2Addr := fmt.Sprintf("%p", &ts2)
- v2Addr := fmt.Sprintf("%p", pv2)
- pv2Addr := fmt.Sprintf("%p", &pv2)
- v2t := "spew_test.xref1"
- v2t2 := "spew_test.xref2"
- v2s := "{<*>{<*>{<*><shown>}}}"
- v2s2 := "{<*>{<*><shown>}}"
- v2s3 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + "){ps2:<*>(" +
- ts2Addr + ")<shown>}}}"
- v2s4 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + ")<shown>}}"
- v2s5 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + "){ps2:(*" + v2t2 +
- ")<shown>}}}"
- v2s6 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + ")<shown>}}"
- v2s7 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
- ")(" + v2Addr + "){ps2:(*" + v2t2 + ")(" + ts2Addr +
- ")<shown>}}}"
- v2s8 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
- ")(" + v2Addr + ")<shown>}}"
- addFormatterTest("%v", v2, v2s)
- addFormatterTest("%v", pv2, "<*>"+v2s2)
- addFormatterTest("%v", &pv2, "<**>"+v2s2)
- addFormatterTest("%+v", v2, v2s3)
- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s4)
- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s4)
- addFormatterTest("%#v", v2, "("+v2t+")"+v2s5)
- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s6)
- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s6)
- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s7)
- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s8)
- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s8)
-
- // Structs that are indirectly circular.
- v3 := indirCir1{nil}
- tic2 := indirCir2{nil}
- tic3 := indirCir3{&v3}
- tic2.ps3 = &tic3
- v3.ps2 = &tic2
- pv3 := &v3
- tic2Addr := fmt.Sprintf("%p", &tic2)
- tic3Addr := fmt.Sprintf("%p", &tic3)
- v3Addr := fmt.Sprintf("%p", pv3)
- pv3Addr := fmt.Sprintf("%p", &pv3)
- v3t := "spew_test.indirCir1"
- v3t2 := "spew_test.indirCir2"
- v3t3 := "spew_test.indirCir3"
- v3s := "{<*>{<*>{<*>{<*><shown>}}}}"
- v3s2 := "{<*>{<*>{<*><shown>}}}"
- v3s3 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
- v3Addr + "){ps2:<*>(" + tic2Addr + ")<shown>}}}}"
- v3s4 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
- v3Addr + ")<shown>}}}"
- v3s5 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
- "){ps2:(*" + v3t2 + ")<shown>}}}}"
- v3s6 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
- ")<shown>}}}"
- v3s7 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
- tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + "){ps2:(*" + v3t2 +
- ")(" + tic2Addr + ")<shown>}}}}"
- v3s8 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
- tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + ")<shown>}}}"
- addFormatterTest("%v", v3, v3s)
- addFormatterTest("%v", pv3, "<*>"+v3s2)
- addFormatterTest("%v", &pv3, "<**>"+v3s2)
- addFormatterTest("%+v", v3, v3s3)
- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s4)
- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s4)
- addFormatterTest("%#v", v3, "("+v3t+")"+v3s5)
- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s6)
- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s6)
- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s7)
- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s8)
- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s8)
-}
-
-func addPanicFormatterTests() {
- // Type that panics in its Stringer interface.
- v := panicer(127)
- nv := (*panicer)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.panicer"
- vs := "(PANIC=test panic)127"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-}
-
-func addErrorFormatterTests() {
- // Type that has a custom Error interface.
- v := customError(127)
- nv := (*customError)(nil)
- pv := &v
- vAddr := fmt.Sprintf("%p", pv)
- pvAddr := fmt.Sprintf("%p", &pv)
- vt := "spew_test.customError"
- vs := "error: 127"
- addFormatterTest("%v", v, vs)
- addFormatterTest("%v", pv, "<*>"+vs)
- addFormatterTest("%v", &pv, "<**>"+vs)
- addFormatterTest("%v", nv, "<nil>")
- addFormatterTest("%+v", v, vs)
- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%+v", nv, "<nil>")
- addFormatterTest("%#v", v, "("+vt+")"+vs)
- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
- addFormatterTest("%#+v", v, "("+vt+")"+vs)
- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
-}
-
-func addPassthroughFormatterTests() {
- // %x passthrough with uint.
- v := uint(4294967295)
- pv := &v
- vAddr := fmt.Sprintf("%x", pv)
- pvAddr := fmt.Sprintf("%x", &pv)
- vs := "ffffffff"
- addFormatterTest("%x", v, vs)
- addFormatterTest("%x", pv, vAddr)
- addFormatterTest("%x", &pv, pvAddr)
-
- // %#x passthrough with uint.
- v2 := int(2147483647)
- pv2 := &v2
- v2Addr := fmt.Sprintf("%#x", pv2)
- pv2Addr := fmt.Sprintf("%#x", &pv2)
- v2s := "0x7fffffff"
- addFormatterTest("%#x", v2, v2s)
- addFormatterTest("%#x", pv2, v2Addr)
- addFormatterTest("%#x", &pv2, pv2Addr)
-
- // %f passthrough with precision.
- addFormatterTest("%.2f", 3.1415, "3.14")
- addFormatterTest("%.3f", 3.1415, "3.142")
- addFormatterTest("%.4f", 3.1415, "3.1415")
-
- // %f passthrough with width and precision.
- addFormatterTest("%5.2f", 3.1415, " 3.14")
- addFormatterTest("%6.3f", 3.1415, " 3.142")
- addFormatterTest("%7.4f", 3.1415, " 3.1415")
-
- // %d passthrough with width.
- addFormatterTest("%3d", 127, "127")
- addFormatterTest("%4d", 127, " 127")
- addFormatterTest("%5d", 127, " 127")
-
- // %q passthrough with string.
- addFormatterTest("%q", "test", "\"test\"")
-}
-
-// TestFormatter executes all of the tests described by formatterTests.
-func TestFormatter(t *testing.T) {
- // Setup tests.
- addIntFormatterTests()
- addUintFormatterTests()
- addBoolFormatterTests()
- addFloatFormatterTests()
- addComplexFormatterTests()
- addArrayFormatterTests()
- addSliceFormatterTests()
- addStringFormatterTests()
- addInterfaceFormatterTests()
- addMapFormatterTests()
- addStructFormatterTests()
- addUintptrFormatterTests()
- addUnsafePointerFormatterTests()
- addChanFormatterTests()
- addFuncFormatterTests()
- addCircularFormatterTests()
- addPanicFormatterTests()
- addErrorFormatterTests()
- addPassthroughFormatterTests()
-
- t.Logf("Running %d tests", len(formatterTests))
- for i, test := range formatterTests {
- buf := new(bytes.Buffer)
- spew.Fprintf(buf, test.format, test.in)
- s := buf.String()
- if testFailed(s, test.wants) {
- t.Errorf("Formatter #%d format: %s got: %s %s", i, test.format, s,
- stringizeWants(test.wants))
- continue
- }
- }
-}
-
-type testStruct struct {
- x int
-}
-
-func (ts testStruct) String() string {
- return fmt.Sprintf("ts.%d", ts.x)
-}
-
-type testStructP struct {
- x int
-}
-
-func (ts *testStructP) String() string {
- return fmt.Sprintf("ts.%d", ts.x)
-}
-
-func TestPrintSortedKeys(t *testing.T) {
- cfg := spew.ConfigState{SortKeys: true}
- s := cfg.Sprint(map[int]string{1: "1", 3: "3", 2: "2"})
- expected := "map[1:1 2:2 3:3]"
- if s != expected {
- t.Errorf("Sorted keys mismatch 1:\n %v %v", s, expected)
- }
-
- s = cfg.Sprint(map[stringer]int{"1": 1, "3": 3, "2": 2})
- expected = "map[stringer 1:1 stringer 2:2 stringer 3:3]"
- if s != expected {
- t.Errorf("Sorted keys mismatch 2:\n %v %v", s, expected)
- }
-
- s = cfg.Sprint(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
- expected = "map[stringer 1:1 stringer 2:2 stringer 3:3]"
- if spew.UnsafeDisabled {
- expected = "map[1:1 2:2 3:3]"
- }
- if s != expected {
- t.Errorf("Sorted keys mismatch 3:\n %v %v", s, expected)
- }
-
- s = cfg.Sprint(map[testStruct]int{{1}: 1, {3}: 3, {2}: 2})
- expected = "map[ts.1:1 ts.2:2 ts.3:3]"
- if s != expected {
- t.Errorf("Sorted keys mismatch 4:\n %v %v", s, expected)
- }
-
- if !spew.UnsafeDisabled {
- s = cfg.Sprint(map[testStructP]int{{1}: 1, {3}: 3, {2}: 2})
- expected = "map[ts.1:1 ts.2:2 ts.3:3]"
- if s != expected {
- t.Errorf("Sorted keys mismatch 5:\n %v %v", s, expected)
- }
- }
-
- s = cfg.Sprint(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
- expected = "map[error: 1:1 error: 2:2 error: 3:3]"
- if s != expected {
- t.Errorf("Sorted keys mismatch 6:\n %v %v", s, expected)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internal_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internal_test.go
deleted file mode 100644
index e312b4fadc070b6c9cffa98a2666a6d61d146470..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internal_test.go
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
-This test file is part of the spew package rather than than the spew_test
-package because it needs access to internals to properly test certain cases
-which are not possible via the public interface since they should never happen.
-*/
-
-package spew
-
-import (
- "bytes"
- "reflect"
- "testing"
-)
-
-// dummyFmtState implements a fake fmt.State to use for testing invalid
-// reflect.Value handling. This is necessary because the fmt package catches
-// invalid values before invoking the formatter on them.
-type dummyFmtState struct {
- bytes.Buffer
-}
-
-func (dfs *dummyFmtState) Flag(f int) bool {
- return f == int('+')
-}
-
-func (dfs *dummyFmtState) Precision() (int, bool) {
- return 0, false
-}
-
-func (dfs *dummyFmtState) Width() (int, bool) {
- return 0, false
-}
-
-// TestInvalidReflectValue ensures the dump and formatter code handles an
-// invalid reflect value properly. This needs access to internal state since it
-// should never happen in real code and therefore can't be tested via the public
-// API.
-func TestInvalidReflectValue(t *testing.T) {
- i := 1
-
- // Dump invalid reflect value.
- v := new(reflect.Value)
- buf := new(bytes.Buffer)
- d := dumpState{w: buf, cs: &Config}
- d.dump(*v)
- s := buf.String()
- want := "<invalid>"
- if s != want {
- t.Errorf("InvalidReflectValue #%d\n got: %s want: %s", i, s, want)
- }
- i++
-
- // Formatter invalid reflect value.
- buf2 := new(dummyFmtState)
- f := formatState{value: *v, cs: &Config, fs: buf2}
- f.format(*v)
- s = buf2.String()
- want = "<invalid>"
- if s != want {
- t.Errorf("InvalidReflectValue #%d got: %s want: %s", i, s, want)
- }
-}
-
-// SortValues makes the internal sortValues function available to the test
-// package.
-func SortValues(values []reflect.Value, cs *ConfigState) {
- sortValues(values, cs)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internalunsafe_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internalunsafe_test.go
deleted file mode 100644
index 80dc22177db25720abc48df563ed6053c11dce5f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/internalunsafe_test.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
-
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when the code is not running on Google App Engine, compiled by GopherJS, and
-// "-tags safe" is not added to the go build command line. The "disableunsafe"
-// tag is deprecated and thus should not be used.
-// +build !js,!appengine,!safe,!disableunsafe,go1.4
-
-/*
-This test file is part of the spew package rather than than the spew_test
-package because it needs access to internals to properly test certain cases
-which are not possible via the public interface since they should never happen.
-*/
-
-package spew
-
-import (
- "bytes"
- "reflect"
- "testing"
-)
-
-// changeKind uses unsafe to intentionally change the kind of a reflect.Value to
-// the maximum kind value which does not exist. This is needed to test the
-// fallback code which punts to the standard fmt library for new types that
-// might get added to the language.
-func changeKind(v *reflect.Value, readOnly bool) {
- flags := flagField(v)
- if readOnly {
- *flags |= flagRO
- } else {
- *flags &^= flagRO
- }
- *flags |= flagKindMask
-}
-
-// TestAddedReflectValue tests functionaly of the dump and formatter code which
-// falls back to the standard fmt library for new types that might get added to
-// the language.
-func TestAddedReflectValue(t *testing.T) {
- i := 1
-
- // Dump using a reflect.Value that is exported.
- v := reflect.ValueOf(int8(5))
- changeKind(&v, false)
- buf := new(bytes.Buffer)
- d := dumpState{w: buf, cs: &Config}
- d.dump(v)
- s := buf.String()
- want := "(int8) 5"
- if s != want {
- t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
- }
- i++
-
- // Dump using a reflect.Value that is not exported.
- changeKind(&v, true)
- buf.Reset()
- d.dump(v)
- s = buf.String()
- want = "(int8) <int8 Value>"
- if s != want {
- t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
- }
- i++
-
- // Formatter using a reflect.Value that is exported.
- changeKind(&v, false)
- buf2 := new(dummyFmtState)
- f := formatState{value: v, cs: &Config, fs: buf2}
- f.format(v)
- s = buf2.String()
- want = "5"
- if s != want {
- t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
- }
- i++
-
- // Formatter using a reflect.Value that is not exported.
- changeKind(&v, true)
- buf2.Reset()
- f = formatState{value: v, cs: &Config, fs: buf2}
- f.format(v)
- s = buf2.String()
- want = "<int8 Value>"
- if s != want {
- t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew.go
deleted file mode 100644
index 32c0e338825308f6b9b4d0407aa5682a23e2dc9c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew.go
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew
-
-import (
- "fmt"
- "io"
-)
-
-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the formatted string as a value that satisfies error. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Errorf(format string, a ...interface{}) (err error) {
- return fmt.Errorf(format, convertArgs(a)...)
-}
-
-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
- return fmt.Fprint(w, convertArgs(a)...)
-}
-
-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
- return fmt.Fprintf(w, format, convertArgs(a)...)
-}
-
-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
-// passed with a default Formatter interface returned by NewFormatter. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
-func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
- return fmt.Fprintln(w, convertArgs(a)...)
-}
-
-// Print is a wrapper for fmt.Print that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
-func Print(a ...interface{}) (n int, err error) {
- return fmt.Print(convertArgs(a)...)
-}
-
-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Printf(format string, a ...interface{}) (n int, err error) {
- return fmt.Printf(format, convertArgs(a)...)
-}
-
-// Println is a wrapper for fmt.Println that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the number of bytes written and any write error encountered. See
-// NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
-func Println(a ...interface{}) (n int, err error) {
- return fmt.Println(convertArgs(a)...)
-}
-
-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprint(a ...interface{}) string {
- return fmt.Sprint(convertArgs(a)...)
-}
-
-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
-// passed with a default Formatter interface returned by NewFormatter. It
-// returns the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintf(format string, a ...interface{}) string {
- return fmt.Sprintf(format, convertArgs(a)...)
-}
-
-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
-// were passed with a default Formatter interface returned by NewFormatter. It
-// returns the resulting string. See NewFormatter for formatting details.
-//
-// This function is shorthand for the following syntax:
-//
-// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
-func Sprintln(a ...interface{}) string {
- return fmt.Sprintln(convertArgs(a)...)
-}
-
-// convertArgs accepts a slice of arguments and returns a slice of the same
-// length with each argument converted to a default spew Formatter interface.
-func convertArgs(args []interface{}) (formatters []interface{}) {
- formatters = make([]interface{}, len(args))
- for index, arg := range args {
- formatters[index] = NewFormatter(arg)
- }
- return formatters
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew_test.go b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew_test.go
deleted file mode 100644
index b70466c69f8e6443d35c9454f1222ddf3d279777..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/spew/spew_test.go
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew_test
-
-import (
- "bytes"
- "fmt"
- "io/ioutil"
- "os"
- "testing"
-
- "github.com/davecgh/go-spew/spew"
-)
-
-// spewFunc is used to identify which public function of the spew package or
-// ConfigState a test applies to.
-type spewFunc int
-
-const (
- fCSFdump spewFunc = iota
- fCSFprint
- fCSFprintf
- fCSFprintln
- fCSPrint
- fCSPrintln
- fCSSdump
- fCSSprint
- fCSSprintf
- fCSSprintln
- fCSErrorf
- fCSNewFormatter
- fErrorf
- fFprint
- fFprintln
- fPrint
- fPrintln
- fSdump
- fSprint
- fSprintf
- fSprintln
-)
-
-// Map of spewFunc values to names for pretty printing.
-var spewFuncStrings = map[spewFunc]string{
- fCSFdump: "ConfigState.Fdump",
- fCSFprint: "ConfigState.Fprint",
- fCSFprintf: "ConfigState.Fprintf",
- fCSFprintln: "ConfigState.Fprintln",
- fCSSdump: "ConfigState.Sdump",
- fCSPrint: "ConfigState.Print",
- fCSPrintln: "ConfigState.Println",
- fCSSprint: "ConfigState.Sprint",
- fCSSprintf: "ConfigState.Sprintf",
- fCSSprintln: "ConfigState.Sprintln",
- fCSErrorf: "ConfigState.Errorf",
- fCSNewFormatter: "ConfigState.NewFormatter",
- fErrorf: "spew.Errorf",
- fFprint: "spew.Fprint",
- fFprintln: "spew.Fprintln",
- fPrint: "spew.Print",
- fPrintln: "spew.Println",
- fSdump: "spew.Sdump",
- fSprint: "spew.Sprint",
- fSprintf: "spew.Sprintf",
- fSprintln: "spew.Sprintln",
-}
-
-func (f spewFunc) String() string {
- if s, ok := spewFuncStrings[f]; ok {
- return s
- }
- return fmt.Sprintf("Unknown spewFunc (%d)", int(f))
-}
-
-// spewTest is used to describe a test to be performed against the public
-// functions of the spew package or ConfigState.
-type spewTest struct {
- cs *spew.ConfigState
- f spewFunc
- format string
- in interface{}
- want string
-}
-
-// spewTests houses the tests to be performed against the public functions of
-// the spew package and ConfigState.
-//
-// These tests are only intended to ensure the public functions are exercised
-// and are intentionally not exhaustive of types. The exhaustive type
-// tests are handled in the dump and format tests.
-var spewTests []spewTest
-
-// redirStdout is a helper function to return the standard output from f as a
-// byte slice.
-func redirStdout(f func()) ([]byte, error) {
- tempFile, err := ioutil.TempFile("", "ss-test")
- if err != nil {
- return nil, err
- }
- fileName := tempFile.Name()
- defer os.Remove(fileName) // Ignore error
-
- origStdout := os.Stdout
- os.Stdout = tempFile
- f()
- os.Stdout = origStdout
- tempFile.Close()
-
- return ioutil.ReadFile(fileName)
-}
-
-func initSpewTests() {
- // Config states with various settings.
- scsDefault := spew.NewDefaultConfig()
- scsNoMethods := &spew.ConfigState{Indent: " ", DisableMethods: true}
- scsNoPmethods := &spew.ConfigState{Indent: " ", DisablePointerMethods: true}
- scsMaxDepth := &spew.ConfigState{Indent: " ", MaxDepth: 1}
- scsContinue := &spew.ConfigState{Indent: " ", ContinueOnMethod: true}
- scsNoPtrAddr := &spew.ConfigState{DisablePointerAddresses: true}
- scsNoCap := &spew.ConfigState{DisableCapacities: true}
-
- // Variables for tests on types which implement Stringer interface with and
- // without a pointer receiver.
- ts := stringer("test")
- tps := pstringer("test")
-
- type ptrTester struct {
- s *struct{}
- }
- tptr := &ptrTester{s: &struct{}{}}
-
- // depthTester is used to test max depth handling for structs, array, slices
- // and maps.
- type depthTester struct {
- ic indirCir1
- arr [1]string
- slice []string
- m map[string]int
- }
- dt := depthTester{indirCir1{nil}, [1]string{"arr"}, []string{"slice"},
- map[string]int{"one": 1}}
-
- // Variable for tests on types which implement error interface.
- te := customError(10)
-
- spewTests = []spewTest{
- {scsDefault, fCSFdump, "", int8(127), "(int8) 127\n"},
- {scsDefault, fCSFprint, "", int16(32767), "32767"},
- {scsDefault, fCSFprintf, "%v", int32(2147483647), "2147483647"},
- {scsDefault, fCSFprintln, "", int(2147483647), "2147483647\n"},
- {scsDefault, fCSPrint, "", int64(9223372036854775807), "9223372036854775807"},
- {scsDefault, fCSPrintln, "", uint8(255), "255\n"},
- {scsDefault, fCSSdump, "", uint8(64), "(uint8) 64\n"},
- {scsDefault, fCSSprint, "", complex(1, 2), "(1+2i)"},
- {scsDefault, fCSSprintf, "%v", complex(float32(3), 4), "(3+4i)"},
- {scsDefault, fCSSprintln, "", complex(float64(5), 6), "(5+6i)\n"},
- {scsDefault, fCSErrorf, "%#v", uint16(65535), "(uint16)65535"},
- {scsDefault, fCSNewFormatter, "%v", uint32(4294967295), "4294967295"},
- {scsDefault, fErrorf, "%v", uint64(18446744073709551615), "18446744073709551615"},
- {scsDefault, fFprint, "", float32(3.14), "3.14"},
- {scsDefault, fFprintln, "", float64(6.28), "6.28\n"},
- {scsDefault, fPrint, "", true, "true"},
- {scsDefault, fPrintln, "", false, "false\n"},
- {scsDefault, fSdump, "", complex(-10, -20), "(complex128) (-10-20i)\n"},
- {scsDefault, fSprint, "", complex(-1, -2), "(-1-2i)"},
- {scsDefault, fSprintf, "%v", complex(float32(-3), -4), "(-3-4i)"},
- {scsDefault, fSprintln, "", complex(float64(-5), -6), "(-5-6i)\n"},
- {scsNoMethods, fCSFprint, "", ts, "test"},
- {scsNoMethods, fCSFprint, "", &ts, "<*>test"},
- {scsNoMethods, fCSFprint, "", tps, "test"},
- {scsNoMethods, fCSFprint, "", &tps, "<*>test"},
- {scsNoPmethods, fCSFprint, "", ts, "stringer test"},
- {scsNoPmethods, fCSFprint, "", &ts, "<*>stringer test"},
- {scsNoPmethods, fCSFprint, "", tps, "test"},
- {scsNoPmethods, fCSFprint, "", &tps, "<*>stringer test"},
- {scsMaxDepth, fCSFprint, "", dt, "{{<max>} [<max>] [<max>] map[<max>]}"},
- {scsMaxDepth, fCSFdump, "", dt, "(spew_test.depthTester) {\n" +
- " ic: (spew_test.indirCir1) {\n <max depth reached>\n },\n" +
- " arr: ([1]string) (len=1 cap=1) {\n <max depth reached>\n },\n" +
- " slice: ([]string) (len=1 cap=1) {\n <max depth reached>\n },\n" +
- " m: (map[string]int) (len=1) {\n <max depth reached>\n }\n}\n"},
- {scsContinue, fCSFprint, "", ts, "(stringer test) test"},
- {scsContinue, fCSFdump, "", ts, "(spew_test.stringer) " +
- "(len=4) (stringer test) \"test\"\n"},
- {scsContinue, fCSFprint, "", te, "(error: 10) 10"},
- {scsContinue, fCSFdump, "", te, "(spew_test.customError) " +
- "(error: 10) 10\n"},
- {scsNoPtrAddr, fCSFprint, "", tptr, "<*>{<*>{}}"},
- {scsNoPtrAddr, fCSSdump, "", tptr, "(*spew_test.ptrTester)({\ns: (*struct {})({\n})\n})\n"},
- {scsNoCap, fCSSdump, "", make([]string, 0, 10), "([]string) {\n}\n"},
- {scsNoCap, fCSSdump, "", make([]string, 1, 10), "([]string) (len=1) {\n(string) \"\"\n}\n"},
- }
-}
-
-// TestSpew executes all of the tests described by spewTests.
-func TestSpew(t *testing.T) {
- initSpewTests()
-
- t.Logf("Running %d tests", len(spewTests))
- for i, test := range spewTests {
- buf := new(bytes.Buffer)
- switch test.f {
- case fCSFdump:
- test.cs.Fdump(buf, test.in)
-
- case fCSFprint:
- test.cs.Fprint(buf, test.in)
-
- case fCSFprintf:
- test.cs.Fprintf(buf, test.format, test.in)
-
- case fCSFprintln:
- test.cs.Fprintln(buf, test.in)
-
- case fCSPrint:
- b, err := redirStdout(func() { test.cs.Print(test.in) })
- if err != nil {
- t.Errorf("%v #%d %v", test.f, i, err)
- continue
- }
- buf.Write(b)
-
- case fCSPrintln:
- b, err := redirStdout(func() { test.cs.Println(test.in) })
- if err != nil {
- t.Errorf("%v #%d %v", test.f, i, err)
- continue
- }
- buf.Write(b)
-
- case fCSSdump:
- str := test.cs.Sdump(test.in)
- buf.WriteString(str)
-
- case fCSSprint:
- str := test.cs.Sprint(test.in)
- buf.WriteString(str)
-
- case fCSSprintf:
- str := test.cs.Sprintf(test.format, test.in)
- buf.WriteString(str)
-
- case fCSSprintln:
- str := test.cs.Sprintln(test.in)
- buf.WriteString(str)
-
- case fCSErrorf:
- err := test.cs.Errorf(test.format, test.in)
- buf.WriteString(err.Error())
-
- case fCSNewFormatter:
- fmt.Fprintf(buf, test.format, test.cs.NewFormatter(test.in))
-
- case fErrorf:
- err := spew.Errorf(test.format, test.in)
- buf.WriteString(err.Error())
-
- case fFprint:
- spew.Fprint(buf, test.in)
-
- case fFprintln:
- spew.Fprintln(buf, test.in)
-
- case fPrint:
- b, err := redirStdout(func() { spew.Print(test.in) })
- if err != nil {
- t.Errorf("%v #%d %v", test.f, i, err)
- continue
- }
- buf.Write(b)
-
- case fPrintln:
- b, err := redirStdout(func() { spew.Println(test.in) })
- if err != nil {
- t.Errorf("%v #%d %v", test.f, i, err)
- continue
- }
- buf.Write(b)
-
- case fSdump:
- str := spew.Sdump(test.in)
- buf.WriteString(str)
-
- case fSprint:
- str := spew.Sprint(test.in)
- buf.WriteString(str)
-
- case fSprintf:
- str := spew.Sprintf(test.format, test.in)
- buf.WriteString(str)
-
- case fSprintln:
- str := spew.Sprintln(test.in)
- buf.WriteString(str)
-
- default:
- t.Errorf("%v #%d unrecognized function", test.f, i)
- continue
- }
- s := buf.String()
- if test.want != s {
- t.Errorf("ConfigState #%d\n got: %s want: %s", i, s, test.want)
- continue
- }
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/test_coverage.txt b/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/test_coverage.txt
deleted file mode 100644
index 2cd087a2a1273c5446897521ae85658fb8e66def..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/davecgh/go-spew@v1.1.1/test_coverage.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-
-github.com/davecgh/go-spew/spew/dump.go dumpState.dump 100.00% (88/88)
-github.com/davecgh/go-spew/spew/format.go formatState.format 100.00% (82/82)
-github.com/davecgh/go-spew/spew/format.go formatState.formatPtr 100.00% (52/52)
-github.com/davecgh/go-spew/spew/dump.go dumpState.dumpPtr 100.00% (44/44)
-github.com/davecgh/go-spew/spew/dump.go dumpState.dumpSlice 100.00% (39/39)
-github.com/davecgh/go-spew/spew/common.go handleMethods 100.00% (30/30)
-github.com/davecgh/go-spew/spew/common.go printHexPtr 100.00% (18/18)
-github.com/davecgh/go-spew/spew/common.go unsafeReflectValue 100.00% (13/13)
-github.com/davecgh/go-spew/spew/format.go formatState.constructOrigFormat 100.00% (12/12)
-github.com/davecgh/go-spew/spew/dump.go fdump 100.00% (11/11)
-github.com/davecgh/go-spew/spew/format.go formatState.Format 100.00% (11/11)
-github.com/davecgh/go-spew/spew/common.go init 100.00% (10/10)
-github.com/davecgh/go-spew/spew/common.go printComplex 100.00% (9/9)
-github.com/davecgh/go-spew/spew/common.go valuesSorter.Less 100.00% (8/8)
-github.com/davecgh/go-spew/spew/format.go formatState.buildDefaultFormat 100.00% (7/7)
-github.com/davecgh/go-spew/spew/format.go formatState.unpackValue 100.00% (5/5)
-github.com/davecgh/go-spew/spew/dump.go dumpState.indent 100.00% (4/4)
-github.com/davecgh/go-spew/spew/common.go catchPanic 100.00% (4/4)
-github.com/davecgh/go-spew/spew/config.go ConfigState.convertArgs 100.00% (4/4)
-github.com/davecgh/go-spew/spew/spew.go convertArgs 100.00% (4/4)
-github.com/davecgh/go-spew/spew/format.go newFormatter 100.00% (3/3)
-github.com/davecgh/go-spew/spew/dump.go Sdump 100.00% (3/3)
-github.com/davecgh/go-spew/spew/common.go printBool 100.00% (3/3)
-github.com/davecgh/go-spew/spew/common.go sortValues 100.00% (3/3)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Sdump 100.00% (3/3)
-github.com/davecgh/go-spew/spew/dump.go dumpState.unpackValue 100.00% (3/3)
-github.com/davecgh/go-spew/spew/spew.go Printf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Println 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Sprint 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Sprintf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Sprintln 100.00% (1/1)
-github.com/davecgh/go-spew/spew/common.go printFloat 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go NewDefaultConfig 100.00% (1/1)
-github.com/davecgh/go-spew/spew/common.go printInt 100.00% (1/1)
-github.com/davecgh/go-spew/spew/common.go printUint 100.00% (1/1)
-github.com/davecgh/go-spew/spew/common.go valuesSorter.Len 100.00% (1/1)
-github.com/davecgh/go-spew/spew/common.go valuesSorter.Swap 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Errorf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Fprint 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Fprintf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Fprintln 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Print 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Printf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Println 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Sprint 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Sprintf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Sprintln 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.NewFormatter 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Fdump 100.00% (1/1)
-github.com/davecgh/go-spew/spew/config.go ConfigState.Dump 100.00% (1/1)
-github.com/davecgh/go-spew/spew/dump.go Fdump 100.00% (1/1)
-github.com/davecgh/go-spew/spew/dump.go Dump 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Fprintln 100.00% (1/1)
-github.com/davecgh/go-spew/spew/format.go NewFormatter 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Errorf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Fprint 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Fprintf 100.00% (1/1)
-github.com/davecgh/go-spew/spew/spew.go Print 100.00% (1/1)
-github.com/davecgh/go-spew/spew ------------------------------- 100.00% (505/505)
-
diff --git a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/.travis.yml b/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/.travis.yml
deleted file mode 100644
index 90c9c6f917fb5c8d7bbb79db79b8ac168941553d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/.travis.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-language: go
-go:
- - 1.5
- - tip
-
diff --git a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/LICENSE b/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/LICENSE
deleted file mode 100644
index c67dad612a3dfca2b84599c640798d7be7d46728..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2013, Patrick Mezard
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
- The names of its contributors may not be used to endorse or promote
-products derived from this software without specific prior written
-permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/README.md b/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/README.md
deleted file mode 100644
index e87f307ed44fe4d73874eda51cb780c2b62bf611..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-go-difflib
-==========
-
-[](https://travis-ci.org/pmezard/go-difflib)
-[](https://godoc.org/github.com/pmezard/go-difflib/difflib)
-
-Go-difflib is a partial port of python 3 difflib package. Its main goal
-was to make unified and context diff available in pure Go, mostly for
-testing purposes.
-
-The following class and functions (and related tests) have be ported:
-
-* `SequenceMatcher`
-* `unified_diff()`
-* `context_diff()`
-
-## Installation
-
-```bash
-$ go get github.com/pmezard/go-difflib/difflib
-```
-
-### Quick Start
-
-Diffs are configured with Unified (or ContextDiff) structures, and can
-be output to an io.Writer or returned as a string.
-
-```Go
-diff := UnifiedDiff{
- A: difflib.SplitLines("foo\nbar\n"),
- B: difflib.SplitLines("foo\nbaz\n"),
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
-}
-text, _ := GetUnifiedDiffString(diff)
-fmt.Printf(text)
-```
-
-would output:
-
-```
---- Original
-+++ Current
-@@ -1,3 +1,3 @@
- foo
--bar
-+baz
-```
-
diff --git a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib.go b/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib.go
deleted file mode 100644
index 003e99fadb4f189565b409b9509ecf30b752d25a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib.go
+++ /dev/null
@@ -1,772 +0,0 @@
-// Package difflib is a partial port of Python difflib module.
-//
-// It provides tools to compare sequences of strings and generate textual diffs.
-//
-// The following class and functions have been ported:
-//
-// - SequenceMatcher
-//
-// - unified_diff
-//
-// - context_diff
-//
-// Getting unified diffs was the main goal of the port. Keep in mind this code
-// is mostly suitable to output text differences in a human friendly way, there
-// are no guarantees generated diffs are consumable by patch(1).
-package difflib
-
-import (
- "bufio"
- "bytes"
- "fmt"
- "io"
- "strings"
-)
-
-func min(a, b int) int {
- if a < b {
- return a
- }
- return b
-}
-
-func max(a, b int) int {
- if a > b {
- return a
- }
- return b
-}
-
-func calculateRatio(matches, length int) float64 {
- if length > 0 {
- return 2.0 * float64(matches) / float64(length)
- }
- return 1.0
-}
-
-type Match struct {
- A int
- B int
- Size int
-}
-
-type OpCode struct {
- Tag byte
- I1 int
- I2 int
- J1 int
- J2 int
-}
-
-// SequenceMatcher compares sequence of strings. The basic
-// algorithm predates, and is a little fancier than, an algorithm
-// published in the late 1980's by Ratcliff and Obershelp under the
-// hyperbolic name "gestalt pattern matching". The basic idea is to find
-// the longest contiguous matching subsequence that contains no "junk"
-// elements (R-O doesn't address junk). The same idea is then applied
-// recursively to the pieces of the sequences to the left and to the right
-// of the matching subsequence. This does not yield minimal edit
-// sequences, but does tend to yield matches that "look right" to people.
-//
-// SequenceMatcher tries to compute a "human-friendly diff" between two
-// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the
-// longest *contiguous* & junk-free matching subsequence. That's what
-// catches peoples' eyes. The Windows(tm) windiff has another interesting
-// notion, pairing up elements that appear uniquely in each sequence.
-// That, and the method here, appear to yield more intuitive difference
-// reports than does diff. This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
-// ordinary text files, or maybe "<P>" lines in HTML files). That may be
-// because this is the only method of the 3 that has a *concept* of
-// "junk" <wink>.
-//
-// Timing: Basic R-O is cubic time worst case and quadratic time expected
-// case. SequenceMatcher is quadratic time for the worst case and has
-// expected-case behavior dependent in a complicated way on how many
-// elements the sequences have in common; best case time is linear.
-type SequenceMatcher struct {
- a []string
- b []string
- b2j map[string][]int
- IsJunk func(string) bool
- autoJunk bool
- bJunk map[string]struct{}
- matchingBlocks []Match
- fullBCount map[string]int
- bPopular map[string]struct{}
- opCodes []OpCode
-}
-
-func NewMatcher(a, b []string) *SequenceMatcher {
- m := SequenceMatcher{autoJunk: true}
- m.SetSeqs(a, b)
- return &m
-}
-
-func NewMatcherWithJunk(a, b []string, autoJunk bool,
- isJunk func(string) bool) *SequenceMatcher {
-
- m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
- m.SetSeqs(a, b)
- return &m
-}
-
-// Set two sequences to be compared.
-func (m *SequenceMatcher) SetSeqs(a, b []string) {
- m.SetSeq1(a)
- m.SetSeq2(b)
-}
-
-// Set the first sequence to be compared. The second sequence to be compared is
-// not changed.
-//
-// SequenceMatcher computes and caches detailed information about the second
-// sequence, so if you want to compare one sequence S against many sequences,
-// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
-// sequences.
-//
-// See also SetSeqs() and SetSeq2().
-func (m *SequenceMatcher) SetSeq1(a []string) {
- if &a == &m.a {
- return
- }
- m.a = a
- m.matchingBlocks = nil
- m.opCodes = nil
-}
-
-// Set the second sequence to be compared. The first sequence to be compared is
-// not changed.
-func (m *SequenceMatcher) SetSeq2(b []string) {
- if &b == &m.b {
- return
- }
- m.b = b
- m.matchingBlocks = nil
- m.opCodes = nil
- m.fullBCount = nil
- m.chainB()
-}
-
-func (m *SequenceMatcher) chainB() {
- // Populate line -> index mapping
- b2j := map[string][]int{}
- for i, s := range m.b {
- indices := b2j[s]
- indices = append(indices, i)
- b2j[s] = indices
- }
-
- // Purge junk elements
- m.bJunk = map[string]struct{}{}
- if m.IsJunk != nil {
- junk := m.bJunk
- for s, _ := range b2j {
- if m.IsJunk(s) {
- junk[s] = struct{}{}
- }
- }
- for s, _ := range junk {
- delete(b2j, s)
- }
- }
-
- // Purge remaining popular elements
- popular := map[string]struct{}{}
- n := len(m.b)
- if m.autoJunk && n >= 200 {
- ntest := n/100 + 1
- for s, indices := range b2j {
- if len(indices) > ntest {
- popular[s] = struct{}{}
- }
- }
- for s, _ := range popular {
- delete(b2j, s)
- }
- }
- m.bPopular = popular
- m.b2j = b2j
-}
-
-func (m *SequenceMatcher) isBJunk(s string) bool {
- _, ok := m.bJunk[s]
- return ok
-}
-
-// Find longest matching block in a[alo:ahi] and b[blo:bhi].
-//
-// If IsJunk is not defined:
-//
-// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-// alo <= i <= i+k <= ahi
-// blo <= j <= j+k <= bhi
-// and for all (i',j',k') meeting those conditions,
-// k >= k'
-// i <= i'
-// and if i == i', j <= j'
-//
-// In other words, of all maximal matching blocks, return one that
-// starts earliest in a, and of all those maximal matching blocks that
-// start earliest in a, return the one that starts earliest in b.
-//
-// If IsJunk is defined, first the longest matching block is
-// determined as above, but with the additional restriction that no
-// junk element appears in the block. Then that block is extended as
-// far as possible by matching (only) junk elements on both sides. So
-// the resulting block never matches on junk except as identical junk
-// happens to be adjacent to an "interesting" match.
-//
-// If no blocks match, return (alo, blo, 0).
-func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
- // CAUTION: stripping common prefix or suffix would be incorrect.
- // E.g.,
- // ab
- // acab
- // Longest matching block is "ab", but if common prefix is
- // stripped, it's "a" (tied with "b"). UNIX(tm) diff does so
- // strip, so ends up claiming that ab is changed to acab by
- // inserting "ca" in the middle. That's minimal but unintuitive:
- // "it's obvious" that someone inserted "ac" at the front.
- // Windiff ends up at the same place as diff, but by pairing up
- // the unique 'b's and then matching the first two 'a's.
- besti, bestj, bestsize := alo, blo, 0
-
- // find longest junk-free match
- // during an iteration of the loop, j2len[j] = length of longest
- // junk-free match ending with a[i-1] and b[j]
- j2len := map[int]int{}
- for i := alo; i != ahi; i++ {
- // look at all instances of a[i] in b; note that because
- // b2j has no junk keys, the loop is skipped if a[i] is junk
- newj2len := map[int]int{}
- for _, j := range m.b2j[m.a[i]] {
- // a[i] matches b[j]
- if j < blo {
- continue
- }
- if j >= bhi {
- break
- }
- k := j2len[j-1] + 1
- newj2len[j] = k
- if k > bestsize {
- besti, bestj, bestsize = i-k+1, j-k+1, k
- }
- }
- j2len = newj2len
- }
-
- // Extend the best by non-junk elements on each end. In particular,
- // "popular" non-junk elements aren't in b2j, which greatly speeds
- // the inner loop above, but also means "the best" match so far
- // doesn't contain any junk *or* popular non-junk elements.
- for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- !m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- // Now that we have a wholly interesting match (albeit possibly
- // empty!), we may as well suck up the matching junk on each
- // side of it too. Can't think of a good reason not to, and it
- // saves post-processing the (possibly considerable) expense of
- // figuring out what to do with it. In the case of an empty
- // interesting match, this is clearly the right thing to do,
- // because no other kind of match is possible in the regions.
- for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- return Match{A: besti, B: bestj, Size: bestsize}
-}
-
-// Return list of triples describing matching subsequences.
-//
-// Each triple is of the form (i, j, n), and means that
-// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
-// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
-// adjacent triples in the list, and the second is not the last triple in the
-// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
-// adjacent equal blocks.
-//
-// The last triple is a dummy, (len(a), len(b), 0), and is the only
-// triple with n==0.
-func (m *SequenceMatcher) GetMatchingBlocks() []Match {
- if m.matchingBlocks != nil {
- return m.matchingBlocks
- }
-
- var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
- matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
- match := m.findLongestMatch(alo, ahi, blo, bhi)
- i, j, k := match.A, match.B, match.Size
- if match.Size > 0 {
- if alo < i && blo < j {
- matched = matchBlocks(alo, i, blo, j, matched)
- }
- matched = append(matched, match)
- if i+k < ahi && j+k < bhi {
- matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
- }
- }
- return matched
- }
- matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
-
- // It's possible that we have adjacent equal blocks in the
- // matching_blocks list now.
- nonAdjacent := []Match{}
- i1, j1, k1 := 0, 0, 0
- for _, b := range matched {
- // Is this block adjacent to i1, j1, k1?
- i2, j2, k2 := b.A, b.B, b.Size
- if i1+k1 == i2 && j1+k1 == j2 {
- // Yes, so collapse them -- this just increases the length of
- // the first block by the length of the second, and the first
- // block so lengthened remains the block to compare against.
- k1 += k2
- } else {
- // Not adjacent. Remember the first block (k1==0 means it's
- // the dummy we started with), and make the second block the
- // new block to compare against.
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
- }
- i1, j1, k1 = i2, j2, k2
- }
- }
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
- }
-
- nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
- m.matchingBlocks = nonAdjacent
- return m.matchingBlocks
-}
-
-// Return list of 5-tuples describing how to turn a into b.
-//
-// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple
-// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
-// tuple preceding it, and likewise for j1 == the previous j2.
-//
-// The tags are characters, with these meanings:
-//
-// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]
-//
-// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.
-//
-// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
-//
-// 'e' (equal): a[i1:i2] == b[j1:j2]
-func (m *SequenceMatcher) GetOpCodes() []OpCode {
- if m.opCodes != nil {
- return m.opCodes
- }
- i, j := 0, 0
- matching := m.GetMatchingBlocks()
- opCodes := make([]OpCode, 0, len(matching))
- for _, m := range matching {
- // invariant: we've pumped out correct diffs to change
- // a[:i] into b[:j], and the next matching block is
- // a[ai:ai+size] == b[bj:bj+size]. So we need to pump
- // out a diff to change a[i:ai] into b[j:bj], pump out
- // the matching block, and move (i,j) beyond the match
- ai, bj, size := m.A, m.B, m.Size
- tag := byte(0)
- if i < ai && j < bj {
- tag = 'r'
- } else if i < ai {
- tag = 'd'
- } else if j < bj {
- tag = 'i'
- }
- if tag > 0 {
- opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
- }
- i, j = ai+size, bj+size
- // the list of matching blocks is terminated by a
- // sentinel with size 0
- if size > 0 {
- opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
- }
- }
- m.opCodes = opCodes
- return m.opCodes
-}
-
-// Isolate change clusters by eliminating ranges with no changes.
-//
-// Return a generator of groups with up to n lines of context.
-// Each group is in the same format as returned by GetOpCodes().
-func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
- if n < 0 {
- n = 3
- }
- codes := m.GetOpCodes()
- if len(codes) == 0 {
- codes = []OpCode{OpCode{'e', 0, 1, 0, 1}}
- }
- // Fixup leading and trailing groups if they show no changes.
- if codes[0].Tag == 'e' {
- c := codes[0]
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
- }
- if codes[len(codes)-1].Tag == 'e' {
- c := codes[len(codes)-1]
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
- }
- nn := n + n
- groups := [][]OpCode{}
- group := []OpCode{}
- for _, c := range codes {
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- // End the current group and start a new one whenever
- // there is a large range with no changes.
- if c.Tag == 'e' && i2-i1 > nn {
- group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
- j1, min(j2, j1+n)})
- groups = append(groups, group)
- group = []OpCode{}
- i1, j1 = max(i1, i2-n), max(j1, j2-n)
- }
- group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
- }
- if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
- groups = append(groups, group)
- }
- return groups
-}
-
-// Return a measure of the sequences' similarity (float in [0,1]).
-//
-// Where T is the total number of elements in both sequences, and
-// M is the number of matches, this is 2.0*M / T.
-// Note that this is 1 if the sequences are identical, and 0 if
-// they have nothing in common.
-//
-// .Ratio() is expensive to compute if you haven't already computed
-// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
-// want to try .QuickRatio() or .RealQuickRation() first to get an
-// upper bound.
-func (m *SequenceMatcher) Ratio() float64 {
- matches := 0
- for _, m := range m.GetMatchingBlocks() {
- matches += m.Size
- }
- return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() relatively quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute.
-func (m *SequenceMatcher) QuickRatio() float64 {
- // viewing a and b as multisets, set matches to the cardinality
- // of their intersection; this counts the number of matches
- // without regard to order, so is clearly an upper bound
- if m.fullBCount == nil {
- m.fullBCount = map[string]int{}
- for _, s := range m.b {
- m.fullBCount[s] = m.fullBCount[s] + 1
- }
- }
-
- // avail[x] is the number of times x appears in 'b' less the
- // number of times we've seen it in 'a' so far ... kinda
- avail := map[string]int{}
- matches := 0
- for _, s := range m.a {
- n, ok := avail[s]
- if !ok {
- n = m.fullBCount[s]
- }
- avail[s] = n - 1
- if n > 0 {
- matches += 1
- }
- }
- return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() very quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute than either .Ratio() or .QuickRatio().
-func (m *SequenceMatcher) RealQuickRatio() float64 {
- la, lb := len(m.a), len(m.b)
- return calculateRatio(min(la, lb), la+lb)
-}
-
-// Convert range to the "ed" format
-func formatRangeUnified(start, stop int) string {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- beginning := start + 1 // lines start numbering with one
- length := stop - start
- if length == 1 {
- return fmt.Sprintf("%d", beginning)
- }
- if length == 0 {
- beginning -= 1 // empty ranges begin at line just before the range
- }
- return fmt.Sprintf("%d,%d", beginning, length)
-}
-
-// Unified diff parameters
-type UnifiedDiff struct {
- A []string // First sequence lines
- FromFile string // First file name
- FromDate string // First file time
- B []string // Second sequence lines
- ToFile string // Second file name
- ToDate string // Second file time
- Eol string // Headers end of line, defaults to LF
- Context int // Number of context lines
-}
-
-// Compare two sequences of lines; generate the delta as a unified diff.
-//
-// Unified diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by 'n' which
-// defaults to three.
-//
-// By default, the diff control lines (those with ---, +++, or @@) are
-// created with a trailing newline. This is helpful so that inputs
-// created from file.readlines() result in diffs that are suitable for
-// file.writelines() since both the inputs and outputs have trailing
-// newlines.
-//
-// For inputs that do not have trailing newlines, set the lineterm
-// argument to "" so that the output will be uniformly newline free.
-//
-// The unidiff format normally has a header for filenames and modification
-// times. Any or all of these may be specified using strings for
-// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
-// The modification times are normally expressed in the ISO 8601 format.
-func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
- buf := bufio.NewWriter(writer)
- defer buf.Flush()
- wf := func(format string, args ...interface{}) error {
- _, err := buf.WriteString(fmt.Sprintf(format, args...))
- return err
- }
- ws := func(s string) error {
- _, err := buf.WriteString(s)
- return err
- }
-
- if len(diff.Eol) == 0 {
- diff.Eol = "\n"
- }
-
- started := false
- m := NewMatcher(diff.A, diff.B)
- for _, g := range m.GetGroupedOpCodes(diff.Context) {
- if !started {
- started = true
- fromDate := ""
- if len(diff.FromDate) > 0 {
- fromDate = "\t" + diff.FromDate
- }
- toDate := ""
- if len(diff.ToDate) > 0 {
- toDate = "\t" + diff.ToDate
- }
- if diff.FromFile != "" || diff.ToFile != "" {
- err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
- if err != nil {
- return err
- }
- err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
- if err != nil {
- return err
- }
- }
- }
- first, last := g[0], g[len(g)-1]
- range1 := formatRangeUnified(first.I1, last.I2)
- range2 := formatRangeUnified(first.J1, last.J2)
- if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
- return err
- }
- for _, c := range g {
- i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
- if c.Tag == 'e' {
- for _, line := range diff.A[i1:i2] {
- if err := ws(" " + line); err != nil {
- return err
- }
- }
- continue
- }
- if c.Tag == 'r' || c.Tag == 'd' {
- for _, line := range diff.A[i1:i2] {
- if err := ws("-" + line); err != nil {
- return err
- }
- }
- }
- if c.Tag == 'r' || c.Tag == 'i' {
- for _, line := range diff.B[j1:j2] {
- if err := ws("+" + line); err != nil {
- return err
- }
- }
- }
- }
- }
- return nil
-}
-
-// Like WriteUnifiedDiff but returns the diff a string.
-func GetUnifiedDiffString(diff UnifiedDiff) (string, error) {
- w := &bytes.Buffer{}
- err := WriteUnifiedDiff(w, diff)
- return string(w.Bytes()), err
-}
-
-// Convert range to the "ed" format.
-func formatRangeContext(start, stop int) string {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- beginning := start + 1 // lines start numbering with one
- length := stop - start
- if length == 0 {
- beginning -= 1 // empty ranges begin at line just before the range
- }
- if length <= 1 {
- return fmt.Sprintf("%d", beginning)
- }
- return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
-}
-
-type ContextDiff UnifiedDiff
-
-// Compare two sequences of lines; generate the delta as a context diff.
-//
-// Context diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by diff.Context
-// which defaults to three.
-//
-// By default, the diff control lines (those with *** or ---) are
-// created with a trailing newline.
-//
-// For inputs that do not have trailing newlines, set the diff.Eol
-// argument to "" so that the output will be uniformly newline free.
-//
-// The context diff format normally has a header for filenames and
-// modification times. Any or all of these may be specified using
-// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
-// The modification times are normally expressed in the ISO 8601 format.
-// If not specified, the strings default to blanks.
-func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
- buf := bufio.NewWriter(writer)
- defer buf.Flush()
- var diffErr error
- wf := func(format string, args ...interface{}) {
- _, err := buf.WriteString(fmt.Sprintf(format, args...))
- if diffErr == nil && err != nil {
- diffErr = err
- }
- }
- ws := func(s string) {
- _, err := buf.WriteString(s)
- if diffErr == nil && err != nil {
- diffErr = err
- }
- }
-
- if len(diff.Eol) == 0 {
- diff.Eol = "\n"
- }
-
- prefix := map[byte]string{
- 'i': "+ ",
- 'd': "- ",
- 'r': "! ",
- 'e': " ",
- }
-
- started := false
- m := NewMatcher(diff.A, diff.B)
- for _, g := range m.GetGroupedOpCodes(diff.Context) {
- if !started {
- started = true
- fromDate := ""
- if len(diff.FromDate) > 0 {
- fromDate = "\t" + diff.FromDate
- }
- toDate := ""
- if len(diff.ToDate) > 0 {
- toDate = "\t" + diff.ToDate
- }
- if diff.FromFile != "" || diff.ToFile != "" {
- wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
- wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
- }
- }
-
- first, last := g[0], g[len(g)-1]
- ws("***************" + diff.Eol)
-
- range1 := formatRangeContext(first.I1, last.I2)
- wf("*** %s ****%s", range1, diff.Eol)
- for _, c := range g {
- if c.Tag == 'r' || c.Tag == 'd' {
- for _, cc := range g {
- if cc.Tag == 'i' {
- continue
- }
- for _, line := range diff.A[cc.I1:cc.I2] {
- ws(prefix[cc.Tag] + line)
- }
- }
- break
- }
- }
-
- range2 := formatRangeContext(first.J1, last.J2)
- wf("--- %s ----%s", range2, diff.Eol)
- for _, c := range g {
- if c.Tag == 'r' || c.Tag == 'i' {
- for _, cc := range g {
- if cc.Tag == 'd' {
- continue
- }
- for _, line := range diff.B[cc.J1:cc.J2] {
- ws(prefix[cc.Tag] + line)
- }
- }
- break
- }
- }
- }
- return diffErr
-}
-
-// Like WriteContextDiff but returns the diff a string.
-func GetContextDiffString(diff ContextDiff) (string, error) {
- w := &bytes.Buffer{}
- err := WriteContextDiff(w, diff)
- return string(w.Bytes()), err
-}
-
-// Split a string on "\n" while preserving them. The output can be used
-// as input for UnifiedDiff and ContextDiff structures.
-func SplitLines(s string) []string {
- lines := strings.SplitAfter(s, "\n")
- lines[len(lines)-1] += "\n"
- return lines
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib_test.go b/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib_test.go
deleted file mode 100644
index d725119620740eaaa4adfb3f3b927bb4c02907db..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/pmezard/go-difflib@v1.0.0/difflib/difflib_test.go
+++ /dev/null
@@ -1,426 +0,0 @@
-package difflib
-
-import (
- "bytes"
- "fmt"
- "math"
- "reflect"
- "strings"
- "testing"
-)
-
-func assertAlmostEqual(t *testing.T, a, b float64, places int) {
- if math.Abs(a-b) > math.Pow10(-places) {
- t.Errorf("%.7f != %.7f", a, b)
- }
-}
-
-func assertEqual(t *testing.T, a, b interface{}) {
- if !reflect.DeepEqual(a, b) {
- t.Errorf("%v != %v", a, b)
- }
-}
-
-func splitChars(s string) []string {
- chars := make([]string, 0, len(s))
- // Assume ASCII inputs
- for i := 0; i != len(s); i++ {
- chars = append(chars, string(s[i]))
- }
- return chars
-}
-
-func TestSequenceMatcherRatio(t *testing.T) {
- s := NewMatcher(splitChars("abcd"), splitChars("bcde"))
- assertEqual(t, s.Ratio(), 0.75)
- assertEqual(t, s.QuickRatio(), 0.75)
- assertEqual(t, s.RealQuickRatio(), 1.0)
-}
-
-func TestGetOptCodes(t *testing.T) {
- a := "qabxcd"
- b := "abycdf"
- s := NewMatcher(splitChars(a), splitChars(b))
- w := &bytes.Buffer{}
- for _, op := range s.GetOpCodes() {
- fmt.Fprintf(w, "%s a[%d:%d], (%s) b[%d:%d] (%s)\n", string(op.Tag),
- op.I1, op.I2, a[op.I1:op.I2], op.J1, op.J2, b[op.J1:op.J2])
- }
- result := string(w.Bytes())
- expected := `d a[0:1], (q) b[0:0] ()
-e a[1:3], (ab) b[0:2] (ab)
-r a[3:4], (x) b[2:3] (y)
-e a[4:6], (cd) b[3:5] (cd)
-i a[6:6], () b[5:6] (f)
-`
- if expected != result {
- t.Errorf("unexpected op codes: \n%s", result)
- }
-}
-
-func TestGroupedOpCodes(t *testing.T) {
- a := []string{}
- for i := 0; i != 39; i++ {
- a = append(a, fmt.Sprintf("%02d", i))
- }
- b := []string{}
- b = append(b, a[:8]...)
- b = append(b, " i")
- b = append(b, a[8:19]...)
- b = append(b, " x")
- b = append(b, a[20:22]...)
- b = append(b, a[27:34]...)
- b = append(b, " y")
- b = append(b, a[35:]...)
- s := NewMatcher(a, b)
- w := &bytes.Buffer{}
- for _, g := range s.GetGroupedOpCodes(-1) {
- fmt.Fprintf(w, "group\n")
- for _, op := range g {
- fmt.Fprintf(w, " %s, %d, %d, %d, %d\n", string(op.Tag),
- op.I1, op.I2, op.J1, op.J2)
- }
- }
- result := string(w.Bytes())
- expected := `group
- e, 5, 8, 5, 8
- i, 8, 8, 8, 9
- e, 8, 11, 9, 12
-group
- e, 16, 19, 17, 20
- r, 19, 20, 20, 21
- e, 20, 22, 21, 23
- d, 22, 27, 23, 23
- e, 27, 30, 23, 26
-group
- e, 31, 34, 27, 30
- r, 34, 35, 30, 31
- e, 35, 38, 31, 34
-`
- if expected != result {
- t.Errorf("unexpected op codes: \n%s", result)
- }
-}
-
-func ExampleGetUnifiedDiffCode() {
- a := `one
-two
-three
-four
-fmt.Printf("%s,%T",a,b)`
- b := `zero
-one
-three
-four`
- diff := UnifiedDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- FromDate: "2005-01-26 23:30:50",
- ToFile: "Current",
- ToDate: "2010-04-02 10:20:52",
- Context: 3,
- }
- result, _ := GetUnifiedDiffString(diff)
- fmt.Println(strings.Replace(result, "\t", " ", -1))
- // Output:
- // --- Original 2005-01-26 23:30:50
- // +++ Current 2010-04-02 10:20:52
- // @@ -1,5 +1,4 @@
- // +zero
- // one
- // -two
- // three
- // four
- // -fmt.Printf("%s,%T",a,b)
-}
-
-func ExampleGetContextDiffCode() {
- a := `one
-two
-three
-four
-fmt.Printf("%s,%T",a,b)`
- b := `zero
-one
-tree
-four`
- diff := ContextDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- Eol: "\n",
- }
- result, _ := GetContextDiffString(diff)
- fmt.Print(strings.Replace(result, "\t", " ", -1))
- // Output:
- // *** Original
- // --- Current
- // ***************
- // *** 1,5 ****
- // one
- // ! two
- // ! three
- // four
- // - fmt.Printf("%s,%T",a,b)
- // --- 1,4 ----
- // + zero
- // one
- // ! tree
- // four
-}
-
-func ExampleGetContextDiffString() {
- a := `one
-two
-three
-four`
- b := `zero
-one
-tree
-four`
- diff := ContextDiff{
- A: SplitLines(a),
- B: SplitLines(b),
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- Eol: "\n",
- }
- result, _ := GetContextDiffString(diff)
- fmt.Printf(strings.Replace(result, "\t", " ", -1))
- // Output:
- // *** Original
- // --- Current
- // ***************
- // *** 1,4 ****
- // one
- // ! two
- // ! three
- // four
- // --- 1,4 ----
- // + zero
- // one
- // ! tree
- // four
-}
-
-func rep(s string, count int) string {
- return strings.Repeat(s, count)
-}
-
-func TestWithAsciiOneInsert(t *testing.T) {
- sm := NewMatcher(splitChars(rep("b", 100)),
- splitChars("a"+rep("b", 100)))
- assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'i', 0, 0, 0, 1}, {'e', 0, 100, 1, 101}})
- assertEqual(t, len(sm.bPopular), 0)
-
- sm = NewMatcher(splitChars(rep("b", 100)),
- splitChars(rep("b", 50)+"a"+rep("b", 50)))
- assertAlmostEqual(t, sm.Ratio(), 0.995, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'e', 0, 50, 0, 50}, {'i', 50, 50, 50, 51}, {'e', 50, 100, 51, 101}})
- assertEqual(t, len(sm.bPopular), 0)
-}
-
-func TestWithAsciiOnDelete(t *testing.T) {
- sm := NewMatcher(splitChars(rep("a", 40)+"c"+rep("b", 40)),
- splitChars(rep("a", 40)+rep("b", 40)))
- assertAlmostEqual(t, sm.Ratio(), 0.994, 3)
- assertEqual(t, sm.GetOpCodes(),
- []OpCode{{'e', 0, 40, 0, 40}, {'d', 40, 41, 40, 40}, {'e', 41, 81, 40, 80}})
-}
-
-func TestWithAsciiBJunk(t *testing.T) {
- isJunk := func(s string) bool {
- return s == " "
- }
- sm := NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)), true, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{})
-
- sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}})
-
- isJunk = func(s string) bool {
- return s == " " || s == "b"
- }
- sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)),
- splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk)
- assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}, "b": struct{}{}})
-}
-
-func TestSFBugsRatioForNullSeqn(t *testing.T) {
- sm := NewMatcher(nil, nil)
- assertEqual(t, sm.Ratio(), 1.0)
- assertEqual(t, sm.QuickRatio(), 1.0)
- assertEqual(t, sm.RealQuickRatio(), 1.0)
-}
-
-func TestSFBugsComparingEmptyLists(t *testing.T) {
- groups := NewMatcher(nil, nil).GetGroupedOpCodes(-1)
- assertEqual(t, len(groups), 0)
- diff := UnifiedDiff{
- FromFile: "Original",
- ToFile: "Current",
- Context: 3,
- }
- result, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, result, "")
-}
-
-func TestOutputFormatRangeFormatUnified(t *testing.T) {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- //
- // Each <range> field shall be of the form:
- // %1d", <beginning line number> if the range contains exactly one line,
- // and:
- // "%1d,%1d", <beginning line number>, <number of lines> otherwise.
- // If a range is empty, its beginning line number shall be the number of
- // the line just before the range, or 0 if the empty range starts the file.
- fm := formatRangeUnified
- assertEqual(t, fm(3, 3), "3,0")
- assertEqual(t, fm(3, 4), "4")
- assertEqual(t, fm(3, 5), "4,2")
- assertEqual(t, fm(3, 6), "4,3")
- assertEqual(t, fm(0, 0), "0,0")
-}
-
-func TestOutputFormatRangeFormatContext(t *testing.T) {
- // Per the diff spec at http://www.unix.org/single_unix_specification/
- //
- // The range of lines in file1 shall be written in the following format
- // if the range contains two or more lines:
- // "*** %d,%d ****\n", <beginning line number>, <ending line number>
- // and the following format otherwise:
- // "*** %d ****\n", <ending line number>
- // The ending line number of an empty range shall be the number of the preceding line,
- // or 0 if the range is at the start of the file.
- //
- // Next, the range of lines in file2 shall be written in the following format
- // if the range contains two or more lines:
- // "--- %d,%d ----\n", <beginning line number>, <ending line number>
- // and the following format otherwise:
- // "--- %d ----\n", <ending line number>
- fm := formatRangeContext
- assertEqual(t, fm(3, 3), "3")
- assertEqual(t, fm(3, 4), "4")
- assertEqual(t, fm(3, 5), "4,5")
- assertEqual(t, fm(3, 6), "4,6")
- assertEqual(t, fm(0, 0), "0")
-}
-
-func TestOutputFormatTabDelimiter(t *testing.T) {
- diff := UnifiedDiff{
- A: splitChars("one"),
- B: splitChars("two"),
- FromFile: "Original",
- FromDate: "2005-01-26 23:30:50",
- ToFile: "Current",
- ToDate: "2010-04-12 10:20:52",
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud)[:2], []string{
- "--- Original\t2005-01-26 23:30:50\n",
- "+++ Current\t2010-04-12 10:20:52\n",
- })
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd)[:2], []string{
- "*** Original\t2005-01-26 23:30:50\n",
- "--- Current\t2010-04-12 10:20:52\n",
- })
-}
-
-func TestOutputFormatNoTrailingTabOnEmptyFiledate(t *testing.T) {
- diff := UnifiedDiff{
- A: splitChars("one"),
- B: splitChars("two"),
- FromFile: "Original",
- ToFile: "Current",
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud)[:2], []string{"--- Original\n", "+++ Current\n"})
-
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd)[:2], []string{"*** Original\n", "--- Current\n"})
-}
-
-func TestOmitFilenames(t *testing.T) {
- diff := UnifiedDiff{
- A: SplitLines("o\nn\ne\n"),
- B: SplitLines("t\nw\no\n"),
- Eol: "\n",
- }
- ud, err := GetUnifiedDiffString(diff)
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(ud), []string{
- "@@ -0,0 +1,2 @@\n",
- "+t\n",
- "+w\n",
- "@@ -2,2 +3,0 @@\n",
- "-n\n",
- "-e\n",
- "\n",
- })
-
- cd, err := GetContextDiffString(ContextDiff(diff))
- assertEqual(t, err, nil)
- assertEqual(t, SplitLines(cd), []string{
- "***************\n",
- "*** 0 ****\n",
- "--- 1,2 ----\n",
- "+ t\n",
- "+ w\n",
- "***************\n",
- "*** 2,3 ****\n",
- "- n\n",
- "- e\n",
- "--- 3 ----\n",
- "\n",
- })
-}
-
-func TestSplitLines(t *testing.T) {
- allTests := []struct {
- input string
- want []string
- }{
- {"foo", []string{"foo\n"}},
- {"foo\nbar", []string{"foo\n", "bar\n"}},
- {"foo\nbar\n", []string{"foo\n", "bar\n", "\n"}},
- }
- for _, test := range allTests {
- assertEqual(t, SplitLines(test.input), test.want)
- }
-}
-
-func benchmarkSplitLines(b *testing.B, count int) {
- str := strings.Repeat("foo\n", count)
-
- b.ResetTimer()
-
- n := 0
- for i := 0; i < b.N; i++ {
- n += len(SplitLines(str))
- }
-}
-
-func BenchmarkSplitLines100(b *testing.B) {
- benchmarkSplitLines(b, 100)
-}
-
-func BenchmarkSplitLines10000(b *testing.B) {
- benchmarkSplitLines(b, 10000)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gofmt.sh b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gofmt.sh
deleted file mode 100644
index 3f2e5d329fe8acf2e6d5253e670e39a76e244578..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gofmt.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-if [ -n "$(gofmt -l .)" ]; then
- echo "Go code is not formatted:"
- gofmt -d .
- exit 1
-fi
-
-go generate ./...
-if [ -n "$(git status -s -uno)" ]; then
- echo "Go generate output does not match commit."
- echo "Did you forget to run go generate ./... ?"
- exit 1
-fi
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gogenerate.sh b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gogenerate.sh
deleted file mode 100644
index 3fc73fea7633486b3dd0a2212efdf33ab618b75f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.gogenerate.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-
-# If GOMOD is defined we are running with Go Modules enabled, either
-# automatically or via the GO111MODULE=on environment variable. Codegen only
-# works with modules, so skip generation if modules is not in use.
-if [[ -z "$(go env GOMOD)" ]]; then
- echo "Skipping go generate because modules not enabled and required"
- exit 0
-fi
-
-go generate ./...
-if [ -n "$(git diff)" ]; then
- echo "Go generate had not been run"
- git diff
- exit 1
-fi
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.govet.sh b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.govet.sh
deleted file mode 100644
index 77aeb5c47eabd1b0cfbf64cf66a42766a9475f24..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.ci.govet.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-set -e
-
-go vet ./...
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/dependabot.yml b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/dependabot.yml
deleted file mode 100644
index bf6944e71bdc96eea89f926a9e32a810a532108e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/dependabot.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: gomod
- directory: /
- schedule:
- interval: daily
-- package-ecosystem: github-actions
- directory: /
- schedule:
- interval: daily
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/pull_request_template.md b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/pull_request_template.md
deleted file mode 100644
index ba09b9b30926a5c0b2cc012fbe72b9d55e01fbdb..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/pull_request_template.md
+++ /dev/null
@@ -1,15 +0,0 @@
-## Summary
-<!-- High-level, one sentence summary of what this PR accomplishes -->
-
-## Changes
-<!-- * Description of change 1 -->
-<!-- * Description of change 2 -->
-<!-- ... -->
-
-## Motivation
-<!-- Why were the changes necessary. -->
-
-<!-- ## Example usage (if applicable) -->
-
-## Related issues
-<!-- Put `Closes #XXXX` for each issue number this PR fixes/closes -->
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/workflows/main.yml b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/workflows/main.yml
deleted file mode 100644
index 12a23ea615a7b46d6bdd5a53c6a8a739d5cab4f6..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.github/workflows/main.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-name: All builds
-on: [push, pull_request]
-
-jobs:
- build:
- runs-on: ubuntu-latest
- strategy:
- matrix:
- go_version: ["1.18.1", "1.17.6", "1.16.5"]
- steps:
- - uses: actions/checkout@v3
- - name: Setup Go
- uses: actions/setup-go@v3.2.0
- with:
- go-version: ${{ matrix.go_version }}
- - run: ./.ci.gogenerate.sh
- - run: ./.ci.gofmt.sh
- - run: ./.ci.govet.sh
- - run: go test -v -race ./...
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.gitignore b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.gitignore
deleted file mode 100644
index 5aacdb7cca624915c6d0770d5b92405d006e9fd1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/.gitignore
+++ /dev/null
@@ -1,24 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-.DS_Store
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/CONTRIBUTING.md b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/CONTRIBUTING.md
deleted file mode 100644
index a3a062ce99547814c5d4e2911c60a52b6adb60a4..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/CONTRIBUTING.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Contributing to Testify
-
-So you'd like to contribute to Testify? First of all, thank you! Testify is widely used, so each
-contribution has a significant impact within the Golang community! Below you'll find everything you
-need to know to get up to speed on the project.
-
-## Philosophy
-
-The Testify maintainers generally attempt to follow widely accepted practices within the Golang
-community. That being said, the first priority is always to make sure that the package is useful to
-the community. A few general guidelines are listed here:
-
-*Keep it simple (whenever practical)* - Try not to expand the API unless the new surface area
-provides meaningful benefits. For example, don't add functions because they might be useful to
-someone, someday. Add what is useful to specific users, today.
-
-*Ease of use is paramount* - This means good documentation and package organization. It also means
-that we should try hard to use meaningful, descriptive function names, avoid breaking the API
-unnecessarily, and try not to surprise the user.
-
-*Quality isn't an afterthought* - Testify is a testing library, so it seems reasonable that we
-should have a decent test suite. This is doubly important because a bug in Testify doesn't just mean
-a bug in our users' code, it means a bug in our users' tests, which means a potentially unnoticed
-and hard-to-find bug in our users' code.
-
-## Pull Requests
-
-We welcome pull requests! Please include the following in the description:
-
- * Motivation, why your change is important or helpful
- * Example usage (if applicable)
- * Whether you intend to add / change behavior or fix a bug
-
-Please be aware that the maintainers may ask for changes. This isn't a commentary on the quality of
-your idea or your code. Testify is the result of many contributions from many individuals, so we
-need to enforce certain practices and patterns to keep the package easy for others to understand.
-Essentially, we recognize that there are often many good ways to do a given thing, but we have to
-pick one and stick with it.
-
-See `MAINTAINERS.md` for a list of users who can approve / merge your changes.
-
-## Issues
-
-If you find a bug or think of a useful feature you'd like to see added to Testify, the best thing
-you can do is make the necessary changes and open a pull request (see above). If that isn't an
-option, or if you'd like to discuss your change before you write the code, open an issue!
-
-Please provide enough context in the issue description that other members of the community can
-easily understand what it is that you'd like to see.
-
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/LICENSE b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/LICENSE
deleted file mode 100644
index 4b0421cf9ee47908beae4b4648babb75b09ee028..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2012-2020 Mat Ryer, Tyler Bunnell and contributors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/MAINTAINERS.md b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/MAINTAINERS.md
deleted file mode 100644
index b6c1ddefe314c5dd222fe13d683fc755028d1e30..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/MAINTAINERS.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Testify Maintainers
-
-The individuals listed below are active in the project and have the ability to approve and merge
-pull requests.
-
- * @glesica
- * @boyan-soubachov
- * @mvdkleijn
-
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/README.md b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/README.md
deleted file mode 100644
index ce6d3de280a39fdc198127c1dddae75a797a494b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/README.md
+++ /dev/null
@@ -1,371 +0,0 @@
-Testify - Thou Shalt Write Tests
-================================
-
-ℹ️ We are working on testify v2 and would love to hear what you'd like to see in it, have your say here: https://cutt.ly/testify
-
-[](https://travis-ci.org/stretchr/testify) [](https://goreportcard.com/report/github.com/stretchr/testify) [](https://pkg.go.dev/github.com/stretchr/testify)
-
-Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend.
-
-Features include:
-
- * [Easy assertions](#assert-package)
- * [Mocking](#mock-package)
- * [Testing suite interfaces and functions](#suite-package)
-
-Get started:
-
- * Install testify with [one line of code](#installation), or [update it with another](#staying-up-to-date)
- * For an introduction to writing test code in Go, see http://golang.org/doc/code.html#Testing
- * Check out the API Documentation http://godoc.org/github.com/stretchr/testify
- * To make your testing life easier, check out our other project, [gorc](http://github.com/stretchr/gorc)
- * A little about [Test-Driven Development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development)
-
-
-
-[`assert`](http://godoc.org/github.com/stretchr/testify/assert "API documentation") package
--------------------------------------------------------------------------------------------
-
-The `assert` package provides some helpful methods that allow you to write better test code in Go.
-
- * Prints friendly, easy to read failure descriptions
- * Allows for very readable code
- * Optionally annotate each assertion with a message
-
-See it in action:
-
-```go
-package yours
-
-import (
- "testing"
- "github.com/stretchr/testify/assert"
-)
-
-func TestSomething(t *testing.T) {
-
- // assert equality
- assert.Equal(t, 123, 123, "they should be equal")
-
- // assert inequality
- assert.NotEqual(t, 123, 456, "they should not be equal")
-
- // assert for nil (good for errors)
- assert.Nil(t, object)
-
- // assert for not nil (good when you expect something)
- if assert.NotNil(t, object) {
-
- // now we know that object isn't nil, we are safe to make
- // further assertions without causing any errors
- assert.Equal(t, "Something", object.Value)
-
- }
-
-}
-```
-
- * Every assert func takes the `testing.T` object as the first argument. This is how it writes the errors out through the normal `go test` capabilities.
- * Every assert func returns a bool indicating whether the assertion was successful or not, this is useful for if you want to go on making further assertions under certain conditions.
-
-if you assert many times, use the below:
-
-```go
-package yours
-
-import (
- "testing"
- "github.com/stretchr/testify/assert"
-)
-
-func TestSomething(t *testing.T) {
- assert := assert.New(t)
-
- // assert equality
- assert.Equal(123, 123, "they should be equal")
-
- // assert inequality
- assert.NotEqual(123, 456, "they should not be equal")
-
- // assert for nil (good for errors)
- assert.Nil(object)
-
- // assert for not nil (good when you expect something)
- if assert.NotNil(object) {
-
- // now we know that object isn't nil, we are safe to make
- // further assertions without causing any errors
- assert.Equal("Something", object.Value)
- }
-}
-```
-
-[`require`](http://godoc.org/github.com/stretchr/testify/require "API documentation") package
----------------------------------------------------------------------------------------------
-
-The `require` package provides same global functions as the `assert` package, but instead of returning a boolean result they terminate current test.
-
-See [t.FailNow](http://golang.org/pkg/testing/#T.FailNow) for details.
-
-[`mock`](http://godoc.org/github.com/stretchr/testify/mock "API documentation") package
-----------------------------------------------------------------------------------------
-
-The `mock` package provides a mechanism for easily writing mock objects that can be used in place of real objects when writing test code.
-
-An example test function that tests a piece of code that relies on an external object `testObj`, can setup expectations (testify) and assert that they indeed happened:
-
-```go
-package yours
-
-import (
- "testing"
- "github.com/stretchr/testify/mock"
-)
-
-/*
- Test objects
-*/
-
-// MyMockedObject is a mocked object that implements an interface
-// that describes an object that the code I am testing relies on.
-type MyMockedObject struct{
- mock.Mock
-}
-
-// DoSomething is a method on MyMockedObject that implements some interface
-// and just records the activity, and returns what the Mock object tells it to.
-//
-// In the real object, this method would do something useful, but since this
-// is a mocked object - we're just going to stub it out.
-//
-// NOTE: This method is not being tested here, code that uses this object is.
-func (m *MyMockedObject) DoSomething(number int) (bool, error) {
-
- args := m.Called(number)
- return args.Bool(0), args.Error(1)
-
-}
-
-/*
- Actual test functions
-*/
-
-// TestSomething is an example of how to use our test object to
-// make assertions about some target code we are testing.
-func TestSomething(t *testing.T) {
-
- // create an instance of our test object
- testObj := new(MyMockedObject)
-
- // setup expectations
- testObj.On("DoSomething", 123).Return(true, nil)
-
- // call the code we are testing
- targetFuncThatDoesSomethingWithObj(testObj)
-
- // assert that the expectations were met
- testObj.AssertExpectations(t)
-
-
-}
-
-// TestSomethingWithPlaceholder is a second example of how to use our test object to
-// make assertions about some target code we are testing.
-// This time using a placeholder. Placeholders might be used when the
-// data being passed in is normally dynamically generated and cannot be
-// predicted beforehand (eg. containing hashes that are time sensitive)
-func TestSomethingWithPlaceholder(t *testing.T) {
-
- // create an instance of our test object
- testObj := new(MyMockedObject)
-
- // setup expectations with a placeholder in the argument list
- testObj.On("DoSomething", mock.Anything).Return(true, nil)
-
- // call the code we are testing
- targetFuncThatDoesSomethingWithObj(testObj)
-
- // assert that the expectations were met
- testObj.AssertExpectations(t)
-
-
-}
-
-// TestSomethingElse2 is a third example that shows how you can use
-// the Unset method to cleanup handlers and then add new ones.
-func TestSomethingElse2(t *testing.T) {
-
- // create an instance of our test object
- testObj := new(MyMockedObject)
-
- // setup expectations with a placeholder in the argument list
- mockCall := testObj.On("DoSomething", mock.Anything).Return(true, nil)
-
- // call the code we are testing
- targetFuncThatDoesSomethingWithObj(testObj)
-
- // assert that the expectations were met
- testObj.AssertExpectations(t)
-
- // remove the handler now so we can add another one that takes precedence
- mockCall.Unset()
-
- // return false now instead of true
- testObj.On("DoSomething", mock.Anything).Return(false, nil)
-
- testObj.AssertExpectations(t)
-}
-```
-
-For more information on how to write mock code, check out the [API documentation for the `mock` package](http://godoc.org/github.com/stretchr/testify/mock).
-
-You can use the [mockery tool](http://github.com/vektra/mockery) to autogenerate the mock code against an interface as well, making using mocks much quicker.
-
-[`suite`](http://godoc.org/github.com/stretchr/testify/suite "API documentation") package
------------------------------------------------------------------------------------------
-
-The `suite` package provides functionality that you might be used to from more common object oriented languages. With it, you can build a testing suite as a struct, build setup/teardown methods and testing methods on your struct, and run them with 'go test' as per normal.
-
-An example suite is shown below:
-
-```go
-// Basic imports
-import (
- "testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/suite"
-)
-
-// Define the suite, and absorb the built-in basic suite
-// functionality from testify - including a T() method which
-// returns the current testing context
-type ExampleTestSuite struct {
- suite.Suite
- VariableThatShouldStartAtFive int
-}
-
-// Make sure that VariableThatShouldStartAtFive is set to five
-// before each test
-func (suite *ExampleTestSuite) SetupTest() {
- suite.VariableThatShouldStartAtFive = 5
-}
-
-// All methods that begin with "Test" are run as tests within a
-// suite.
-func (suite *ExampleTestSuite) TestExample() {
- assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
-}
-
-// In order for 'go test' to run this suite, we need to create
-// a normal test function and pass our suite to suite.Run
-func TestExampleTestSuite(t *testing.T) {
- suite.Run(t, new(ExampleTestSuite))
-}
-```
-
-For a more complete example, using all of the functionality provided by the suite package, look at our [example testing suite](https://github.com/stretchr/testify/blob/master/suite/suite_test.go)
-
-For more information on writing suites, check out the [API documentation for the `suite` package](http://godoc.org/github.com/stretchr/testify/suite).
-
-`Suite` object has assertion methods:
-
-```go
-// Basic imports
-import (
- "testing"
- "github.com/stretchr/testify/suite"
-)
-
-// Define the suite, and absorb the built-in basic suite
-// functionality from testify - including assertion methods.
-type ExampleTestSuite struct {
- suite.Suite
- VariableThatShouldStartAtFive int
-}
-
-// Make sure that VariableThatShouldStartAtFive is set to five
-// before each test
-func (suite *ExampleTestSuite) SetupTest() {
- suite.VariableThatShouldStartAtFive = 5
-}
-
-// All methods that begin with "Test" are run as tests within a
-// suite.
-func (suite *ExampleTestSuite) TestExample() {
- suite.Equal(suite.VariableThatShouldStartAtFive, 5)
-}
-
-// In order for 'go test' to run this suite, we need to create
-// a normal test function and pass our suite to suite.Run
-func TestExampleTestSuite(t *testing.T) {
- suite.Run(t, new(ExampleTestSuite))
-}
-```
-
-------
-
-Installation
-============
-
-To install Testify, use `go get`:
-
- go get github.com/stretchr/testify
-
-This will then make the following packages available to you:
-
- github.com/stretchr/testify/assert
- github.com/stretchr/testify/require
- github.com/stretchr/testify/mock
- github.com/stretchr/testify/suite
- github.com/stretchr/testify/http (deprecated)
-
-Import the `testify/assert` package into your code using this template:
-
-```go
-package yours
-
-import (
- "testing"
- "github.com/stretchr/testify/assert"
-)
-
-func TestSomething(t *testing.T) {
-
- assert.True(t, true, "True is true!")
-
-}
-```
-
-------
-
-Staying up to date
-==================
-
-To update Testify to the latest version, use `go get -u github.com/stretchr/testify`.
-
-------
-
-Supported go versions
-==================
-
-We currently support the most recent major Go versions from 1.13 onward.
-
-------
-
-Contributing
-============
-
-Please feel free to submit issues, fork the repository and send pull requests!
-
-When submitting an issue, we ask that you please include a complete test function that demonstrates the issue. Extra credit for those using Testify to write the test code that demonstrates it.
-
-Code generation is used. Look for `CODE GENERATED AUTOMATICALLY` at the top of some files. Run `go generate ./...` to update generated files.
-
-We also chat on the [Gophers Slack](https://gophers.slack.com) group in the `#testify` and `#testify-dev` channels.
-
-------
-
-License
-=======
-
-This project is licensed under the terms of the MIT license.
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare.go
deleted file mode 100644
index 95d8e59da69bf8e207db7af447a2f792db6f5625..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare.go
+++ /dev/null
@@ -1,458 +0,0 @@
-package assert
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "time"
-)
-
-type CompareType int
-
-const (
- compareLess CompareType = iota - 1
- compareEqual
- compareGreater
-)
-
-var (
- intType = reflect.TypeOf(int(1))
- int8Type = reflect.TypeOf(int8(1))
- int16Type = reflect.TypeOf(int16(1))
- int32Type = reflect.TypeOf(int32(1))
- int64Type = reflect.TypeOf(int64(1))
-
- uintType = reflect.TypeOf(uint(1))
- uint8Type = reflect.TypeOf(uint8(1))
- uint16Type = reflect.TypeOf(uint16(1))
- uint32Type = reflect.TypeOf(uint32(1))
- uint64Type = reflect.TypeOf(uint64(1))
-
- float32Type = reflect.TypeOf(float32(1))
- float64Type = reflect.TypeOf(float64(1))
-
- stringType = reflect.TypeOf("")
-
- timeType = reflect.TypeOf(time.Time{})
- bytesType = reflect.TypeOf([]byte{})
-)
-
-func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
- obj1Value := reflect.ValueOf(obj1)
- obj2Value := reflect.ValueOf(obj2)
-
- // throughout this switch we try and avoid calling .Convert() if possible,
- // as this has a pretty big performance impact
- switch kind {
- case reflect.Int:
- {
- intobj1, ok := obj1.(int)
- if !ok {
- intobj1 = obj1Value.Convert(intType).Interface().(int)
- }
- intobj2, ok := obj2.(int)
- if !ok {
- intobj2 = obj2Value.Convert(intType).Interface().(int)
- }
- if intobj1 > intobj2 {
- return compareGreater, true
- }
- if intobj1 == intobj2 {
- return compareEqual, true
- }
- if intobj1 < intobj2 {
- return compareLess, true
- }
- }
- case reflect.Int8:
- {
- int8obj1, ok := obj1.(int8)
- if !ok {
- int8obj1 = obj1Value.Convert(int8Type).Interface().(int8)
- }
- int8obj2, ok := obj2.(int8)
- if !ok {
- int8obj2 = obj2Value.Convert(int8Type).Interface().(int8)
- }
- if int8obj1 > int8obj2 {
- return compareGreater, true
- }
- if int8obj1 == int8obj2 {
- return compareEqual, true
- }
- if int8obj1 < int8obj2 {
- return compareLess, true
- }
- }
- case reflect.Int16:
- {
- int16obj1, ok := obj1.(int16)
- if !ok {
- int16obj1 = obj1Value.Convert(int16Type).Interface().(int16)
- }
- int16obj2, ok := obj2.(int16)
- if !ok {
- int16obj2 = obj2Value.Convert(int16Type).Interface().(int16)
- }
- if int16obj1 > int16obj2 {
- return compareGreater, true
- }
- if int16obj1 == int16obj2 {
- return compareEqual, true
- }
- if int16obj1 < int16obj2 {
- return compareLess, true
- }
- }
- case reflect.Int32:
- {
- int32obj1, ok := obj1.(int32)
- if !ok {
- int32obj1 = obj1Value.Convert(int32Type).Interface().(int32)
- }
- int32obj2, ok := obj2.(int32)
- if !ok {
- int32obj2 = obj2Value.Convert(int32Type).Interface().(int32)
- }
- if int32obj1 > int32obj2 {
- return compareGreater, true
- }
- if int32obj1 == int32obj2 {
- return compareEqual, true
- }
- if int32obj1 < int32obj2 {
- return compareLess, true
- }
- }
- case reflect.Int64:
- {
- int64obj1, ok := obj1.(int64)
- if !ok {
- int64obj1 = obj1Value.Convert(int64Type).Interface().(int64)
- }
- int64obj2, ok := obj2.(int64)
- if !ok {
- int64obj2 = obj2Value.Convert(int64Type).Interface().(int64)
- }
- if int64obj1 > int64obj2 {
- return compareGreater, true
- }
- if int64obj1 == int64obj2 {
- return compareEqual, true
- }
- if int64obj1 < int64obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint:
- {
- uintobj1, ok := obj1.(uint)
- if !ok {
- uintobj1 = obj1Value.Convert(uintType).Interface().(uint)
- }
- uintobj2, ok := obj2.(uint)
- if !ok {
- uintobj2 = obj2Value.Convert(uintType).Interface().(uint)
- }
- if uintobj1 > uintobj2 {
- return compareGreater, true
- }
- if uintobj1 == uintobj2 {
- return compareEqual, true
- }
- if uintobj1 < uintobj2 {
- return compareLess, true
- }
- }
- case reflect.Uint8:
- {
- uint8obj1, ok := obj1.(uint8)
- if !ok {
- uint8obj1 = obj1Value.Convert(uint8Type).Interface().(uint8)
- }
- uint8obj2, ok := obj2.(uint8)
- if !ok {
- uint8obj2 = obj2Value.Convert(uint8Type).Interface().(uint8)
- }
- if uint8obj1 > uint8obj2 {
- return compareGreater, true
- }
- if uint8obj1 == uint8obj2 {
- return compareEqual, true
- }
- if uint8obj1 < uint8obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint16:
- {
- uint16obj1, ok := obj1.(uint16)
- if !ok {
- uint16obj1 = obj1Value.Convert(uint16Type).Interface().(uint16)
- }
- uint16obj2, ok := obj2.(uint16)
- if !ok {
- uint16obj2 = obj2Value.Convert(uint16Type).Interface().(uint16)
- }
- if uint16obj1 > uint16obj2 {
- return compareGreater, true
- }
- if uint16obj1 == uint16obj2 {
- return compareEqual, true
- }
- if uint16obj1 < uint16obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint32:
- {
- uint32obj1, ok := obj1.(uint32)
- if !ok {
- uint32obj1 = obj1Value.Convert(uint32Type).Interface().(uint32)
- }
- uint32obj2, ok := obj2.(uint32)
- if !ok {
- uint32obj2 = obj2Value.Convert(uint32Type).Interface().(uint32)
- }
- if uint32obj1 > uint32obj2 {
- return compareGreater, true
- }
- if uint32obj1 == uint32obj2 {
- return compareEqual, true
- }
- if uint32obj1 < uint32obj2 {
- return compareLess, true
- }
- }
- case reflect.Uint64:
- {
- uint64obj1, ok := obj1.(uint64)
- if !ok {
- uint64obj1 = obj1Value.Convert(uint64Type).Interface().(uint64)
- }
- uint64obj2, ok := obj2.(uint64)
- if !ok {
- uint64obj2 = obj2Value.Convert(uint64Type).Interface().(uint64)
- }
- if uint64obj1 > uint64obj2 {
- return compareGreater, true
- }
- if uint64obj1 == uint64obj2 {
- return compareEqual, true
- }
- if uint64obj1 < uint64obj2 {
- return compareLess, true
- }
- }
- case reflect.Float32:
- {
- float32obj1, ok := obj1.(float32)
- if !ok {
- float32obj1 = obj1Value.Convert(float32Type).Interface().(float32)
- }
- float32obj2, ok := obj2.(float32)
- if !ok {
- float32obj2 = obj2Value.Convert(float32Type).Interface().(float32)
- }
- if float32obj1 > float32obj2 {
- return compareGreater, true
- }
- if float32obj1 == float32obj2 {
- return compareEqual, true
- }
- if float32obj1 < float32obj2 {
- return compareLess, true
- }
- }
- case reflect.Float64:
- {
- float64obj1, ok := obj1.(float64)
- if !ok {
- float64obj1 = obj1Value.Convert(float64Type).Interface().(float64)
- }
- float64obj2, ok := obj2.(float64)
- if !ok {
- float64obj2 = obj2Value.Convert(float64Type).Interface().(float64)
- }
- if float64obj1 > float64obj2 {
- return compareGreater, true
- }
- if float64obj1 == float64obj2 {
- return compareEqual, true
- }
- if float64obj1 < float64obj2 {
- return compareLess, true
- }
- }
- case reflect.String:
- {
- stringobj1, ok := obj1.(string)
- if !ok {
- stringobj1 = obj1Value.Convert(stringType).Interface().(string)
- }
- stringobj2, ok := obj2.(string)
- if !ok {
- stringobj2 = obj2Value.Convert(stringType).Interface().(string)
- }
- if stringobj1 > stringobj2 {
- return compareGreater, true
- }
- if stringobj1 == stringobj2 {
- return compareEqual, true
- }
- if stringobj1 < stringobj2 {
- return compareLess, true
- }
- }
- // Check for known struct types we can check for compare results.
- case reflect.Struct:
- {
- // All structs enter here. We're not interested in most types.
- if !canConvert(obj1Value, timeType) {
- break
- }
-
- // time.Time can compared!
- timeObj1, ok := obj1.(time.Time)
- if !ok {
- timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time)
- }
-
- timeObj2, ok := obj2.(time.Time)
- if !ok {
- timeObj2 = obj2Value.Convert(timeType).Interface().(time.Time)
- }
-
- return compare(timeObj1.UnixNano(), timeObj2.UnixNano(), reflect.Int64)
- }
- case reflect.Slice:
- {
- // We only care about the []byte type.
- if !canConvert(obj1Value, bytesType) {
- break
- }
-
- // []byte can be compared!
- bytesObj1, ok := obj1.([]byte)
- if !ok {
- bytesObj1 = obj1Value.Convert(bytesType).Interface().([]byte)
-
- }
- bytesObj2, ok := obj2.([]byte)
- if !ok {
- bytesObj2 = obj2Value.Convert(bytesType).Interface().([]byte)
- }
-
- return CompareType(bytes.Compare(bytesObj1, bytesObj2)), true
- }
- }
-
- return compareEqual, false
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
-func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
-func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []CompareType{compareGreater, compareEqual}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
-func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
-func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return compareTwoValues(t, e1, e2, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
-func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- zero := reflect.Zero(reflect.TypeOf(e))
- return compareTwoValues(t, e, zero.Interface(), []CompareType{compareGreater}, "\"%v\" is not positive", msgAndArgs...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
-func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- zero := reflect.Zero(reflect.TypeOf(e))
- return compareTwoValues(t, e, zero.Interface(), []CompareType{compareLess}, "\"%v\" is not negative", msgAndArgs...)
-}
-
-func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []CompareType, failMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- e1Kind := reflect.ValueOf(e1).Kind()
- e2Kind := reflect.ValueOf(e2).Kind()
- if e1Kind != e2Kind {
- return Fail(t, "Elements should be the same type", msgAndArgs...)
- }
-
- compareResult, isComparable := compare(e1, e2, e1Kind)
- if !isComparable {
- return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)
- }
-
- if !containsValue(allowedComparesResults, compareResult) {
- return Fail(t, fmt.Sprintf(failMessage, e1, e2), msgAndArgs...)
- }
-
- return true
-}
-
-func containsValue(values []CompareType, value CompareType) bool {
- for _, v := range values {
- if v == value {
- return true
- }
- }
-
- return false
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_can_convert.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_can_convert.go
deleted file mode 100644
index da867903e2fa8796c0d0b58adaee3465c0b2eb0f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_can_convert.go
+++ /dev/null
@@ -1,16 +0,0 @@
-//go:build go1.17
-// +build go1.17
-
-// TODO: once support for Go 1.16 is dropped, this file can be
-// merged/removed with assertion_compare_go1.17_test.go and
-// assertion_compare_legacy.go
-
-package assert
-
-import "reflect"
-
-// Wrapper around reflect.Value.CanConvert, for compatibility
-// reasons.
-func canConvert(value reflect.Value, to reflect.Type) bool {
- return value.CanConvert(to)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_go1.17_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_go1.17_test.go
deleted file mode 100644
index 53e01ed467839ffedb7a8bfe39cc7d211301ee06..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_go1.17_test.go
+++ /dev/null
@@ -1,182 +0,0 @@
-//go:build go1.17
-// +build go1.17
-
-// TODO: once support for Go 1.16 is dropped, this file can be
-// merged/removed with assertion_compare_can_convert.go and
-// assertion_compare_legacy.go
-
-package assert
-
-import (
- "bytes"
- "reflect"
- "testing"
- "time"
-)
-
-func TestCompare17(t *testing.T) {
- type customTime time.Time
- type customBytes []byte
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- cType string
- }{
- {less: time.Now(), greater: time.Now().Add(time.Hour), cType: "time.Time"},
- {less: customTime(time.Now()), greater: customTime(time.Now().Add(time.Hour)), cType: "time.Time"},
- {less: []byte{1, 1}, greater: []byte{1, 2}, cType: "[]byte"},
- {less: customBytes([]byte{1, 1}), greater: customBytes([]byte{1, 2}), cType: "[]byte"},
- } {
- resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object should be comparable for type " + currCase.cType)
- }
-
- if resLess != compareLess {
- t.Errorf("object less (%v) should be less than greater (%v) for type "+currCase.cType,
- currCase.less, currCase.greater)
- }
-
- resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resGreater != compareGreater {
- t.Errorf("object greater should be greater than less for type " + currCase.cType)
- }
-
- resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resEqual != 0 {
- t.Errorf("objects should be equal for type " + currCase.cType)
- }
- }
-}
-
-func TestGreater17(t *testing.T) {
- mockT := new(testing.T)
-
- if !Greater(mockT, 2, 1) {
- t.Error("Greater should return true")
- }
-
- if Greater(mockT, 1, 1) {
- t.Error("Greater should return false")
- }
-
- if Greater(mockT, 1, 2) {
- t.Error("Greater should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than "[1 2]"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than "0001-01-01 01:00:00 +0000 UTC"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Greater(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Greater")
- }
-}
-
-func TestGreaterOrEqual17(t *testing.T) {
- mockT := new(testing.T)
-
- if !GreaterOrEqual(mockT, 2, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if !GreaterOrEqual(mockT, 1, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if GreaterOrEqual(mockT, 1, 2) {
- t.Error("GreaterOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 1]" is not greater than or equal to "[1 2]"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 00:00:00 +0000 UTC" is not greater than or equal to "0001-01-01 01:00:00 +0000 UTC"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, GreaterOrEqual(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.GreaterOrEqual")
- }
-}
-
-func TestLess17(t *testing.T) {
- mockT := new(testing.T)
-
- if !Less(mockT, 1, 2) {
- t.Error("Less should return true")
- }
-
- if Less(mockT, 1, 1) {
- t.Error("Less should return false")
- }
-
- if Less(mockT, 2, 1) {
- t.Error("Less should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than "[1 1]"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than "0001-01-01 00:00:00 +0000 UTC"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Less(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Less")
- }
-}
-
-func TestLessOrEqual17(t *testing.T) {
- mockT := new(testing.T)
-
- if !LessOrEqual(mockT, 1, 2) {
- t.Error("LessOrEqual should return true")
- }
-
- if !LessOrEqual(mockT, 1, 1) {
- t.Error("LessOrEqual should return true")
- }
-
- if LessOrEqual(mockT, 2, 1) {
- t.Error("LessOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: []byte{1, 1}, greater: []byte{1, 2}, msg: `"[1 2]" is not less than or equal to "[1 1]"`},
- {less: time.Time{}, greater: time.Time{}.Add(time.Hour), msg: `"0001-01-01 01:00:00 +0000 UTC" is not less than or equal to "0001-01-01 00:00:00 +0000 UTC"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, LessOrEqual(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.LessOrEqual")
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_legacy.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_legacy.go
deleted file mode 100644
index 1701af2a3c89c238c4e2af7d48af2abac0bf4f87..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_legacy.go
+++ /dev/null
@@ -1,16 +0,0 @@
-//go:build !go1.17
-// +build !go1.17
-
-// TODO: once support for Go 1.16 is dropped, this file can be
-// merged/removed with assertion_compare_go1.17_test.go and
-// assertion_compare_can_convert.go
-
-package assert
-
-import "reflect"
-
-// Older versions of Go does not have the reflect.Value.CanConvert
-// method.
-func canConvert(value reflect.Value, to reflect.Type) bool {
- return false
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_test.go
deleted file mode 100644
index a38d88060b51b62d43b9310748dea6003b620f66..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_compare_test.go
+++ /dev/null
@@ -1,449 +0,0 @@
-package assert
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "runtime"
- "testing"
-)
-
-func TestCompare(t *testing.T) {
- type customInt int
- type customInt8 int8
- type customInt16 int16
- type customInt32 int32
- type customInt64 int64
- type customUInt uint
- type customUInt8 uint8
- type customUInt16 uint16
- type customUInt32 uint32
- type customUInt64 uint64
- type customFloat32 float32
- type customFloat64 float64
- type customString string
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- cType string
- }{
- {less: customString("a"), greater: customString("b"), cType: "string"},
- {less: "a", greater: "b", cType: "string"},
- {less: customInt(1), greater: customInt(2), cType: "int"},
- {less: int(1), greater: int(2), cType: "int"},
- {less: customInt8(1), greater: customInt8(2), cType: "int8"},
- {less: int8(1), greater: int8(2), cType: "int8"},
- {less: customInt16(1), greater: customInt16(2), cType: "int16"},
- {less: int16(1), greater: int16(2), cType: "int16"},
- {less: customInt32(1), greater: customInt32(2), cType: "int32"},
- {less: int32(1), greater: int32(2), cType: "int32"},
- {less: customInt64(1), greater: customInt64(2), cType: "int64"},
- {less: int64(1), greater: int64(2), cType: "int64"},
- {less: customUInt(1), greater: customUInt(2), cType: "uint"},
- {less: uint8(1), greater: uint8(2), cType: "uint8"},
- {less: customUInt8(1), greater: customUInt8(2), cType: "uint8"},
- {less: uint16(1), greater: uint16(2), cType: "uint16"},
- {less: customUInt16(1), greater: customUInt16(2), cType: "uint16"},
- {less: uint32(1), greater: uint32(2), cType: "uint32"},
- {less: customUInt32(1), greater: customUInt32(2), cType: "uint32"},
- {less: uint64(1), greater: uint64(2), cType: "uint64"},
- {less: customUInt64(1), greater: customUInt64(2), cType: "uint64"},
- {less: float32(1.23), greater: float32(2.34), cType: "float32"},
- {less: customFloat32(1.23), greater: customFloat32(2.23), cType: "float32"},
- {less: float64(1.23), greater: float64(2.34), cType: "float64"},
- {less: customFloat64(1.23), greater: customFloat64(2.34), cType: "float64"},
- } {
- resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object should be comparable for type " + currCase.cType)
- }
-
- if resLess != compareLess {
- t.Errorf("object less (%v) should be less than greater (%v) for type "+currCase.cType,
- currCase.less, currCase.greater)
- }
-
- resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resGreater != compareGreater {
- t.Errorf("object greater should be greater than less for type " + currCase.cType)
- }
-
- resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind())
- if !isComparable {
- t.Error("object are comparable for type " + currCase.cType)
- }
-
- if resEqual != 0 {
- t.Errorf("objects should be equal for type " + currCase.cType)
- }
- }
-}
-
-type outputT struct {
- buf *bytes.Buffer
- helpers map[string]struct{}
-}
-
-// Implements TestingT
-func (t *outputT) Errorf(format string, args ...interface{}) {
- s := fmt.Sprintf(format, args...)
- t.buf.WriteString(s)
-}
-
-func (t *outputT) Helper() {
- if t.helpers == nil {
- t.helpers = make(map[string]struct{})
- }
- t.helpers[callerName(1)] = struct{}{}
-}
-
-// callerName gives the function name (qualified with a package path)
-// for the caller after skip frames (where 0 means the current function).
-func callerName(skip int) string {
- // Make room for the skip PC.
- var pc [1]uintptr
- n := runtime.Callers(skip+2, pc[:]) // skip + runtime.Callers + callerName
- if n == 0 {
- panic("testing: zero callers found")
- }
- frames := runtime.CallersFrames(pc[:n])
- frame, _ := frames.Next()
- return frame.Function
-}
-
-func TestGreater(t *testing.T) {
- mockT := new(testing.T)
-
- if !Greater(mockT, 2, 1) {
- t.Error("Greater should return true")
- }
-
- if Greater(mockT, 1, 1) {
- t.Error("Greater should return false")
- }
-
- if Greater(mockT, 1, 2) {
- t.Error("Greater should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"a" is not greater than "b"`},
- {less: int(1), greater: int(2), msg: `"1" is not greater than "2"`},
- {less: int8(1), greater: int8(2), msg: `"1" is not greater than "2"`},
- {less: int16(1), greater: int16(2), msg: `"1" is not greater than "2"`},
- {less: int32(1), greater: int32(2), msg: `"1" is not greater than "2"`},
- {less: int64(1), greater: int64(2), msg: `"1" is not greater than "2"`},
- {less: uint8(1), greater: uint8(2), msg: `"1" is not greater than "2"`},
- {less: uint16(1), greater: uint16(2), msg: `"1" is not greater than "2"`},
- {less: uint32(1), greater: uint32(2), msg: `"1" is not greater than "2"`},
- {less: uint64(1), greater: uint64(2), msg: `"1" is not greater than "2"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than "2.34"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Greater(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Greater")
- }
-}
-
-func TestGreaterOrEqual(t *testing.T) {
- mockT := new(testing.T)
-
- if !GreaterOrEqual(mockT, 2, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if !GreaterOrEqual(mockT, 1, 1) {
- t.Error("GreaterOrEqual should return true")
- }
-
- if GreaterOrEqual(mockT, 1, 2) {
- t.Error("GreaterOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"a" is not greater than or equal to "b"`},
- {less: int(1), greater: int(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int8(1), greater: int8(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int16(1), greater: int16(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int32(1), greater: int32(2), msg: `"1" is not greater than or equal to "2"`},
- {less: int64(1), greater: int64(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint8(1), greater: uint8(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint16(1), greater: uint16(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint32(1), greater: uint32(2), msg: `"1" is not greater than or equal to "2"`},
- {less: uint64(1), greater: uint64(2), msg: `"1" is not greater than or equal to "2"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"1.23" is not greater than or equal to "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, GreaterOrEqual(out, currCase.less, currCase.greater))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.GreaterOrEqual")
- }
-}
-
-func TestLess(t *testing.T) {
- mockT := new(testing.T)
-
- if !Less(mockT, 1, 2) {
- t.Error("Less should return true")
- }
-
- if Less(mockT, 1, 1) {
- t.Error("Less should return false")
- }
-
- if Less(mockT, 2, 1) {
- t.Error("Less should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"b" is not less than "a"`},
- {less: int(1), greater: int(2), msg: `"2" is not less than "1"`},
- {less: int8(1), greater: int8(2), msg: `"2" is not less than "1"`},
- {less: int16(1), greater: int16(2), msg: `"2" is not less than "1"`},
- {less: int32(1), greater: int32(2), msg: `"2" is not less than "1"`},
- {less: int64(1), greater: int64(2), msg: `"2" is not less than "1"`},
- {less: uint8(1), greater: uint8(2), msg: `"2" is not less than "1"`},
- {less: uint16(1), greater: uint16(2), msg: `"2" is not less than "1"`},
- {less: uint32(1), greater: uint32(2), msg: `"2" is not less than "1"`},
- {less: uint64(1), greater: uint64(2), msg: `"2" is not less than "1"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than "1.23"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Less(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Less")
- }
-}
-
-func TestLessOrEqual(t *testing.T) {
- mockT := new(testing.T)
-
- if !LessOrEqual(mockT, 1, 2) {
- t.Error("LessOrEqual should return true")
- }
-
- if !LessOrEqual(mockT, 1, 1) {
- t.Error("LessOrEqual should return true")
- }
-
- if LessOrEqual(mockT, 2, 1) {
- t.Error("LessOrEqual should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- less interface{}
- greater interface{}
- msg string
- }{
- {less: "a", greater: "b", msg: `"b" is not less than or equal to "a"`},
- {less: int(1), greater: int(2), msg: `"2" is not less than or equal to "1"`},
- {less: int8(1), greater: int8(2), msg: `"2" is not less than or equal to "1"`},
- {less: int16(1), greater: int16(2), msg: `"2" is not less than or equal to "1"`},
- {less: int32(1), greater: int32(2), msg: `"2" is not less than or equal to "1"`},
- {less: int64(1), greater: int64(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint8(1), greater: uint8(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint16(1), greater: uint16(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint32(1), greater: uint32(2), msg: `"2" is not less than or equal to "1"`},
- {less: uint64(1), greater: uint64(2), msg: `"2" is not less than or equal to "1"`},
- {less: float32(1.23), greater: float32(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
- {less: float64(1.23), greater: float64(2.34), msg: `"2.34" is not less than or equal to "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, LessOrEqual(out, currCase.greater, currCase.less))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.LessOrEqual")
- }
-}
-
-func TestPositive(t *testing.T) {
- mockT := new(testing.T)
-
- if !Positive(mockT, 1) {
- t.Error("Positive should return true")
- }
-
- if !Positive(mockT, 1.23) {
- t.Error("Positive should return true")
- }
-
- if Positive(mockT, -1) {
- t.Error("Positive should return false")
- }
-
- if Positive(mockT, -1.23) {
- t.Error("Positive should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- e interface{}
- msg string
- }{
- {e: int(-1), msg: `"-1" is not positive`},
- {e: int8(-1), msg: `"-1" is not positive`},
- {e: int16(-1), msg: `"-1" is not positive`},
- {e: int32(-1), msg: `"-1" is not positive`},
- {e: int64(-1), msg: `"-1" is not positive`},
- {e: float32(-1.23), msg: `"-1.23" is not positive`},
- {e: float64(-1.23), msg: `"-1.23" is not positive`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Positive(out, currCase.e))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Positive")
- }
-}
-
-func TestNegative(t *testing.T) {
- mockT := new(testing.T)
-
- if !Negative(mockT, -1) {
- t.Error("Negative should return true")
- }
-
- if !Negative(mockT, -1.23) {
- t.Error("Negative should return true")
- }
-
- if Negative(mockT, 1) {
- t.Error("Negative should return false")
- }
-
- if Negative(mockT, 1.23) {
- t.Error("Negative should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- e interface{}
- msg string
- }{
- {e: int(1), msg: `"1" is not negative`},
- {e: int8(1), msg: `"1" is not negative`},
- {e: int16(1), msg: `"1" is not negative`},
- {e: int32(1), msg: `"1" is not negative`},
- {e: int64(1), msg: `"1" is not negative`},
- {e: float32(1.23), msg: `"1.23" is not negative`},
- {e: float64(1.23), msg: `"1.23" is not negative`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, Negative(out, currCase.e))
- Contains(t, out.buf.String(), currCase.msg)
- Contains(t, out.helpers, "github.com/stretchr/testify/assert.Negative")
- }
-}
-
-func Test_compareTwoValuesDifferentValuesTypes(t *testing.T) {
- mockT := new(testing.T)
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- compareResult bool
- }{
- {v1: 123, v2: "abc"},
- {v1: "abc", v2: 123456},
- {v1: float64(12), v2: "123"},
- {v1: "float(12)", v2: float64(1)},
- } {
- compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, []CompareType{compareLess, compareEqual, compareGreater}, "testFailMessage")
- False(t, compareResult)
- }
-}
-
-func Test_compareTwoValuesNotComparableValues(t *testing.T) {
- mockT := new(testing.T)
-
- type CompareStruct struct {
- }
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- }{
- {v1: CompareStruct{}, v2: CompareStruct{}},
- {v1: map[string]int{}, v2: map[string]int{}},
- {v1: make([]int, 5), v2: make([]int, 5)},
- } {
- compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, []CompareType{compareLess, compareEqual, compareGreater}, "testFailMessage")
- False(t, compareResult)
- }
-}
-
-func Test_compareTwoValuesCorrectCompareResult(t *testing.T) {
- mockT := new(testing.T)
-
- for _, currCase := range []struct {
- v1 interface{}
- v2 interface{}
- compareTypes []CompareType
- }{
- {v1: 1, v2: 2, compareTypes: []CompareType{compareLess}},
- {v1: 1, v2: 2, compareTypes: []CompareType{compareLess, compareEqual}},
- {v1: 2, v2: 2, compareTypes: []CompareType{compareGreater, compareEqual}},
- {v1: 2, v2: 2, compareTypes: []CompareType{compareEqual}},
- {v1: 2, v2: 1, compareTypes: []CompareType{compareEqual, compareGreater}},
- {v1: 2, v2: 1, compareTypes: []CompareType{compareGreater}},
- } {
- compareResult := compareTwoValues(mockT, currCase.v1, currCase.v2, currCase.compareTypes, "testFailMessage")
- True(t, compareResult)
- }
-}
-
-func Test_containsValue(t *testing.T) {
- for _, currCase := range []struct {
- values []CompareType
- value CompareType
- result bool
- }{
- {values: []CompareType{compareGreater}, value: compareGreater, result: true},
- {values: []CompareType{compareGreater, compareLess}, value: compareGreater, result: true},
- {values: []CompareType{compareGreater, compareLess}, value: compareLess, result: true},
- {values: []CompareType{compareGreater, compareLess}, value: compareEqual, result: false},
- } {
- compareResult := containsValue(currCase.values, currCase.value)
- Equal(t, currCase.result, compareResult)
- }
-}
-
-func TestComparingMsgAndArgsForwarding(t *testing.T) {
- msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
- expectedOutput := "format this c001\n"
- funcs := []func(t TestingT){
- func(t TestingT) { Greater(t, 1, 2, msgAndArgs...) },
- func(t TestingT) { GreaterOrEqual(t, 1, 2, msgAndArgs...) },
- func(t TestingT) { Less(t, 2, 1, msgAndArgs...) },
- func(t TestingT) { LessOrEqual(t, 2, 1, msgAndArgs...) },
- func(t TestingT) { Positive(t, 0, msgAndArgs...) },
- func(t TestingT) { Negative(t, 0, msgAndArgs...) },
- }
- for _, f := range funcs {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- f(out)
- Contains(t, out.buf.String(), expectedOutput)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go
deleted file mode 100644
index 7880b8f9433308d40a2703ab84f9c6e7f906f0d2..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go
+++ /dev/null
@@ -1,763 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package assert
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Conditionf uses a Comparison to assert a complex condition.
-func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Condition(t, comp, append([]interface{}{msg}, args...)...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
-func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Contains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return DirExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
-func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Empty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
-func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
-func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Error(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
-func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContains(t, theError, contains, append([]interface{}{msg}, args...)...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Eventually(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
-func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Failf reports a failure through
-func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// FailNowf fails test
-func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
-func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return False(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return FileExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
-func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Greater(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
-func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCode(t, handler, method, url, values, statuscode, append([]interface{}{msg}, args...)...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasing(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
-func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Len(t, object, length, append([]interface{}{msg}, args...)...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
-func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Less(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
-func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqual(t, e1, e2, append([]interface{}{msg}, args...)...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
-func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Negative(t, e, append([]interface{}{msg}, args...)...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Never(t, condition, waitFor, tick, append([]interface{}{msg}, args...)...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// assert.Nilf(t, err, "error message %s", "formatted")
-func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Nil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoError(t, err, append([]interface{}{msg}, args...)...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExists(t, path, append([]interface{}{msg}, args...)...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
-func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEmpty(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
-func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// assert.NotNilf(t, err, "error message %s", "formatted")
-func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotNil(t, object, append([]interface{}{msg}, args...)...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
-func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotPanics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
-func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return NotZero(t, i, append([]interface{}{msg}, args...)...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
-func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Panics(t, f, append([]interface{}{msg}, args...)...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithErrorf(t TestingT, errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithError(t, errString, f, append([]interface{}{msg}, args...)...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
-func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Positive(t, e, append([]interface{}{msg}, args...)...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
-func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Subset(t, list, subset, append([]interface{}{msg}, args...)...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// assert.Truef(t, myBool, "error message %s", "formatted")
-func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return True(t, value, append([]interface{}{msg}, args...)...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return WithinRange(t, actual, start, end, append([]interface{}{msg}, args...)...)
-}
-
-// YAMLEqf asserts that two YAML strings are equivalent.
-func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return YAMLEq(t, expected, actual, append([]interface{}{msg}, args...)...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Zero(t, i, append([]interface{}{msg}, args...)...)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go.tmpl b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go.tmpl
deleted file mode 100644
index d2bb0b81778858c364f4b3694c00cdd4c72b1c5b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_format.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentFormat}}
-func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool {
- if h, ok := t.(tHelper); ok { h.Helper() }
- return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}})
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go
deleted file mode 100644
index 339515b8bfb9a8f50fede5742574687af8bcb5f3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go
+++ /dev/null
@@ -1,1514 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package assert
-
-import (
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Condition(a.t, comp, msgAndArgs...)
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Conditionf(a.t, comp, msg, args...)
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Contains(a.t, s, contains, msgAndArgs...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
-func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Containsf(a.t, s, contains, msg, args...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return DirExists(a.t, path, msgAndArgs...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return DirExistsf(a.t, path, msg, args...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
-func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Empty(obj)
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Empty(a.t, object, msgAndArgs...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Emptyf(obj, "error message %s", "formatted")
-func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Emptyf(a.t, object, msg, args...)
-}
-
-// Equal asserts that two objects are equal.
-//
-// a.Equal(123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
-func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualErrorf(a.t, theError, errString, msg, args...)
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// a.EqualValues(uint32(123), int32(123))
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
-func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return EqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// a.Equalf(123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Equalf(a.t, expected, actual, msg, args...)
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Error(a.t, err, msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorAsf(a.t, err, target, msg, args...)
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
-func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContains(a.t, theError, contains, msgAndArgs...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
-func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorContainsf(a.t, theError, contains, msg, args...)
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return ErrorIsf(a.t, err, target, msg, args...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Errorf(a.t, err, msg, args...)
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// a.Exactly(int32(123), int64(123))
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
-func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Exactlyf(a.t, expected, actual, msg, args...)
-}
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNowf fails test
-func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FailNowf(a.t, failureMessage, msg, args...)
-}
-
-// Failf reports a failure through
-func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Failf(a.t, failureMessage, msg, args...)
-}
-
-// False asserts that the specified value is false.
-//
-// a.False(myBool)
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return False(a.t, value, msgAndArgs...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// a.Falsef(myBool, "error message %s", "formatted")
-func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Falsef(a.t, value, msg, args...)
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FileExists(a.t, path, msgAndArgs...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return FileExistsf(a.t, path, msg, args...)
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
-func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Greater(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
-func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return GreaterOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
-func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Greaterf(a.t, e1, e2, msg, args...)
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPError(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPErrorf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// a.Implements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Implementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InDeltaf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
-func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsDecreasingf(a.t, object, msg, args...)
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
-func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsIncreasingf(a.t, object, msg, args...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
-func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonDecreasingf(a.t, object, msg, args...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
-func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsNonIncreasingf(a.t, object, msg, args...)
-}
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return IsTypef(a.t, expectedType, object, msg, args...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return JSONEqf(a.t, expected, actual, msg, args...)
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// a.Len(mySlice, 3)
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Len(a.t, object, length, msgAndArgs...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
-func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Lenf(a.t, object, length, msg, args...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
-func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Less(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
-func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return LessOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
-func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Lessf(a.t, e1, e2, msg, args...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// a.Negative(-1)
-// a.Negative(-1.23)
-func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Negative(a.t, e, msgAndArgs...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
-func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Negativef(a.t, e, msg, args...)
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Never(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Neverf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Nil asserts that the specified object is nil.
-//
-// a.Nil(err)
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Nil(a.t, object, msgAndArgs...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// a.Nilf(err, "error message %s", "formatted")
-func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Nilf(a.t, object, msg, args...)
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExists(a.t, path, msgAndArgs...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoDirExistsf(a.t, path, msg, args...)
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoError(a.t, err, msgAndArgs...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoErrorf(a.t, err, msg, args...)
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExists(a.t, path, msgAndArgs...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NoFileExistsf(a.t, path, msg, args...)
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
-func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotContainsf(a.t, s, contains, msg, args...)
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEmpty(a.t, object, msgAndArgs...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEmptyf(a.t, object, msg, args...)
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// a.NotEqual(obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValues(obj1, obj2)
-func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
-func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotEqualf(a.t, expected, actual, msg, args...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotErrorIsf(a.t, err, target, msg, args...)
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// a.NotNil(err)
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotNil(a.t, object, msgAndArgs...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// a.NotNilf(err, "error message %s", "formatted")
-func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotNilf(a.t, object, msg, args...)
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanics(func(){ RemainCalm() })
-func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotPanics(a.t, f, msgAndArgs...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
-func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotPanicsf(a.t, f, msg, args...)
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotRegexpf(a.t, rx, str, msg, args...)
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// a.NotSame(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSame(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSamef(a.t, expected, actual, msg, args...)
-}
-
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
-func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSubset(a.t, list, subset, msgAndArgs...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotSubsetf(a.t, list, subset, msg, args...)
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotZero(a.t, i, msgAndArgs...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return NotZerof(a.t, i, msg, args...)
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panics(func(){ GoCrazy() })
-func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Panics(a.t, f, msgAndArgs...)
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithError(errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithError(a.t, errString, f, msgAndArgs...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithErrorf(errString string, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithErrorf(a.t, errString, f, msg, args...)
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValue(a.t, expected, f, msgAndArgs...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return PanicsWithValuef(a.t, expected, f, msg, args...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Panicsf(a.t, f, msg, args...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// a.Positive(1)
-// a.Positive(1.23)
-func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Positive(a.t, e, msgAndArgs...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
-func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Positivef(a.t, e, msg, args...)
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Regexpf(a.t, rx, str, msg, args...)
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// a.Same(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Same(a.t, expected, actual, msgAndArgs...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Samef(a.t, expected, actual, msg, args...)
-}
-
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
-func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Subset(a.t, list, subset, msgAndArgs...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Subsetf(a.t, list, subset, msg, args...)
-}
-
-// True asserts that the specified value is true.
-//
-// a.True(myBool)
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return True(a.t, value, msgAndArgs...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// a.Truef(myBool, "error message %s", "formatted")
-func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Truef(a.t, value, msg, args...)
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinDurationf(a.t, expected, actual, delta, msg, args...)
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinRange(a.t, actual, start, end, msgAndArgs...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return WithinRangef(a.t, actual, start, end, msg, args...)
-}
-
-// YAMLEq asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return YAMLEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// YAMLEqf asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return YAMLEqf(a.t, expected, actual, msg, args...)
-}
-
-// Zero asserts that i is the zero value for its type.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Zero(a.t, i, msgAndArgs...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- return Zerof(a.t, i, msg, args...)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go.tmpl b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go.tmpl
deleted file mode 100644
index 188bb9e174397295062da708cc9f5207e2331768..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_forward.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool {
- if h, ok := a.t.(tHelper); ok { h.Helper() }
- return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order.go
deleted file mode 100644
index 75944878358568654acef8e7d73cbe96cd146d05..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package assert
-
-import (
- "fmt"
- "reflect"
-)
-
-// isOrdered checks that collection contains orderable elements.
-func isOrdered(t TestingT, object interface{}, allowedComparesResults []CompareType, failMessage string, msgAndArgs ...interface{}) bool {
- objKind := reflect.TypeOf(object).Kind()
- if objKind != reflect.Slice && objKind != reflect.Array {
- return false
- }
-
- objValue := reflect.ValueOf(object)
- objLen := objValue.Len()
-
- if objLen <= 1 {
- return true
- }
-
- value := objValue.Index(0)
- valueInterface := value.Interface()
- firstValueKind := value.Kind()
-
- for i := 1; i < objLen; i++ {
- prevValue := value
- prevValueInterface := valueInterface
-
- value = objValue.Index(i)
- valueInterface = value.Interface()
-
- compareResult, isComparable := compare(prevValueInterface, valueInterface, firstValueKind)
-
- if !isComparable {
- return Fail(t, fmt.Sprintf("Can not compare type \"%s\" and \"%s\"", reflect.TypeOf(value), reflect.TypeOf(prevValue)), msgAndArgs...)
- }
-
- if !containsValue(allowedComparesResults, compareResult) {
- return Fail(t, fmt.Sprintf(failMessage, prevValue, value), msgAndArgs...)
- }
- }
-
- return true
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
-func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
-func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []CompareType{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
-func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
-func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- return isOrdered(t, object, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order_test.go
deleted file mode 100644
index eefe06127f81b3421f9aafc86f02ce8edb5fb30a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertion_order_test.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package assert
-
-import (
- "bytes"
- "testing"
-)
-
-func TestIsIncreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsIncreasing(mockT, []int{1, 2}) {
- t.Error("IsIncreasing should return true")
- }
-
- if !IsIncreasing(mockT, []int{1, 2, 3, 4, 5}) {
- t.Error("IsIncreasing should return true")
- }
-
- if IsIncreasing(mockT, []int{1, 1}) {
- t.Error("IsIncreasing should return false")
- }
-
- if IsIncreasing(mockT, []int{2, 1}) {
- t.Error("IsIncreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"b", "a"}, msg: `"b" is not less than "a"`},
- {collection: []int{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than "1"`},
- {collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int8{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int16{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int32{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []int64{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint8{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint16{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint32{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []uint64{2, 1}, msg: `"2" is not less than "1"`},
- {collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
- {collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsIncreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsNonIncreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsNonIncreasing(mockT, []int{2, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if !IsNonIncreasing(mockT, []int{5, 4, 4, 3, 2, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if !IsNonIncreasing(mockT, []int{1, 1}) {
- t.Error("IsNonIncreasing should return true")
- }
-
- if IsNonIncreasing(mockT, []int{1, 2}) {
- t.Error("IsNonIncreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"a", "b"}, msg: `"a" is not greater than or equal to "b"`},
- {collection: []int{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []int64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint8{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint16{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint32{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []uint64{1, 2}, msg: `"1" is not greater than or equal to "2"`},
- {collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
- {collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than or equal to "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsNonIncreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsDecreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsDecreasing(mockT, []int{2, 1}) {
- t.Error("IsDecreasing should return true")
- }
-
- if !IsDecreasing(mockT, []int{5, 4, 3, 2, 1}) {
- t.Error("IsDecreasing should return true")
- }
-
- if IsDecreasing(mockT, []int{1, 1}) {
- t.Error("IsDecreasing should return false")
- }
-
- if IsDecreasing(mockT, []int{1, 2}) {
- t.Error("IsDecreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"a", "b"}, msg: `"a" is not greater than "b"`},
- {collection: []int{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int{1, 2, 7, 6, 5, 4, 3}, msg: `"1" is not greater than "2"`},
- {collection: []int{5, 4, 3, 1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int8{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int16{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int32{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []int64{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint8{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint16{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint32{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []uint64{1, 2}, msg: `"1" is not greater than "2"`},
- {collection: []float32{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
- {collection: []float64{1.23, 2.34}, msg: `"1.23" is not greater than "2.34"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsDecreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestIsNonDecreasing(t *testing.T) {
- mockT := new(testing.T)
-
- if !IsNonDecreasing(mockT, []int{1, 2}) {
- t.Error("IsNonDecreasing should return true")
- }
-
- if !IsNonDecreasing(mockT, []int{1, 1, 2, 3, 4, 5}) {
- t.Error("IsNonDecreasing should return true")
- }
-
- if !IsNonDecreasing(mockT, []int{1, 1}) {
- t.Error("IsNonDecreasing should return false")
- }
-
- if IsNonDecreasing(mockT, []int{2, 1}) {
- t.Error("IsNonDecreasing should return false")
- }
-
- // Check error report
- for _, currCase := range []struct {
- collection interface{}
- msg string
- }{
- {collection: []string{"b", "a"}, msg: `"b" is not less than or equal to "a"`},
- {collection: []int{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int{2, 1, 3, 4, 5, 6, 7}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int{-1, 0, 2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int8{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int16{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int32{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []int64{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint8{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint16{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint32{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []uint64{2, 1}, msg: `"2" is not less than or equal to "1"`},
- {collection: []float32{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
- {collection: []float64{2.34, 1.23}, msg: `"2.34" is not less than or equal to "1.23"`},
- } {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- False(t, IsNonDecreasing(out, currCase.collection))
- Contains(t, out.buf.String(), currCase.msg)
- }
-}
-
-func TestOrderingMsgAndArgsForwarding(t *testing.T) {
- msgAndArgs := []interface{}{"format %s %x", "this", 0xc001}
- expectedOutput := "format this c001\n"
- collection := []int{1, 2, 1}
- funcs := []func(t TestingT){
- func(t TestingT) { IsIncreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsNonIncreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsDecreasing(t, collection, msgAndArgs...) },
- func(t TestingT) { IsNonDecreasing(t, collection, msgAndArgs...) },
- }
- for _, f := range funcs {
- out := &outputT{buf: bytes.NewBuffer(nil)}
- f(out)
- Contains(t, out.buf.String(), expectedOutput)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions.go
deleted file mode 100644
index 2924cf3a149234bdc0255ea3340457a56de7c76f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions.go
+++ /dev/null
@@ -1,1856 +0,0 @@
-package assert
-
-import (
- "bufio"
- "bytes"
- "encoding/json"
- "errors"
- "fmt"
- "math"
- "os"
- "reflect"
- "regexp"
- "runtime"
- "runtime/debug"
- "strings"
- "time"
- "unicode"
- "unicode/utf8"
-
- "github.com/davecgh/go-spew/spew"
- "github.com/pmezard/go-difflib/difflib"
- yaml "gopkg.in/yaml.v3"
-)
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
- Errorf(format string, args ...interface{})
-}
-
-// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful
-// for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool
-
-// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful
-// for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool
-
-// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful
-// for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool
-
-// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful
-// for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool
-
-// Comparison is a custom function that returns true on success and false on failure
-type Comparison func() (success bool)
-
-/*
- Helper functions
-*/
-
-// ObjectsAreEqual determines if two objects are considered equal.
-//
-// This function does no assertion of any kind.
-func ObjectsAreEqual(expected, actual interface{}) bool {
- if expected == nil || actual == nil {
- return expected == actual
- }
-
- exp, ok := expected.([]byte)
- if !ok {
- return reflect.DeepEqual(expected, actual)
- }
-
- act, ok := actual.([]byte)
- if !ok {
- return false
- }
- if exp == nil || act == nil {
- return exp == nil && act == nil
- }
- return bytes.Equal(exp, act)
-}
-
-// ObjectsAreEqualValues gets whether two objects are equal, or if their
-// values are equal.
-func ObjectsAreEqualValues(expected, actual interface{}) bool {
- if ObjectsAreEqual(expected, actual) {
- return true
- }
-
- actualType := reflect.TypeOf(actual)
- if actualType == nil {
- return false
- }
- expectedValue := reflect.ValueOf(expected)
- if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
- // Attempt comparison after type conversion
- return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
- }
-
- return false
-}
-
-/* CallerInfo is necessary because the assert functions use the testing object
-internally, causing it to print the file:line of the assert method, rather than where
-the problem actually occurred in calling code.*/
-
-// CallerInfo returns an array of strings containing the file and line number
-// of each stack frame leading from the current test to the assert call that
-// failed.
-func CallerInfo() []string {
-
- var pc uintptr
- var ok bool
- var file string
- var line int
- var name string
-
- callers := []string{}
- for i := 0; ; i++ {
- pc, file, line, ok = runtime.Caller(i)
- if !ok {
- // The breaks below failed to terminate the loop, and we ran off the
- // end of the call stack.
- break
- }
-
- // This is a huge edge case, but it will panic if this is the case, see #180
- if file == "<autogenerated>" {
- break
- }
-
- f := runtime.FuncForPC(pc)
- if f == nil {
- break
- }
- name = f.Name()
-
- // testing.tRunner is the standard library function that calls
- // tests. Subtests are called directly by tRunner, without going through
- // the Test/Benchmark/Example function that contains the t.Run calls, so
- // with subtests we should break when we hit tRunner, without adding it
- // to the list of callers.
- if name == "testing.tRunner" {
- break
- }
-
- parts := strings.Split(file, "/")
- if len(parts) > 1 {
- filename := parts[len(parts)-1]
- dir := parts[len(parts)-2]
- if (dir != "assert" && dir != "mock" && dir != "require") || filename == "mock_test.go" {
- callers = append(callers, fmt.Sprintf("%s:%d", file, line))
- }
- }
-
- // Drop the package
- segments := strings.Split(name, ".")
- name = segments[len(segments)-1]
- if isTest(name, "Test") ||
- isTest(name, "Benchmark") ||
- isTest(name, "Example") {
- break
- }
- }
-
- return callers
-}
-
-// Stolen from the `go test` tool.
-// isTest tells whether name looks like a test (or benchmark, according to prefix).
-// It is a Test (say) if there is a character after Test that is not a lower-case letter.
-// We don't want TesticularCancer.
-func isTest(name, prefix string) bool {
- if !strings.HasPrefix(name, prefix) {
- return false
- }
- if len(name) == len(prefix) { // "Test" is ok
- return true
- }
- r, _ := utf8.DecodeRuneInString(name[len(prefix):])
- return !unicode.IsLower(r)
-}
-
-func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
- if len(msgAndArgs) == 0 || msgAndArgs == nil {
- return ""
- }
- if len(msgAndArgs) == 1 {
- msg := msgAndArgs[0]
- if msgAsStr, ok := msg.(string); ok {
- return msgAsStr
- }
- return fmt.Sprintf("%+v", msg)
- }
- if len(msgAndArgs) > 1 {
- return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
- }
- return ""
-}
-
-// Aligns the provided message so that all lines after the first line start at the same location as the first line.
-// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).
-// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the
-// basis on which the alignment occurs).
-func indentMessageLines(message string, longestLabelLen int) string {
- outBuf := new(bytes.Buffer)
-
- for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
- // no need to align first line because it starts at the correct location (after the label)
- if i != 0 {
- // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab
- outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t")
- }
- outBuf.WriteString(scanner.Text())
- }
-
- return outBuf.String()
-}
-
-type failNower interface {
- FailNow()
-}
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, failureMessage, msgAndArgs...)
-
- // We cannot extend TestingT with FailNow() and
- // maintain backwards compatibility, so we fallback
- // to panicking when FailNow is not available in
- // TestingT.
- // See issue #263
-
- if t, ok := t.(failNower); ok {
- t.FailNow()
- } else {
- panic("test failed and t is missing `FailNow()`")
- }
- return false
-}
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- content := []labeledContent{
- {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")},
- {"Error", failureMessage},
- }
-
- // Add test name if the Go version supports it
- if n, ok := t.(interface {
- Name() string
- }); ok {
- content = append(content, labeledContent{"Test", n.Name()})
- }
-
- message := messageFromMsgAndArgs(msgAndArgs...)
- if len(message) > 0 {
- content = append(content, labeledContent{"Messages", message})
- }
-
- t.Errorf("\n%s", ""+labeledOutput(content...))
-
- return false
-}
-
-type labeledContent struct {
- label string
- content string
-}
-
-// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:
-//
-// \t{{label}}:{{align_spaces}}\t{{content}}\n
-//
-// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.
-// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this
-// alignment is achieved, "\t{{content}}\n" is added for the output.
-//
-// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line.
-func labeledOutput(content ...labeledContent) string {
- longestLabel := 0
- for _, v := range content {
- if len(v.label) > longestLabel {
- longestLabel = len(v.label)
- }
- }
- var output string
- for _, v := range content {
- output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n"
- }
- return output
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- interfaceType := reflect.TypeOf(interfaceObject).Elem()
-
- if object == nil {
- return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...)
- }
- if !reflect.TypeOf(object).Implements(interfaceType) {
- return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...)
- }
-
- return true
-}
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
- return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
- }
-
- return true
-}
-
-// Equal asserts that two objects are equal.
-//
-// assert.Equal(t, 123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if err := validateEqualArgs(expected, actual); err != nil {
- return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)",
- expected, actual, err), msgAndArgs...)
- }
-
- if !ObjectsAreEqual(expected, actual) {
- diff := diff(expected, actual)
- expected, actual = formatUnequalValues(expected, actual)
- return Fail(t, fmt.Sprintf("Not equal: \n"+
- "expected: %s\n"+
- "actual : %s%s", expected, actual, diff), msgAndArgs...)
- }
-
- return true
-
-}
-
-// validateEqualArgs checks whether provided arguments can be safely used in the
-// Equal/NotEqual functions.
-func validateEqualArgs(expected, actual interface{}) error {
- if expected == nil && actual == nil {
- return nil
- }
-
- if isFunction(expected) || isFunction(actual) {
- return errors.New("cannot take func type as argument")
- }
- return nil
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// assert.Same(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !samePointers(expected, actual) {
- return Fail(t, fmt.Sprintf("Not same: \n"+
- "expected: %p %#v\n"+
- "actual : %p %#v", expected, expected, actual, actual), msgAndArgs...)
- }
-
- return true
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// assert.NotSame(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if samePointers(expected, actual) {
- return Fail(t, fmt.Sprintf(
- "Expected and actual point to the same object: %p %#v",
- expected, expected), msgAndArgs...)
- }
- return true
-}
-
-// samePointers compares two generic interface objects and returns whether
-// they point to the same object
-func samePointers(first, second interface{}) bool {
- firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second)
- if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr {
- return false
- }
-
- firstType, secondType := reflect.TypeOf(first), reflect.TypeOf(second)
- if firstType != secondType {
- return false
- }
-
- // compare pointer addresses
- return first == second
-}
-
-// formatUnequalValues takes two values of arbitrary types and returns string
-// representations appropriate to be presented to the user.
-//
-// If the values are not of like type, the returned strings will be prefixed
-// with the type name, and the value will be enclosed in parenthesis similar
-// to a type conversion in the Go grammar.
-func formatUnequalValues(expected, actual interface{}) (e string, a string) {
- if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
- return fmt.Sprintf("%T(%s)", expected, truncatingFormat(expected)),
- fmt.Sprintf("%T(%s)", actual, truncatingFormat(actual))
- }
- switch expected.(type) {
- case time.Duration:
- return fmt.Sprintf("%v", expected), fmt.Sprintf("%v", actual)
- }
- return truncatingFormat(expected), truncatingFormat(actual)
-}
-
-// truncatingFormat formats the data and truncates it if it's too long.
-//
-// This helps keep formatted error messages lines from exceeding the
-// bufio.MaxScanTokenSize max line length that the go testing framework imposes.
-func truncatingFormat(data interface{}) string {
- value := fmt.Sprintf("%#v", data)
- max := bufio.MaxScanTokenSize - 100 // Give us some space the type info too if needed.
- if len(value) > max {
- value = value[0:max] + "<... truncated>"
- }
- return value
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// assert.EqualValues(t, uint32(123), int32(123))
-func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if !ObjectsAreEqualValues(expected, actual) {
- diff := diff(expected, actual)
- expected, actual = formatUnequalValues(expected, actual)
- return Fail(t, fmt.Sprintf("Not equal: \n"+
- "expected: %s\n"+
- "actual : %s%s", expected, actual, diff), msgAndArgs...)
- }
-
- return true
-
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// assert.Exactly(t, int32(123), int64(123))
-func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- aType := reflect.TypeOf(expected)
- bType := reflect.TypeOf(actual)
-
- if aType != bType {
- return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
- }
-
- return Equal(t, expected, actual, msgAndArgs...)
-
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// assert.NotNil(t, err)
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- if !isNil(object) {
- return true
- }
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Expected value not to be nil.", msgAndArgs...)
-}
-
-// containsKind checks if a specified kind in the slice of kinds.
-func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool {
- for i := 0; i < len(kinds); i++ {
- if kind == kinds[i] {
- return true
- }
- }
-
- return false
-}
-
-// isNil checks if a specified object is nil or not, without Failing.
-func isNil(object interface{}) bool {
- if object == nil {
- return true
- }
-
- value := reflect.ValueOf(object)
- kind := value.Kind()
- isNilableKind := containsKind(
- []reflect.Kind{
- reflect.Chan, reflect.Func,
- reflect.Interface, reflect.Map,
- reflect.Ptr, reflect.Slice, reflect.UnsafePointer},
- kind)
-
- if isNilableKind && value.IsNil() {
- return true
- }
-
- return false
-}
-
-// Nil asserts that the specified object is nil.
-//
-// assert.Nil(t, err)
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- if isNil(object) {
- return true
- }
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
-}
-
-// isEmpty gets whether the specified object is considered empty or not.
-func isEmpty(object interface{}) bool {
-
- // get nil case out of the way
- if object == nil {
- return true
- }
-
- objValue := reflect.ValueOf(object)
-
- switch objValue.Kind() {
- // collection types are empty when they have no element
- case reflect.Chan, reflect.Map, reflect.Slice:
- return objValue.Len() == 0
- // pointers are empty if nil or if the value they point to is empty
- case reflect.Ptr:
- if objValue.IsNil() {
- return true
- }
- deref := objValue.Elem().Interface()
- return isEmpty(deref)
- // for all other types, compare against the zero value
- // array types are empty when they match their zero-initialized state
- default:
- zero := reflect.Zero(objValue.Type())
- return reflect.DeepEqual(object, zero.Interface())
- }
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Empty(t, obj)
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- pass := isEmpty(object)
- if !pass {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
- }
-
- return pass
-
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
- pass := !isEmpty(object)
- if !pass {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
- }
-
- return pass
-
-}
-
-// getLen try to get length of object.
-// return (false, 0) if impossible.
-func getLen(x interface{}) (ok bool, length int) {
- v := reflect.ValueOf(x)
- defer func() {
- if e := recover(); e != nil {
- ok = false
- }
- }()
- return true, v.Len()
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// assert.Len(t, mySlice, 3)
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- ok, l := getLen(object)
- if !ok {
- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
- }
-
- if l != length {
- return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
- }
- return true
-}
-
-// True asserts that the specified value is true.
-//
-// assert.True(t, myBool)
-func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
- if !value {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Should be true", msgAndArgs...)
- }
-
- return true
-
-}
-
-// False asserts that the specified value is false.
-//
-// assert.False(t, myBool)
-func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
- if value {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "Should be false", msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// assert.NotEqual(t, obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if err := validateEqualArgs(expected, actual); err != nil {
- return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)",
- expected, actual, err), msgAndArgs...)
- }
-
- if ObjectsAreEqual(expected, actual) {
- return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValues(t, obj1, obj2)
-func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if ObjectsAreEqualValues(expected, actual) {
- return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
- }
-
- return true
-}
-
-// containsElement try loop over the list check if the list includes the element.
-// return (false, false) if impossible.
-// return (true, false) if element was not found.
-// return (true, true) if element was found.
-func containsElement(list interface{}, element interface{}) (ok, found bool) {
-
- listValue := reflect.ValueOf(list)
- listType := reflect.TypeOf(list)
- if listType == nil {
- return false, false
- }
- listKind := listType.Kind()
- defer func() {
- if e := recover(); e != nil {
- ok = false
- found = false
- }
- }()
-
- if listKind == reflect.String {
- elementValue := reflect.ValueOf(element)
- return true, strings.Contains(listValue.String(), elementValue.String())
- }
-
- if listKind == reflect.Map {
- mapKeys := listValue.MapKeys()
- for i := 0; i < len(mapKeys); i++ {
- if ObjectsAreEqual(mapKeys[i].Interface(), element) {
- return true, true
- }
- }
- return true, false
- }
-
- for i := 0; i < listValue.Len(); i++ {
- if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
- return true, true
- }
- }
- return true, false
-
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
-func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ok, found := containsElement(s, contains)
- if !ok {
- return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
- }
- if !found {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", s, contains), msgAndArgs...)
- }
-
- return true
-
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
-func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ok, found := containsElement(s, contains)
- if !ok {
- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
- }
- if found {
- return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
- }
-
- return true
-
-}
-
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
-func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if subset == nil {
- return true // we consider nil to be equal to the nil set
- }
-
- listKind := reflect.TypeOf(list).Kind()
- if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
- }
-
- subsetKind := reflect.TypeOf(subset).Kind()
- if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
- }
-
- if subsetKind == reflect.Map && listKind == reflect.Map {
- subsetMap := reflect.ValueOf(subset)
- actualMap := reflect.ValueOf(list)
-
- for _, k := range subsetMap.MapKeys() {
- ev := subsetMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !av.IsValid() {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
- }
- if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
- }
- }
-
- return true
- }
-
- subsetList := reflect.ValueOf(subset)
- for i := 0; i < subsetList.Len(); i++ {
- element := subsetList.Index(i).Interface()
- ok, found := containsElement(list, element)
- if !ok {
- return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", list), msgAndArgs...)
- }
- if !found {
- return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, element), msgAndArgs...)
- }
- }
-
- return true
-}
-
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
-func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if subset == nil {
- return Fail(t, "nil is the empty set which is a subset of every set", msgAndArgs...)
- }
-
- listKind := reflect.TypeOf(list).Kind()
- if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
- }
-
- subsetKind := reflect.TypeOf(subset).Kind()
- if subsetKind != reflect.Array && subsetKind != reflect.Slice && listKind != reflect.Map {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
- }
-
- if subsetKind == reflect.Map && listKind == reflect.Map {
- subsetMap := reflect.ValueOf(subset)
- actualMap := reflect.ValueOf(list)
-
- for _, k := range subsetMap.MapKeys() {
- ev := subsetMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !av.IsValid() {
- return true
- }
- if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
- return true
- }
- }
-
- return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
- }
-
- subsetList := reflect.ValueOf(subset)
- for i := 0; i < subsetList.Len(); i++ {
- element := subsetList.Index(i).Interface()
- ok, found := containsElement(list, element)
- if !ok {
- return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...)
- }
- if !found {
- return true
- }
- }
-
- return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
-func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if isEmpty(listA) && isEmpty(listB) {
- return true
- }
-
- if !isList(t, listA, msgAndArgs...) || !isList(t, listB, msgAndArgs...) {
- return false
- }
-
- extraA, extraB := diffLists(listA, listB)
-
- if len(extraA) == 0 && len(extraB) == 0 {
- return true
- }
-
- return Fail(t, formatListDiff(listA, listB, extraA, extraB), msgAndArgs...)
-}
-
-// isList checks that the provided value is array or slice.
-func isList(t TestingT, list interface{}, msgAndArgs ...interface{}) (ok bool) {
- kind := reflect.TypeOf(list).Kind()
- if kind != reflect.Array && kind != reflect.Slice {
- return Fail(t, fmt.Sprintf("%q has an unsupported type %s, expecting array or slice", list, kind),
- msgAndArgs...)
- }
- return true
-}
-
-// diffLists diffs two arrays/slices and returns slices of elements that are only in A and only in B.
-// If some element is present multiple times, each instance is counted separately (e.g. if something is 2x in A and
-// 5x in B, it will be 0x in extraA and 3x in extraB). The order of items in both lists is ignored.
-func diffLists(listA, listB interface{}) (extraA, extraB []interface{}) {
- aValue := reflect.ValueOf(listA)
- bValue := reflect.ValueOf(listB)
-
- aLen := aValue.Len()
- bLen := bValue.Len()
-
- // Mark indexes in bValue that we already used
- visited := make([]bool, bLen)
- for i := 0; i < aLen; i++ {
- element := aValue.Index(i).Interface()
- found := false
- for j := 0; j < bLen; j++ {
- if visited[j] {
- continue
- }
- if ObjectsAreEqual(bValue.Index(j).Interface(), element) {
- visited[j] = true
- found = true
- break
- }
- }
- if !found {
- extraA = append(extraA, element)
- }
- }
-
- for j := 0; j < bLen; j++ {
- if visited[j] {
- continue
- }
- extraB = append(extraB, bValue.Index(j).Interface())
- }
-
- return
-}
-
-func formatListDiff(listA, listB interface{}, extraA, extraB []interface{}) string {
- var msg bytes.Buffer
-
- msg.WriteString("elements differ")
- if len(extraA) > 0 {
- msg.WriteString("\n\nextra elements in list A:\n")
- msg.WriteString(spewConfig.Sdump(extraA))
- }
- if len(extraB) > 0 {
- msg.WriteString("\n\nextra elements in list B:\n")
- msg.WriteString(spewConfig.Sdump(extraB))
- }
- msg.WriteString("\n\nlistA:\n")
- msg.WriteString(spewConfig.Sdump(listA))
- msg.WriteString("\n\nlistB:\n")
- msg.WriteString(spewConfig.Sdump(listB))
-
- return msg.String()
-}
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- result := comp()
- if !result {
- Fail(t, "Condition failed!", msgAndArgs...)
- }
- return result
-}
-
-// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
-// methods, and represents a simple func that takes no arguments, and returns nothing.
-type PanicTestFunc func()
-
-// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
-func didPanic(f PanicTestFunc) (didPanic bool, message interface{}, stack string) {
- didPanic = true
-
- defer func() {
- message = recover()
- if didPanic {
- stack = string(debug.Stack())
- }
- }()
-
- // call the target function
- f()
- didPanic = false
-
- return
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panics(t, func(){ GoCrazy() })
-func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if funcDidPanic, panicValue, _ := didPanic(f); !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
-
- return true
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- funcDidPanic, panicValue, panickedStack := didPanic(f)
- if !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
- if panicValue != expected {
- return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, expected, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- funcDidPanic, panicValue, panickedStack := didPanic(f)
- if !funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
- }
- panicErr, ok := panicValue.(error)
- if !ok || panicErr.Error() != errString {
- return Fail(t, fmt.Sprintf("func %#v should panic with error message:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, errString, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanics(t, func(){ RemainCalm() })
-func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if funcDidPanic, panicValue, panickedStack := didPanic(f); funcDidPanic {
- return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v\n\tPanic stack:\t%s", f, panicValue, panickedStack), msgAndArgs...)
- }
-
- return true
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
-func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- dt := expected.Sub(actual)
- if dt < -delta || dt > delta {
- return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
- }
-
- return true
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func WithinRange(t TestingT, actual, start, end time.Time, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- if end.Before(start) {
- return Fail(t, "Start should be before end", msgAndArgs...)
- }
-
- if actual.Before(start) {
- return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is before the range", actual, start, end), msgAndArgs...)
- } else if actual.After(end) {
- return Fail(t, fmt.Sprintf("Time %v expected to be in time range %v to %v, but is after the range", actual, start, end), msgAndArgs...)
- }
-
- return true
-}
-
-func toFloat(x interface{}) (float64, bool) {
- var xf float64
- xok := true
-
- switch xn := x.(type) {
- case uint:
- xf = float64(xn)
- case uint8:
- xf = float64(xn)
- case uint16:
- xf = float64(xn)
- case uint32:
- xf = float64(xn)
- case uint64:
- xf = float64(xn)
- case int:
- xf = float64(xn)
- case int8:
- xf = float64(xn)
- case int16:
- xf = float64(xn)
- case int32:
- xf = float64(xn)
- case int64:
- xf = float64(xn)
- case float32:
- xf = float64(xn)
- case float64:
- xf = xn
- case time.Duration:
- xf = float64(xn)
- default:
- xok = false
- }
-
- return xf, xok
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
-func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- af, aok := toFloat(expected)
- bf, bok := toFloat(actual)
-
- if !aok || !bok {
- return Fail(t, "Parameters must be numerical", msgAndArgs...)
- }
-
- if math.IsNaN(af) && math.IsNaN(bf) {
- return true
- }
-
- if math.IsNaN(af) {
- return Fail(t, "Expected must not be NaN", msgAndArgs...)
- }
-
- if math.IsNaN(bf) {
- return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...)
- }
-
- dt := af - bf
- if dt < -delta || dt > delta {
- return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
- }
-
- return true
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if expected == nil || actual == nil ||
- reflect.TypeOf(actual).Kind() != reflect.Slice ||
- reflect.TypeOf(expected).Kind() != reflect.Slice {
- return Fail(t, "Parameters must be slice", msgAndArgs...)
- }
-
- actualSlice := reflect.ValueOf(actual)
- expectedSlice := reflect.ValueOf(expected)
-
- for i := 0; i < actualSlice.Len(); i++ {
- result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...)
- if !result {
- return result
- }
- }
-
- return true
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if expected == nil || actual == nil ||
- reflect.TypeOf(actual).Kind() != reflect.Map ||
- reflect.TypeOf(expected).Kind() != reflect.Map {
- return Fail(t, "Arguments must be maps", msgAndArgs...)
- }
-
- expectedMap := reflect.ValueOf(expected)
- actualMap := reflect.ValueOf(actual)
-
- if expectedMap.Len() != actualMap.Len() {
- return Fail(t, "Arguments must have the same number of keys", msgAndArgs...)
- }
-
- for _, k := range expectedMap.MapKeys() {
- ev := expectedMap.MapIndex(k)
- av := actualMap.MapIndex(k)
-
- if !ev.IsValid() {
- return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...)
- }
-
- if !av.IsValid() {
- return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...)
- }
-
- if !InDelta(
- t,
- ev.Interface(),
- av.Interface(),
- delta,
- msgAndArgs...,
- ) {
- return false
- }
- }
-
- return true
-}
-
-func calcRelativeError(expected, actual interface{}) (float64, error) {
- af, aok := toFloat(expected)
- bf, bok := toFloat(actual)
- if !aok || !bok {
- return 0, fmt.Errorf("Parameters must be numerical")
- }
- if math.IsNaN(af) && math.IsNaN(bf) {
- return 0, nil
- }
- if math.IsNaN(af) {
- return 0, errors.New("expected value must not be NaN")
- }
- if af == 0 {
- return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error")
- }
- if math.IsNaN(bf) {
- return 0, errors.New("actual value must not be NaN")
- }
-
- return math.Abs(af-bf) / math.Abs(af), nil
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if math.IsNaN(epsilon) {
- return Fail(t, "epsilon must not be NaN")
- }
- actualEpsilon, err := calcRelativeError(expected, actual)
- if err != nil {
- return Fail(t, err.Error(), msgAndArgs...)
- }
- if actualEpsilon > epsilon {
- return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+
- " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...)
- }
-
- return true
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if expected == nil || actual == nil ||
- reflect.TypeOf(actual).Kind() != reflect.Slice ||
- reflect.TypeOf(expected).Kind() != reflect.Slice {
- return Fail(t, "Parameters must be slice", msgAndArgs...)
- }
-
- actualSlice := reflect.ValueOf(actual)
- expectedSlice := reflect.ValueOf(expected)
-
- for i := 0; i < actualSlice.Len(); i++ {
- result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon)
- if !result {
- return result
- }
- }
-
- return true
-}
-
-/*
- Errors
-*/
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
- if err != nil {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...)
- }
-
- return true
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
-func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
- if err == nil {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- return Fail(t, "An error is expected but got nil.", msgAndArgs...)
- }
-
- return true
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !Error(t, theError, msgAndArgs...) {
- return false
- }
- expected := errString
- actual := theError.Error()
- // don't need to use deep equals here, we know they are both strings
- if expected != actual {
- return Fail(t, fmt.Sprintf("Error message not equal:\n"+
- "expected: %q\n"+
- "actual : %q", expected, actual), msgAndArgs...)
- }
- return true
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
-func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !Error(t, theError, msgAndArgs...) {
- return false
- }
-
- actual := theError.Error()
- if !strings.Contains(actual, contains) {
- return Fail(t, fmt.Sprintf("Error %#v does not contain %#v", actual, contains), msgAndArgs...)
- }
-
- return true
-}
-
-// matchRegexp return true if a specified regexp matches a string.
-func matchRegexp(rx interface{}, str interface{}) bool {
-
- var r *regexp.Regexp
- if rr, ok := rx.(*regexp.Regexp); ok {
- r = rr
- } else {
- r = regexp.MustCompile(fmt.Sprint(rx))
- }
-
- return (r.FindStringIndex(fmt.Sprint(str)) != nil)
-
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- match := matchRegexp(rx, str)
-
- if !match {
- Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...)
- }
-
- return match
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- match := matchRegexp(rx, str)
-
- if match {
- Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...)
- }
-
- return !match
-
-}
-
-// Zero asserts that i is the zero value for its type.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
- return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...)
- }
- return true
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
- return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...)
- }
- return true
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
- }
- return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
- }
- if info.IsDir() {
- return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...)
- }
- return true
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- return true
- }
- if info.IsDir() {
- return true
- }
- return Fail(t, fmt.Sprintf("file %q exists", path), msgAndArgs...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...)
- }
- return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...)
- }
- if !info.IsDir() {
- return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...)
- }
- return true
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- info, err := os.Lstat(path)
- if err != nil {
- if os.IsNotExist(err) {
- return true
- }
- return true
- }
- if !info.IsDir() {
- return true
- }
- return Fail(t, fmt.Sprintf("directory %q exists", path), msgAndArgs...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- var expectedJSONAsInterface, actualJSONAsInterface interface{}
-
- if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...)
- }
-
- if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...)
- }
-
- return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
-}
-
-// YAMLEq asserts that two YAML strings are equivalent.
-func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- var expectedYAMLAsInterface, actualYAMLAsInterface interface{}
-
- if err := yaml.Unmarshal([]byte(expected), &expectedYAMLAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid yaml.\nYAML parsing error: '%s'", expected, err.Error()), msgAndArgs...)
- }
-
- if err := yaml.Unmarshal([]byte(actual), &actualYAMLAsInterface); err != nil {
- return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid yaml.\nYAML error: '%s'", actual, err.Error()), msgAndArgs...)
- }
-
- return Equal(t, expectedYAMLAsInterface, actualYAMLAsInterface, msgAndArgs...)
-}
-
-func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
- t := reflect.TypeOf(v)
- k := t.Kind()
-
- if k == reflect.Ptr {
- t = t.Elem()
- k = t.Kind()
- }
- return t, k
-}
-
-// diff returns a diff of both values as long as both are of the same type and
-// are a struct, map, slice, array or string. Otherwise it returns an empty string.
-func diff(expected interface{}, actual interface{}) string {
- if expected == nil || actual == nil {
- return ""
- }
-
- et, ek := typeAndKind(expected)
- at, _ := typeAndKind(actual)
-
- if et != at {
- return ""
- }
-
- if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String {
- return ""
- }
-
- var e, a string
-
- switch et {
- case reflect.TypeOf(""):
- e = reflect.ValueOf(expected).String()
- a = reflect.ValueOf(actual).String()
- case reflect.TypeOf(time.Time{}):
- e = spewConfigStringerEnabled.Sdump(expected)
- a = spewConfigStringerEnabled.Sdump(actual)
- default:
- e = spewConfig.Sdump(expected)
- a = spewConfig.Sdump(actual)
- }
-
- diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
- A: difflib.SplitLines(e),
- B: difflib.SplitLines(a),
- FromFile: "Expected",
- FromDate: "",
- ToFile: "Actual",
- ToDate: "",
- Context: 1,
- })
-
- return "\n\nDiff:\n" + diff
-}
-
-func isFunction(arg interface{}) bool {
- if arg == nil {
- return false
- }
- return reflect.TypeOf(arg).Kind() == reflect.Func
-}
-
-var spewConfig = spew.ConfigState{
- Indent: " ",
- DisablePointerAddresses: true,
- DisableCapacities: true,
- SortKeys: true,
- DisableMethods: true,
- MaxDepth: 10,
-}
-
-var spewConfigStringerEnabled = spew.ConfigState{
- Indent: " ",
- DisablePointerAddresses: true,
- DisableCapacities: true,
- SortKeys: true,
- MaxDepth: 10,
-}
-
-type tHelper interface {
- Helper()
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
-func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ch := make(chan bool, 1)
-
- timer := time.NewTimer(waitFor)
- defer timer.Stop()
-
- ticker := time.NewTicker(tick)
- defer ticker.Stop()
-
- for tick := ticker.C; ; {
- select {
- case <-timer.C:
- return Fail(t, "Condition never satisfied", msgAndArgs...)
- case <-tick:
- tick = nil
- go func() { ch <- condition() }()
- case v := <-ch:
- if v {
- return true
- }
- tick = ticker.C
- }
- }
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
-func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- ch := make(chan bool, 1)
-
- timer := time.NewTimer(waitFor)
- defer timer.Stop()
-
- ticker := time.NewTicker(tick)
- defer ticker.Stop()
-
- for tick := ticker.C; ; {
- select {
- case <-timer.C:
- return true
- case <-tick:
- tick = nil
- go func() { ch <- condition() }()
- case v := <-ch:
- if v {
- return Fail(t, "Condition satisfied", msgAndArgs...)
- }
- tick = ticker.C
- }
- }
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if errors.Is(err, target) {
- return true
- }
-
- var expectedText string
- if target != nil {
- expectedText = target.Error()
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Target error should be in err chain:\n"+
- "expected: %q\n"+
- "in chain: %s", expectedText, chain,
- ), msgAndArgs...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if !errors.Is(err, target) {
- return true
- }
-
- var expectedText string
- if target != nil {
- expectedText = target.Error()
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
- "found: %q\n"+
- "in chain: %s", expectedText, chain,
- ), msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if errors.As(err, target) {
- return true
- }
-
- chain := buildErrorChainString(err)
-
- return Fail(t, fmt.Sprintf("Should be in error chain:\n"+
- "expected: %q\n"+
- "in chain: %s", target, chain,
- ), msgAndArgs...)
-}
-
-func buildErrorChainString(err error) string {
- if err == nil {
- return ""
- }
-
- e := errors.Unwrap(err)
- chain := fmt.Sprintf("%q", err.Error())
- for e != nil {
- chain += fmt.Sprintf("\n\t%q", e.Error())
- e = errors.Unwrap(e)
- }
- return chain
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions_test.go
deleted file mode 100644
index cae11f81dd37666efcfc2d567d4c855ef56f2837..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/assertions_test.go
+++ /dev/null
@@ -1,2582 +0,0 @@
-package assert
-
-import (
- "bufio"
- "bytes"
- "encoding/json"
- "errors"
- "fmt"
- "io"
- "math"
- "os"
- "reflect"
- "regexp"
- "runtime"
- "strings"
- "testing"
- "time"
- "unsafe"
-)
-
-var (
- i interface{}
- zeros = []interface{}{
- false,
- byte(0),
- complex64(0),
- complex128(0),
- float32(0),
- float64(0),
- int(0),
- int8(0),
- int16(0),
- int32(0),
- int64(0),
- rune(0),
- uint(0),
- uint8(0),
- uint16(0),
- uint32(0),
- uint64(0),
- uintptr(0),
- "",
- [0]interface{}{},
- []interface{}(nil),
- struct{ x int }{},
- (*interface{})(nil),
- (func())(nil),
- nil,
- interface{}(nil),
- map[interface{}]interface{}(nil),
- (chan interface{})(nil),
- (<-chan interface{})(nil),
- (chan<- interface{})(nil),
- }
- nonZeros = []interface{}{
- true,
- byte(1),
- complex64(1),
- complex128(1),
- float32(1),
- float64(1),
- int(1),
- int8(1),
- int16(1),
- int32(1),
- int64(1),
- rune(1),
- uint(1),
- uint8(1),
- uint16(1),
- uint32(1),
- uint64(1),
- uintptr(1),
- "s",
- [1]interface{}{1},
- []interface{}{},
- struct{ x int }{1},
- (&i),
- (func() {}),
- interface{}(1),
- map[interface{}]interface{}{},
- (make(chan interface{})),
- (<-chan interface{})(make(chan interface{})),
- (chan<- interface{})(make(chan interface{})),
- }
-)
-
-// AssertionTesterInterface defines an interface to be used for testing assertion methods
-type AssertionTesterInterface interface {
- TestMethod()
-}
-
-// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
-type AssertionTesterConformingObject struct {
-}
-
-func (a *AssertionTesterConformingObject) TestMethod() {
-}
-
-// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
-type AssertionTesterNonConformingObject struct {
-}
-
-func TestObjectsAreEqual(t *testing.T) {
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected to be equal
- {"Hello World", "Hello World", true},
- {123, 123, true},
- {123.5, 123.5, true},
- {[]byte("Hello World"), []byte("Hello World"), true},
- {nil, nil, true},
-
- // cases that are expected not to be equal
- {map[int]int{5: 10}, map[int]int{10: 20}, false},
- {'x', "x", false},
- {"x", 'x', false},
- {0, 0.1, false},
- {0.1, 0, false},
- {time.Now, time.Now, false},
- {func() {}, func() {}, false},
- {uint32(10), int32(10), false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ObjectsAreEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ObjectsAreEqual(c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("ObjectsAreEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
-
- })
- }
-
- // Cases where type differ but values are equal
- if !ObjectsAreEqualValues(uint32(10), int32(10)) {
- t.Error("ObjectsAreEqualValues should return true")
- }
- if ObjectsAreEqualValues(0, nil) {
- t.Fail()
- }
- if ObjectsAreEqualValues(nil, 0) {
- t.Fail()
- }
-
-}
-
-func TestImplements(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
- t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
- }
- if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
- t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
- }
- if Implements(mockT, (*AssertionTesterInterface)(nil), nil) {
- t.Error("Implements method should return false: nil does not implement AssertionTesterInterface")
- }
-
-}
-
-func TestIsType(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
- t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
- }
- if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
- t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
- }
-
-}
-
-func TestEqual(t *testing.T) {
- type myType string
-
- mockT := new(testing.T)
- var m map[string]interface{}
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- remark string
- }{
- {"Hello World", "Hello World", true, ""},
- {123, 123, true, ""},
- {123.5, 123.5, true, ""},
- {[]byte("Hello World"), []byte("Hello World"), true, ""},
- {nil, nil, true, ""},
- {int32(123), int32(123), true, ""},
- {uint64(123), uint64(123), true, ""},
- {myType("1"), myType("1"), true, ""},
- {&struct{}{}, &struct{}{}, true, "pointer equality is based on equality of underlying value"},
-
- // Not expected to be equal
- {m["bar"], "something", false, ""},
- {myType("1"), myType("2"), false, ""},
-
- // A case that might be confusing, especially with numeric literals
- {10, uint(10), false, ""},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Equal(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := Equal(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("Equal(%#v, %#v) should return %#v: %s", c.expected, c.actual, c.result, c.remark)
- }
- })
- }
-}
-
-func ptr(i int) *int {
- return &i
-}
-
-func TestSame(t *testing.T) {
-
- mockT := new(testing.T)
-
- if Same(mockT, ptr(1), ptr(1)) {
- t.Error("Same should return false")
- }
- if Same(mockT, 1, 1) {
- t.Error("Same should return false")
- }
- p := ptr(2)
- if Same(mockT, p, *p) {
- t.Error("Same should return false")
- }
- if !Same(mockT, p, p) {
- t.Error("Same should return true")
- }
-}
-
-func TestNotSame(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotSame(mockT, ptr(1), ptr(1)) {
- t.Error("NotSame should return true; different pointers")
- }
- if !NotSame(mockT, 1, 1) {
- t.Error("NotSame should return true; constant inputs")
- }
- p := ptr(2)
- if !NotSame(mockT, p, *p) {
- t.Error("NotSame should return true; mixed-type inputs")
- }
- if NotSame(mockT, p, p) {
- t.Error("NotSame should return false")
- }
-}
-
-func Test_samePointers(t *testing.T) {
- p := ptr(2)
-
- type args struct {
- first interface{}
- second interface{}
- }
- tests := []struct {
- name string
- args args
- assertion BoolAssertionFunc
- }{
- {
- name: "1 != 2",
- args: args{first: 1, second: 2},
- assertion: False,
- },
- {
- name: "1 != 1 (not same ptr)",
- args: args{first: 1, second: 1},
- assertion: False,
- },
- {
- name: "ptr(1) == ptr(1)",
- args: args{first: p, second: p},
- assertion: True,
- },
- {
- name: "int(1) != float32(1)",
- args: args{first: int(1), second: float32(1)},
- assertion: False,
- },
- {
- name: "array != slice",
- args: args{first: [2]int{1, 2}, second: []int{1, 2}},
- assertion: False,
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, samePointers(tt.args.first, tt.args.second))
- })
- }
-}
-
-// bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by
-// testing.T.Errorf to an internal bytes.Buffer.
-type bufferT struct {
- buf bytes.Buffer
-}
-
-func (t *bufferT) Errorf(format string, args ...interface{}) {
- // implementation of decorate is copied from testing.T
- decorate := func(s string) string {
- _, file, line, ok := runtime.Caller(3) // decorate + log + public function.
- if ok {
- // Truncate file name at last file name separator.
- if index := strings.LastIndex(file, "/"); index >= 0 {
- file = file[index+1:]
- } else if index = strings.LastIndex(file, "\\"); index >= 0 {
- file = file[index+1:]
- }
- } else {
- file = "???"
- line = 1
- }
- buf := new(bytes.Buffer)
- // Every line is indented at least one tab.
- buf.WriteByte('\t')
- fmt.Fprintf(buf, "%s:%d: ", file, line)
- lines := strings.Split(s, "\n")
- if l := len(lines); l > 1 && lines[l-1] == "" {
- lines = lines[:l-1]
- }
- for i, line := range lines {
- if i > 0 {
- // Second and subsequent lines are indented an extra tab.
- buf.WriteString("\n\t\t")
- }
- buf.WriteString(line)
- }
- buf.WriteByte('\n')
- return buf.String()
- }
- t.buf.WriteString(decorate(fmt.Sprintf(format, args...)))
-}
-
-func TestStringEqual(t *testing.T) {
- for i, currCase := range []struct {
- equalWant string
- equalGot string
- msgAndArgs []interface{}
- want string
- }{
- {equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"},
- } {
- mockT := &bufferT{}
- Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
- Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
- }
-}
-
-func TestEqualFormatting(t *testing.T) {
- for i, currCase := range []struct {
- equalWant string
- equalGot string
- msgAndArgs []interface{}
- want string
- }{
- {equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"},
- {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"},
- } {
- mockT := &bufferT{}
- Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...)
- Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i)
- }
-}
-
-func TestFormatUnequalValues(t *testing.T) {
- expected, actual := formatUnequalValues("foo", "bar")
- Equal(t, `"foo"`, expected, "value should not include type")
- Equal(t, `"bar"`, actual, "value should not include type")
-
- expected, actual = formatUnequalValues(123, 123)
- Equal(t, `123`, expected, "value should not include type")
- Equal(t, `123`, actual, "value should not include type")
-
- expected, actual = formatUnequalValues(int64(123), int32(123))
- Equal(t, `int64(123)`, expected, "value should include type")
- Equal(t, `int32(123)`, actual, "value should include type")
-
- expected, actual = formatUnequalValues(int64(123), nil)
- Equal(t, `int64(123)`, expected, "value should include type")
- Equal(t, `<nil>(<nil>)`, actual, "value should include type")
-
- type testStructType struct {
- Val string
- }
-
- expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"})
- Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation")
- Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation")
-}
-
-func TestNotNil(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotNil(mockT, new(AssertionTesterConformingObject)) {
- t.Error("NotNil should return true: object is not nil")
- }
- if NotNil(mockT, nil) {
- t.Error("NotNil should return false: object is nil")
- }
- if NotNil(mockT, (*struct{})(nil)) {
- t.Error("NotNil should return false: object is (*struct{})(nil)")
- }
-
-}
-
-func TestNil(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Nil(mockT, nil) {
- t.Error("Nil should return true: object is nil")
- }
- if !Nil(mockT, (*struct{})(nil)) {
- t.Error("Nil should return true: object is (*struct{})(nil)")
- }
- if Nil(mockT, new(AssertionTesterConformingObject)) {
- t.Error("Nil should return false: object is not nil")
- }
-
-}
-
-func TestTrue(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !True(mockT, true) {
- t.Error("True should return true")
- }
- if True(mockT, false) {
- t.Error("True should return false")
- }
-
-}
-
-func TestFalse(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !False(mockT, false) {
- t.Error("False should return true")
- }
- if False(mockT, true) {
- t.Error("False should return false")
- }
-
-}
-
-func TestExactly(t *testing.T) {
-
- mockT := new(testing.T)
-
- a := float32(1)
- b := float64(1)
- c := float32(1)
- d := float32(2)
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {a, b, false},
- {a, d, false},
- {a, c, true},
- {nil, a, false},
- {a, nil, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Exactly(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := Exactly(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("Exactly(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestNotEqual(t *testing.T) {
-
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected not to match
- {"Hello World", "Hello World!", true},
- {123, 1234, true},
- {123.5, 123.55, true},
- {[]byte("Hello World"), []byte("Hello World!"), true},
- {nil, new(AssertionTesterConformingObject), true},
-
- // cases that are expected to match
- {nil, nil, false},
- {"Hello World", "Hello World", false},
- {123, 123, false},
- {123.5, 123.5, false},
- {[]byte("Hello World"), []byte("Hello World"), false},
- {new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
- {&struct{}{}, &struct{}{}, false},
- {func() int { return 23 }, func() int { return 24 }, false},
- // A case that might be confusing, especially with numeric literals
- {int(10), uint(10), true},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotEqual(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := NotEqual(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("NotEqual(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestNotEqualValues(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // cases that are expected not to match
- {"Hello World", "Hello World!", true},
- {123, 1234, true},
- {123.5, 123.55, true},
- {[]byte("Hello World"), []byte("Hello World!"), true},
- {nil, new(AssertionTesterConformingObject), true},
-
- // cases that are expected to match
- {nil, nil, false},
- {"Hello World", "Hello World", false},
- {123, 123, false},
- {123.5, 123.5, false},
- {[]byte("Hello World"), []byte("Hello World"), false},
- {new(AssertionTesterConformingObject), new(AssertionTesterConformingObject), false},
- {&struct{}{}, &struct{}{}, false},
-
- // Different behaviour from NotEqual()
- {func() int { return 23 }, func() int { return 24 }, true},
- {int(10), int(11), true},
- {int(10), uint(10), false},
-
- {struct{}{}, struct{}{}, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotEqualValues(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := NotEqualValues(mockT, c.expected, c.actual)
-
- if res != c.result {
- t.Errorf("NotEqualValues(%#v, %#v) should return %#v", c.expected, c.actual, c.result)
- }
- })
- }
-}
-
-func TestContainsNotContains(t *testing.T) {
-
- type A struct {
- Name, Value string
- }
- list := []string{"Foo", "Bar"}
-
- complexList := []*A{
- {"b", "c"},
- {"d", "e"},
- {"g", "h"},
- {"j", "k"},
- }
- simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
- var zeroMap map[interface{}]interface{}
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- {"Hello World", "Hello", true},
- {"Hello World", "Salut", false},
- {list, "Bar", true},
- {list, "Salut", false},
- {complexList, &A{"g", "h"}, true},
- {complexList, &A{"g", "e"}, false},
- {simpleMap, "Foo", true},
- {simpleMap, "Bar", false},
- {zeroMap, "Bar", false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("Contains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- mockT := new(testing.T)
- res := Contains(mockT, c.expected, c.actual)
-
- if res != c.result {
- if res {
- t.Errorf("Contains(%#v, %#v) should return true:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
- } else {
- t.Errorf("Contains(%#v, %#v) should return false:\n\t%#v does not contain %#v", c.expected, c.actual, c.expected, c.actual)
- }
- }
- })
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("NotContains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- mockT := new(testing.T)
- res := NotContains(mockT, c.expected, c.actual)
-
- // NotContains should be inverse of Contains. If it's not, something is wrong
- if res == Contains(mockT, c.expected, c.actual) {
- if res {
- t.Errorf("NotContains(%#v, %#v) should return true:\n\t%#v does not contains %#v", c.expected, c.actual, c.expected, c.actual)
- } else {
- t.Errorf("NotContains(%#v, %#v) should return false:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
- }
- }
- })
- }
-}
-
-func TestContainsFailMessage(t *testing.T) {
-
- mockT := new(mockTestingT)
-
- Contains(mockT, "Hello World", errors.New("Hello"))
- expectedFail := "\"Hello World\" does not contain &errors.errorString{s:\"Hello\"}"
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
- }
-}
-
-func TestContainsNotContainsOnNilValue(t *testing.T) {
- mockT := new(mockTestingT)
-
- Contains(mockT, nil, "key")
- expectedFail := "<nil> could not be applied builtin len()"
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
- }
-
- NotContains(mockT, nil, "key")
- if !strings.Contains(actualFail, expectedFail) {
- t.Errorf("Contains failure should include %q but was %q", expectedFail, actualFail)
- }
-}
-
-func TestSubsetNotSubset(t *testing.T) {
- cases := []struct {
- list interface{}
- subset interface{}
- result bool
- message string
- }{
- // cases that are expected to contain
- {[]int{1, 2, 3}, nil, true, `nil is the empty set which is a subset of every set`},
- {[]int{1, 2, 3}, []int{}, true, `[] is a subset of ['\x01' '\x02' '\x03']`},
- {[]int{1, 2, 3}, []int{1, 2}, true, `['\x01' '\x02'] is a subset of ['\x01' '\x02' '\x03']`},
- {[]int{1, 2, 3}, []int{1, 2, 3}, true, `['\x01' '\x02' '\x03'] is a subset of ['\x01' '\x02' '\x03']`},
- {[]string{"hello", "world"}, []string{"hello"}, true, `["hello"] is a subset of ["hello" "world"]`},
- {map[string]string{
- "a": "x",
- "c": "z",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "y",
- }, true, `map["a":"x" "b":"y"] is a subset of map["a":"x" "b":"y" "c":"z"]`},
-
- // cases that are expected not to contain
- {[]string{"hello", "world"}, []string{"hello", "testify"}, false, `[]string{"hello", "world"} does not contain "testify"`},
- {[]int{1, 2, 3}, []int{4, 5}, false, `[]int{1, 2, 3} does not contain 4`},
- {[]int{1, 2, 3}, []int{1, 5}, false, `[]int{1, 2, 3} does not contain 5`},
- {map[string]string{
- "a": "x",
- "c": "z",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "z",
- }, false, `map[string]string{"a":"x", "b":"y", "c":"z"} does not contain map[string]string{"a":"x", "b":"z"}`},
- {map[string]string{
- "a": "x",
- "b": "y",
- }, map[string]string{
- "a": "x",
- "b": "y",
- "c": "z",
- }, false, `map[string]string{"a":"x", "b":"y"} does not contain map[string]string{"a":"x", "b":"y", "c":"z"}`},
- }
-
- for _, c := range cases {
- t.Run("SubSet: "+c.message, func(t *testing.T) {
-
- mockT := new(mockTestingT)
- res := Subset(mockT, c.list, c.subset)
-
- if res != c.result {
- t.Errorf("Subset should return %t: %s", c.result, c.message)
- }
- if !c.result {
- expectedFail := c.message
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Log(actualFail)
- t.Errorf("Subset failure should contain %q but was %q", expectedFail, actualFail)
- }
- }
- })
- }
- for _, c := range cases {
- t.Run("NotSubSet: "+c.message, func(t *testing.T) {
- mockT := new(mockTestingT)
- res := NotSubset(mockT, c.list, c.subset)
-
- // NotSubset should match the inverse of Subset. If it doesn't, something is wrong
- if res == Subset(mockT, c.list, c.subset) {
- t.Errorf("NotSubset should return %t: %s", !c.result, c.message)
- }
- if c.result {
- expectedFail := c.message
- actualFail := mockT.errorString()
- if !strings.Contains(actualFail, expectedFail) {
- t.Log(actualFail)
- t.Errorf("NotSubset failure should contain %q but was %q", expectedFail, actualFail)
- }
- }
- })
- }
-}
-
-func TestNotSubsetNil(t *testing.T) {
- mockT := new(testing.T)
- NotSubset(mockT, []string{"foo"}, nil)
- if !mockT.Failed() {
- t.Error("NotSubset on nil set should have failed the test")
- }
-}
-
-func Test_containsElement(t *testing.T) {
-
- list1 := []string{"Foo", "Bar"}
- list2 := []int{1, 2}
- simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
-
- ok, found := containsElement("Hello World", "World")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Foo")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Bar")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list2, 1)
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list2, 2)
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(list1, "Foo!")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(list2, 3)
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(list2, "1")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(simpleMap, "Foo")
- True(t, ok)
- True(t, found)
-
- ok, found = containsElement(simpleMap, "Bar")
- True(t, ok)
- False(t, found)
-
- ok, found = containsElement(1433, "1")
- False(t, ok)
- False(t, found)
-}
-
-func TestElementsMatch(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- expected interface{}
- actual interface{}
- result bool
- }{
- // matching
- {nil, nil, true},
-
- {nil, nil, true},
- {[]int{}, []int{}, true},
- {[]int{1}, []int{1}, true},
- {[]int{1, 1}, []int{1, 1}, true},
- {[]int{1, 2}, []int{1, 2}, true},
- {[]int{1, 2}, []int{2, 1}, true},
- {[2]int{1, 2}, [2]int{2, 1}, true},
- {[]string{"hello", "world"}, []string{"world", "hello"}, true},
- {[]string{"hello", "hello"}, []string{"hello", "hello"}, true},
- {[]string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}, true},
- {[3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}, true},
- {[]int{}, nil, true},
-
- // not matching
- {[]int{1}, []int{1, 1}, false},
- {[]int{1, 2}, []int{2, 2}, false},
- {[]string{"hello", "hello"}, []string{"hello"}, false},
- }
-
- for _, c := range cases {
- t.Run(fmt.Sprintf("ElementsMatch(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
- res := ElementsMatch(mockT, c.actual, c.expected)
-
- if res != c.result {
- t.Errorf("ElementsMatch(%#v, %#v) should return %v", c.actual, c.expected, c.result)
- }
- })
- }
-}
-
-func TestDiffLists(t *testing.T) {
- tests := []struct {
- name string
- listA interface{}
- listB interface{}
- extraA []interface{}
- extraB []interface{}
- }{
- {
- name: "equal empty",
- listA: []string{},
- listB: []string{},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "equal same order",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "world"},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "equal different order",
- listA: []string{"hello", "world"},
- listB: []string{"world", "hello"},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "extra A",
- listA: []string{"hello", "hello", "world"},
- listB: []string{"hello", "world"},
- extraA: []interface{}{"hello"},
- extraB: nil,
- },
- {
- name: "extra A twice",
- listA: []string{"hello", "hello", "hello", "world"},
- listB: []string{"hello", "world"},
- extraA: []interface{}{"hello", "hello"},
- extraB: nil,
- },
- {
- name: "extra B",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "hello", "world"},
- extraA: nil,
- extraB: []interface{}{"hello"},
- },
- {
- name: "extra B twice",
- listA: []string{"hello", "world"},
- listB: []string{"hello", "hello", "world", "hello"},
- extraA: nil,
- extraB: []interface{}{"hello", "hello"},
- },
- {
- name: "integers 1",
- listA: []int{1, 2, 3, 4, 5},
- listB: []int{5, 4, 3, 2, 1},
- extraA: nil,
- extraB: nil,
- },
- {
- name: "integers 2",
- listA: []int{1, 2, 1, 2, 1},
- listB: []int{2, 1, 2, 1, 2},
- extraA: []interface{}{1},
- extraB: []interface{}{2},
- },
- }
- for _, test := range tests {
- test := test
- t.Run(test.name, func(t *testing.T) {
- actualExtraA, actualExtraB := diffLists(test.listA, test.listB)
- Equal(t, test.extraA, actualExtraA, "extra A does not match for listA=%v listB=%v",
- test.listA, test.listB)
- Equal(t, test.extraB, actualExtraB, "extra B does not match for listA=%v listB=%v",
- test.listA, test.listB)
- })
- }
-}
-
-func TestCondition(t *testing.T) {
- mockT := new(testing.T)
-
- if !Condition(mockT, func() bool { return true }, "Truth") {
- t.Error("Condition should return true")
- }
-
- if Condition(mockT, func() bool { return false }, "Lie") {
- t.Error("Condition should return false")
- }
-
-}
-
-func TestDidPanic(t *testing.T) {
-
- const panicMsg = "Panic!"
-
- if funcDidPanic, msg, _ := didPanic(func() {
- panic(panicMsg)
- }); !funcDidPanic || msg != panicMsg {
- t.Error("didPanic should return true, panicMsg")
- }
-
- if funcDidPanic, msg, _ := didPanic(func() {
- panic(nil)
- }); !funcDidPanic || msg != nil {
- t.Error("didPanic should return true, nil")
- }
-
- if funcDidPanic, _, _ := didPanic(func() {
- }); funcDidPanic {
- t.Error("didPanic should return false")
- }
-
-}
-
-func TestPanics(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !Panics(mockT, func() {
- panic("Panic!")
- }) {
- t.Error("Panics should return true")
- }
-
- if Panics(mockT, func() {
- }) {
- t.Error("Panics should return false")
- }
-
-}
-
-func TestPanicsWithValue(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !PanicsWithValue(mockT, "Panic!", func() {
- panic("Panic!")
- }) {
- t.Error("PanicsWithValue should return true")
- }
-
- if !PanicsWithValue(mockT, nil, func() {
- panic(nil)
- }) {
- t.Error("PanicsWithValue should return true")
- }
-
- if PanicsWithValue(mockT, "Panic!", func() {
- }) {
- t.Error("PanicsWithValue should return false")
- }
-
- if PanicsWithValue(mockT, "at the disco", func() {
- panic("Panic!")
- }) {
- t.Error("PanicsWithValue should return false")
- }
-}
-
-func TestPanicsWithError(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !PanicsWithError(mockT, "panic", func() {
- panic(errors.New("panic"))
- }) {
- t.Error("PanicsWithError should return true")
- }
-
- if PanicsWithError(mockT, "Panic!", func() {
- }) {
- t.Error("PanicsWithError should return false")
- }
-
- if PanicsWithError(mockT, "at the disco", func() {
- panic(errors.New("panic"))
- }) {
- t.Error("PanicsWithError should return false")
- }
-
- if PanicsWithError(mockT, "Panic!", func() {
- panic("panic")
- }) {
- t.Error("PanicsWithError should return false")
- }
-}
-
-func TestNotPanics(t *testing.T) {
-
- mockT := new(testing.T)
-
- if !NotPanics(mockT, func() {
- }) {
- t.Error("NotPanics should return true")
- }
-
- if NotPanics(mockT, func() {
- panic("Panic!")
- }) {
- t.Error("NotPanics should return false")
- }
-
-}
-
-func TestNoError(t *testing.T) {
-
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
-
- True(t, NoError(mockT, err), "NoError should return True for nil arg")
-
- // now set an error
- err = errors.New("some error")
-
- False(t, NoError(mockT, err), "NoError with error should return False")
-
- // returning an empty error interface
- err = func() error {
- var err *customError
- return err
- }()
-
- if err == nil { // err is not nil here!
- t.Errorf("Error should be nil due to empty interface: %s", err)
- }
-
- False(t, NoError(mockT, err), "NoError should fail with empty error interface")
-}
-
-type customError struct{}
-
-func (*customError) Error() string { return "fail" }
-
-func TestError(t *testing.T) {
-
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
-
- False(t, Error(mockT, err), "Error should return False for nil arg")
-
- // now set an error
- err = errors.New("some error")
-
- True(t, Error(mockT, err), "Error with error should return True")
-
- // go vet check
- True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should rturn True")
-
- // returning an empty error interface
- err = func() error {
- var err *customError
- return err
- }()
-
- if err == nil { // err is not nil here!
- t.Errorf("Error should be nil due to empty interface: %s", err)
- }
-
- True(t, Error(mockT, err), "Error should pass with empty error interface")
-}
-
-func TestEqualError(t *testing.T) {
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
- False(t, EqualError(mockT, err, ""),
- "EqualError should return false for nil arg")
-
- // now set an error
- err = errors.New("some error")
- False(t, EqualError(mockT, err, "Not some error"),
- "EqualError should return false for different error string")
- True(t, EqualError(mockT, err, "some error"),
- "EqualError should return true")
-}
-
-func TestErrorContains(t *testing.T) {
- mockT := new(testing.T)
-
- // start with a nil error
- var err error
- False(t, ErrorContains(mockT, err, ""),
- "ErrorContains should return false for nil arg")
-
- // now set an error
- err = errors.New("some error: another error")
- False(t, ErrorContains(mockT, err, "bad error"),
- "ErrorContains should return false for different error string")
- True(t, ErrorContains(mockT, err, "some error"),
- "ErrorContains should return true")
- True(t, ErrorContains(mockT, err, "another error"),
- "ErrorContains should return true")
-}
-
-func Test_isEmpty(t *testing.T) {
-
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
-
- True(t, isEmpty(""))
- True(t, isEmpty(nil))
- True(t, isEmpty([]string{}))
- True(t, isEmpty(0))
- True(t, isEmpty(int32(0)))
- True(t, isEmpty(int64(0)))
- True(t, isEmpty(false))
- True(t, isEmpty(map[string]string{}))
- True(t, isEmpty(new(time.Time)))
- True(t, isEmpty(time.Time{}))
- True(t, isEmpty(make(chan struct{})))
- True(t, isEmpty([1]int{}))
- False(t, isEmpty("something"))
- False(t, isEmpty(errors.New("something")))
- False(t, isEmpty([]string{"something"}))
- False(t, isEmpty(1))
- False(t, isEmpty(true))
- False(t, isEmpty(map[string]string{"Hello": "World"}))
- False(t, isEmpty(chWithValue))
- False(t, isEmpty([1]int{42}))
-}
-
-func TestEmpty(t *testing.T) {
-
- mockT := new(testing.T)
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
- var tiP *time.Time
- var tiNP time.Time
- var s *string
- var f *os.File
- sP := &s
- x := 1
- xP := &x
-
- type TString string
- type TStruct struct {
- x int
- }
-
- True(t, Empty(mockT, ""), "Empty string is empty")
- True(t, Empty(mockT, nil), "Nil is empty")
- True(t, Empty(mockT, []string{}), "Empty string array is empty")
- True(t, Empty(mockT, 0), "Zero int value is empty")
- True(t, Empty(mockT, false), "False value is empty")
- True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty")
- True(t, Empty(mockT, s), "Nil string pointer is empty")
- True(t, Empty(mockT, f), "Nil os.File pointer is empty")
- True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty")
- True(t, Empty(mockT, tiNP), "time.Time is empty")
- True(t, Empty(mockT, TStruct{}), "struct with zero values is empty")
- True(t, Empty(mockT, TString("")), "empty aliased string is empty")
- True(t, Empty(mockT, sP), "ptr to nil value is empty")
- True(t, Empty(mockT, [1]int{}), "array is state")
-
- False(t, Empty(mockT, "something"), "Non Empty string is not empty")
- False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty")
- False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty")
- False(t, Empty(mockT, 1), "Non-zero int value is not empty")
- False(t, Empty(mockT, true), "True value is not empty")
- False(t, Empty(mockT, chWithValue), "Channel with values is not empty")
- False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty")
- False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty")
- False(t, Empty(mockT, xP), "ptr to non-nil value is not empty")
- False(t, Empty(mockT, [1]int{42}), "array is not state")
-}
-
-func TestNotEmpty(t *testing.T) {
-
- mockT := new(testing.T)
- chWithValue := make(chan struct{}, 1)
- chWithValue <- struct{}{}
-
- False(t, NotEmpty(mockT, ""), "Empty string is empty")
- False(t, NotEmpty(mockT, nil), "Nil is empty")
- False(t, NotEmpty(mockT, []string{}), "Empty string array is empty")
- False(t, NotEmpty(mockT, 0), "Zero int value is empty")
- False(t, NotEmpty(mockT, false), "False value is empty")
- False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty")
- False(t, NotEmpty(mockT, [1]int{}), "array is state")
-
- True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty")
- True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty")
- True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty")
- True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty")
- True(t, NotEmpty(mockT, true), "True value is not empty")
- True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty")
- True(t, NotEmpty(mockT, [1]int{42}), "array is not state")
-}
-
-func Test_getLen(t *testing.T) {
- falseCases := []interface{}{
- nil,
- 0,
- true,
- false,
- 'A',
- struct{}{},
- }
- for _, v := range falseCases {
- ok, l := getLen(v)
- False(t, ok, "Expected getLen fail to get length of %#v", v)
- Equal(t, 0, l, "getLen should return 0 for %#v", v)
- }
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
- trueCases := []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 3},
- {[...]int{1, 2, 3}, 3},
- {"ABC", 3},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3},
- {ch, 3},
-
- {[]int{}, 0},
- {map[int]int{}, 0},
- {make(chan int), 0},
-
- {[]int(nil), 0},
- {map[int]int(nil), 0},
- {(chan int)(nil), 0},
- }
-
- for _, c := range trueCases {
- ok, l := getLen(c.v)
- True(t, ok, "Expected getLen success to get length of %#v", c.v)
- Equal(t, c.l, l)
- }
-}
-
-func TestLen(t *testing.T) {
- mockT := new(testing.T)
-
- False(t, Len(mockT, nil, 0), "nil does not have length")
- False(t, Len(mockT, 0, 0), "int does not have length")
- False(t, Len(mockT, true, 0), "true does not have length")
- False(t, Len(mockT, false, 0), "false does not have length")
- False(t, Len(mockT, 'A', 0), "Rune does not have length")
- False(t, Len(mockT, struct{}{}, 0), "Struct does not have length")
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
-
- cases := []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 3},
- {[...]int{1, 2, 3}, 3},
- {"ABC", 3},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3},
- {ch, 3},
-
- {[]int{}, 0},
- {map[int]int{}, 0},
- {make(chan int), 0},
-
- {[]int(nil), 0},
- {map[int]int(nil), 0},
- {(chan int)(nil), 0},
- }
-
- for _, c := range cases {
- True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
- }
-
- cases = []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 4},
- {[...]int{1, 2, 3}, 2},
- {"ABC", 2},
- {map[int]int{1: 2, 2: 4, 3: 6}, 4},
- {ch, 2},
-
- {[]int{}, 1},
- {map[int]int{}, 1},
- {make(chan int), 1},
-
- {[]int(nil), 1},
- {map[int]int(nil), 1},
- {(chan int)(nil), 1},
- }
-
- for _, c := range cases {
- False(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l)
- }
-}
-
-func TestWithinDuration(t *testing.T) {
-
- mockT := new(testing.T)
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
- True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
-
- False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
-
- False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
-
- False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
- False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
-}
-
-func TestWithinRange(t *testing.T) {
-
- mockT := new(testing.T)
- n := time.Now()
- s := n.Add(-time.Second)
- e := n.Add(time.Second)
-
- True(t, WithinRange(mockT, n, n, n), "Exact same actual, start, and end values return true")
-
- True(t, WithinRange(mockT, n, s, e), "Time in range is within the time range")
- True(t, WithinRange(mockT, s, s, e), "The start time is within the time range")
- True(t, WithinRange(mockT, e, s, e), "The end time is within the time range")
-
- False(t, WithinRange(mockT, s.Add(-time.Nanosecond), s, e, "Just before the start time is not within the time range"))
- False(t, WithinRange(mockT, e.Add(time.Nanosecond), s, e, "Just after the end time is not within the time range"))
-
- False(t, WithinRange(mockT, n, e, s, "Just after the end time is not within the time range"))
-}
-
-func TestInDelta(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
- True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
- True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1")
- False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
- False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
- False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail")
- False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail")
- False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail")
- True(t, InDelta(mockT, math.NaN(), math.NaN(), 0.01), "Expected NaN for both to pass")
-
- cases := []struct {
- a, b interface{}
- delta float64
- }{
- {uint(2), uint(1), 1},
- {uint8(2), uint8(1), 1},
- {uint16(2), uint16(1), 1},
- {uint32(2), uint32(1), 1},
- {uint64(2), uint64(1), 1},
-
- {int(2), int(1), 1},
- {int8(2), int8(1), 1},
- {int16(2), int16(1), 1},
- {int32(2), int32(1), 1},
- {int64(2), int64(1), 1},
-
- {float32(2), float32(1), 1},
- {float64(2), float64(1), 1},
- }
-
- for _, tc := range cases {
- True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
- }
-}
-
-func TestInDeltaSlice(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InDeltaSlice(mockT,
- []float64{1.001, math.NaN(), 0.999},
- []float64{1, math.NaN(), 1},
- 0.1), "{1.001, NaN, 0.009} is element-wise close to {1, NaN, 1} in delta=0.1")
-
- True(t, InDeltaSlice(mockT,
- []float64{1, math.NaN(), 2},
- []float64{0, math.NaN(), 3},
- 1), "{1, NaN, 2} is element-wise close to {0, NaN, 3} in delta=1")
-
- False(t, InDeltaSlice(mockT,
- []float64{1, math.NaN(), 2},
- []float64{0, math.NaN(), 3},
- 0.1), "{1, NaN, 2} is not element-wise close to {0, NaN, 3} in delta=0.1")
-
- False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
-}
-
-func TestInDeltaMapValues(t *testing.T) {
- mockT := new(testing.T)
-
- for _, tc := range []struct {
- title string
- expect interface{}
- actual interface{}
- f func(TestingT, bool, ...interface{}) bool
- delta float64
- }{
- {
- title: "Within delta",
- expect: map[string]float64{
- "foo": 1.0,
- "bar": 2.0,
- "baz": math.NaN(),
- },
- actual: map[string]float64{
- "foo": 1.01,
- "bar": 1.99,
- "baz": math.NaN(),
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "Within delta",
- expect: map[int]float64{
- 1: 1.0,
- 2: 2.0,
- },
- actual: map[int]float64{
- 1: 1.0,
- 2: 1.99,
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "Different number of keys",
- expect: map[int]float64{
- 1: 1.0,
- 2: 2.0,
- },
- actual: map[int]float64{
- 1: 1.0,
- },
- delta: 0.1,
- f: False,
- },
- {
- title: "Within delta with zero value",
- expect: map[string]float64{
- "zero": 0,
- },
- actual: map[string]float64{
- "zero": 0,
- },
- delta: 0.1,
- f: True,
- },
- {
- title: "With missing key with zero value",
- expect: map[string]float64{
- "zero": 0,
- "foo": 0,
- },
- actual: map[string]float64{
- "zero": 0,
- "bar": 0,
- },
- f: False,
- },
- } {
- tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual))
- }
-}
-
-func TestInEpsilon(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), uint16(2), .001},
- {2.1, 2.2, 0.1},
- {2.2, 2.1, 0.1},
- {-2.1, -2.2, 0.1},
- {-2.2, -2.1, 0.1},
- {uint64(100), uint8(101), 0.01},
- {0.1, -0.1, 2},
- {0.1, 0, 2},
- {math.NaN(), math.NaN(), 1},
- {time.Second, time.Second + time.Millisecond, 0.002},
- }
-
- for _, tc := range cases {
- True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc)
- }
-
- cases = []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), int16(-2), .001},
- {uint64(100), uint8(102), 0.01},
- {2.1, 2.2, 0.001},
- {2.2, 2.1, 0.001},
- {2.1, -2.2, 1},
- {2.1, "bla-bla", 0},
- {0.1, -0.1, 1.99},
- {0, 0.1, 2}, // expected must be different to zero
- {time.Second, time.Second + 10*time.Millisecond, 0.002},
- {math.NaN(), 0, 1},
- {0, math.NaN(), 1},
- {0, 0, math.NaN()},
- }
-
- for _, tc := range cases {
- False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-
-}
-
-func TestInEpsilonSlice(t *testing.T) {
- mockT := new(testing.T)
-
- True(t, InEpsilonSlice(mockT,
- []float64{2.2, math.NaN(), 2.0},
- []float64{2.1, math.NaN(), 2.1},
- 0.06), "{2.2, NaN, 2.0} is element-wise close to {2.1, NaN, 2.1} in espilon=0.06")
-
- False(t, InEpsilonSlice(mockT,
- []float64{2.2, 2.0},
- []float64{2.1, 2.1},
- 0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in espilon=0.04")
-
- False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail")
-}
-
-func TestRegexp(t *testing.T) {
- mockT := new(testing.T)
-
- cases := []struct {
- rx, str string
- }{
- {"^start", "start of the line"},
- {"end$", "in the end"},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
- }
-
- for _, tc := range cases {
- True(t, Regexp(mockT, tc.rx, tc.str))
- True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- False(t, NotRegexp(mockT, tc.rx, tc.str))
- False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- }
-
- cases = []struct {
- rx, str string
- }{
- {"^asdfastart", "Not the start of the line"},
- {"end$", "in the end."},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
- }
-
- for _, tc := range cases {
- False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
- False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- True(t, NotRegexp(mockT, tc.rx, tc.str))
- True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str))
- }
-}
-
-func testAutogeneratedFunction() {
- defer func() {
- if err := recover(); err == nil {
- panic("did not panic")
- }
- CallerInfo()
- }()
- t := struct {
- io.Closer
- }{}
- c := t
- c.Close()
-}
-
-func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) {
- NotPanics(t, func() {
- testAutogeneratedFunction()
- })
-}
-
-func TestZero(t *testing.T) {
- mockT := new(testing.T)
-
- for _, test := range zeros {
- True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-
- for _, test := range nonZeros {
- False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-}
-
-func TestNotZero(t *testing.T) {
- mockT := new(testing.T)
-
- for _, test := range zeros {
- False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-
- for _, test := range nonZeros {
- True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test)))
- }
-}
-
-func TestFileExists(t *testing.T) {
- mockT := new(testing.T)
- True(t, FileExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- False(t, FileExists(mockT, "random_file"))
-
- mockT = new(testing.T)
- False(t, FileExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, FileExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_file")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, FileExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestNoFileExists(t *testing.T) {
- mockT := new(testing.T)
- False(t, NoFileExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- True(t, NoFileExists(mockT, "non_existent_file"))
-
- mockT = new(testing.T)
- True(t, NoFileExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, NoFileExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_file")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, NoFileExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func getTempSymlinkPath(file string) (string, error) {
- link := file + "_symlink"
- err := os.Symlink(file, link)
- return link, err
-}
-
-func cleanUpTempFiles(paths []string) []error {
- var res []error
- for _, path := range paths {
- err := os.Remove(path)
- if err != nil {
- res = append(res, err)
- }
- }
- return res
-}
-
-func TestDirExists(t *testing.T) {
- mockT := new(testing.T)
- False(t, DirExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- False(t, DirExists(mockT, "non_existent_dir"))
-
- mockT = new(testing.T)
- True(t, DirExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, DirExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_dir")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- False(t, DirExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestNoDirExists(t *testing.T) {
- mockT := new(testing.T)
- True(t, NoDirExists(mockT, "assertions.go"))
-
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, "non_existent_dir"))
-
- mockT = new(testing.T)
- False(t, NoDirExists(mockT, "../_codegen"))
-
- var tempFiles []string
-
- link, err := getTempSymlinkPath("assertions.go")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, link))
-
- link, err = getTempSymlinkPath("non_existent_dir")
- if err != nil {
- t.Fatal("could not create temp symlink, err:", err)
- }
- tempFiles = append(tempFiles, link)
- mockT = new(testing.T)
- True(t, NoDirExists(mockT, link))
-
- errs := cleanUpTempFiles(tempFiles)
- if len(errs) > 0 {
- t.Fatal("could not clean up temporary files")
- }
-}
-
-func TestJSONEq_EqualSONString(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`))
-}
-
-func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}"))
-}
-
-func TestJSONEq_Array(t *testing.T) {
- mockT := new(testing.T)
- True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`))
-}
-
-func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`))
-}
-
-func TestJSONEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_ActualIsNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON"))
-}
-
-func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, "Not JSON", "Not JSON"))
-}
-
-func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(testing.T)
- False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`))
-}
-
-func TestYAMLEq_EqualYAMLString(t *testing.T) {
- mockT := new(testing.T)
- True(t, YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`))
-}
-
-func TestYAMLEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(testing.T)
- True(t, YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestYAMLEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(testing.T)
- expected := `
-numeric: 1.5
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-`
-
- actual := `
-numeric: 1.5
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-`
- True(t, YAMLEq(mockT, expected, actual))
-}
-
-func TestYAMLEq_Array(t *testing.T) {
- mockT := new(testing.T)
- True(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`))
-}
-
-func TestYAMLEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`))
-}
-
-func TestYAMLEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(testing.T)
- False(t, YAMLEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestYAMLEq_ActualIsSimpleString(t *testing.T) {
- mockT := new(testing.T)
- False(t, YAMLEq(mockT, `{"foo": "bar"}`, "Simple String"))
-}
-
-func TestYAMLEq_ExpectedIsSimpleString(t *testing.T) {
- mockT := new(testing.T)
- False(t, YAMLEq(mockT, "Simple String", `{"foo": "bar", "hello": "world"}`))
-}
-
-func TestYAMLEq_ExpectedAndActualSimpleString(t *testing.T) {
- mockT := new(testing.T)
- True(t, YAMLEq(mockT, "Simple String", "Simple String"))
-}
-
-func TestYAMLEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(testing.T)
- False(t, YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`))
-}
-
-type diffTestingStruct struct {
- A string
- B int
-}
-
-func (d *diffTestingStruct) String() string {
- return d.A
-}
-
-func TestDiff(t *testing.T) {
- expected := `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,3 +1,3 @@
- (struct { foo string }) {
-- foo: (string) (len=5) "hello"
-+ foo: (string) (len=3) "bar"
- }
-`
- actual := diff(
- struct{ foo string }{"hello"},
- struct{ foo string }{"bar"},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,5 +2,5 @@
- (int) 1,
-- (int) 2,
- (int) 3,
-- (int) 4
-+ (int) 5,
-+ (int) 7
- }
-`
- actual = diff(
- []int{1, 2, 3, 4},
- []int{1, 3, 5, 7},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,4 +2,4 @@
- (int) 1,
-- (int) 2,
-- (int) 3
-+ (int) 3,
-+ (int) 5
- }
-`
- actual = diff(
- []int{1, 2, 3, 4}[0:3],
- []int{1, 3, 5, 7}[0:3],
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,6 +1,6 @@
- (map[string]int) (len=4) {
-- (string) (len=4) "four": (int) 4,
-+ (string) (len=4) "five": (int) 5,
- (string) (len=3) "one": (int) 1,
-- (string) (len=5) "three": (int) 3,
-- (string) (len=3) "two": (int) 2
-+ (string) (len=5) "seven": (int) 7,
-+ (string) (len=5) "three": (int) 3
- }
-`
-
- actual = diff(
- map[string]int{"one": 1, "two": 2, "three": 3, "four": 4},
- map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,3 +1,3 @@
- (*errors.errorString)({
-- s: (string) (len=19) "some expected error"
-+ s: (string) (len=12) "actual error"
- })
-`
-
- actual = diff(
- errors.New("some expected error"),
- errors.New("actual error"),
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -2,3 +2,3 @@
- A: (string) (len=11) "some string",
-- B: (int) 10
-+ B: (int) 15
- }
-`
-
- actual = diff(
- diffTestingStruct{A: "some string", B: 10},
- diffTestingStruct{A: "some string", B: 15},
- )
- Equal(t, expected, actual)
-
- expected = `
-
-Diff:
---- Expected
-+++ Actual
-@@ -1,2 +1,2 @@
--(time.Time) 2020-09-24 00:00:00 +0000 UTC
-+(time.Time) 2020-09-25 00:00:00 +0000 UTC
-
-`
-
- actual = diff(
- time.Date(2020, 9, 24, 0, 0, 0, 0, time.UTC),
- time.Date(2020, 9, 25, 0, 0, 0, 0, time.UTC),
- )
- Equal(t, expected, actual)
-}
-
-func TestTimeEqualityErrorFormatting(t *testing.T) {
- mockT := new(mockTestingT)
-
- Equal(mockT, time.Second*2, time.Millisecond)
-
- expectedErr := "\\s+Error Trace:\\s+Error:\\s+Not equal:\\s+\n\\s+expected: 2s\n\\s+actual\\s+: 1ms\n"
- Regexp(t, regexp.MustCompile(expectedErr), mockT.errorString())
-}
-
-func TestDiffEmptyCases(t *testing.T) {
- Equal(t, "", diff(nil, nil))
- Equal(t, "", diff(struct{ foo string }{}, nil))
- Equal(t, "", diff(nil, struct{ foo string }{}))
- Equal(t, "", diff(1, 2))
- Equal(t, "", diff(1, 2))
- Equal(t, "", diff([]int{1}, []bool{true}))
-}
-
-// Ensure there are no data races
-func TestDiffRace(t *testing.T) {
- t.Parallel()
-
- expected := map[string]string{
- "a": "A",
- "b": "B",
- "c": "C",
- }
-
- actual := map[string]string{
- "d": "D",
- "e": "E",
- "f": "F",
- }
-
- // run diffs in parallel simulating tests with t.Parallel()
- numRoutines := 10
- rChans := make([]chan string, numRoutines)
- for idx := range rChans {
- rChans[idx] = make(chan string)
- go func(ch chan string) {
- defer close(ch)
- ch <- diff(expected, actual)
- }(rChans[idx])
- }
-
- for _, ch := range rChans {
- for msg := range ch {
- NotZero(t, msg) // dummy assert
- }
- }
-}
-
-type mockTestingT struct {
- errorFmt string
- args []interface{}
-}
-
-func (m *mockTestingT) errorString() string {
- return fmt.Sprintf(m.errorFmt, m.args...)
-}
-
-func (m *mockTestingT) Errorf(format string, args ...interface{}) {
- m.errorFmt = format
- m.args = args
-}
-
-func TestFailNowWithPlainTestingT(t *testing.T) {
- mockT := &mockTestingT{}
-
- Panics(t, func() {
- FailNow(mockT, "failed")
- }, "should panic since mockT is missing FailNow()")
-}
-
-type mockFailNowTestingT struct {
-}
-
-func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {}
-
-func (m *mockFailNowTestingT) FailNow() {}
-
-func TestFailNowWithFullTestingT(t *testing.T) {
- mockT := &mockFailNowTestingT{}
-
- NotPanics(t, func() {
- FailNow(mockT, "failed")
- }, "should call mockT.FailNow() rather than panicking")
-}
-
-func TestBytesEqual(t *testing.T) {
- var cases = []struct {
- a, b []byte
- }{
- {make([]byte, 2), make([]byte, 2)},
- {make([]byte, 2), make([]byte, 2, 3)},
- {nil, make([]byte, 0)},
- }
- for i, c := range cases {
- Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1)
- }
-}
-
-func BenchmarkBytesEqual(b *testing.B) {
- const size = 1024 * 8
- s := make([]byte, size)
- for i := range s {
- s[i] = byte(i % 255)
- }
- s2 := make([]byte, size)
- copy(s2, s)
-
- mockT := &mockFailNowTestingT{}
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- Equal(mockT, s, s2)
- }
-}
-
-func BenchmarkNotNil(b *testing.B) {
- for i := 0; i < b.N; i++ {
- NotNil(b, b)
- }
-}
-
-func ExampleComparisonAssertionFunc() {
- t := &testing.T{} // provided by test
-
- adder := func(x, y int) int {
- return x + y
- }
-
- type args struct {
- x int
- y int
- }
-
- tests := []struct {
- name string
- args args
- expect int
- assertion ComparisonAssertionFunc
- }{
- {"2+2=4", args{2, 2}, 4, Equal},
- {"2+2!=5", args{2, 2}, 5, NotEqual},
- {"2+3==5", args{2, 3}, 5, Exactly},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
- })
- }
-}
-
-func TestComparisonAssertionFunc(t *testing.T) {
- type iface interface {
- Name() string
- }
-
- tests := []struct {
- name string
- expect interface{}
- got interface{}
- assertion ComparisonAssertionFunc
- }{
- {"implements", (*iface)(nil), t, Implements},
- {"isType", (*testing.T)(nil), t, IsType},
- {"equal", t, t, Equal},
- {"equalValues", t, t, EqualValues},
- {"notEqualValues", t, nil, NotEqualValues},
- {"exactly", t, t, Exactly},
- {"notEqual", t, nil, NotEqual},
- {"notContains", []int{1, 2, 3}, 4, NotContains},
- {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
- {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
- {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
- {"regexp", "^t.*y$", "testify", Regexp},
- {"notRegexp", "^t.*y$", "Testify", NotRegexp},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, tt.got)
- })
- }
-}
-
-func ExampleValueAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParse := func(input string) interface{} {
- var x interface{}
- _ = json.Unmarshal([]byte(input), &x)
- return x
- }
-
- tests := []struct {
- name string
- arg string
- assertion ValueAssertionFunc
- }{
- {"true is not nil", "true", NotNil},
- {"empty string is nil", "", Nil},
- {"zero is not nil", "0", NotNil},
- {"zero is zero", "0", Zero},
- {"false is zero", "false", Zero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, dumbParse(tt.arg))
- })
- }
-}
-
-func TestValueAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value interface{}
- assertion ValueAssertionFunc
- }{
- {"notNil", true, NotNil},
- {"nil", nil, Nil},
- {"empty", []int{}, Empty},
- {"notEmpty", []int{1}, NotEmpty},
- {"zero", false, Zero},
- {"notZero", 42, NotZero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleBoolAssertionFunc() {
- t := &testing.T{} // provided by test
-
- isOkay := func(x int) bool {
- return x >= 42
- }
-
- tests := []struct {
- name string
- arg int
- assertion BoolAssertionFunc
- }{
- {"-1 is bad", -1, False},
- {"42 is good", 42, True},
- {"41 is bad", 41, False},
- {"45 is cool", 45, True},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, isOkay(tt.arg))
- })
- }
-}
-
-func TestBoolAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value bool
- assertion BoolAssertionFunc
- }{
- {"true", true, True},
- {"false", false, False},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleErrorAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParseNum := func(input string, v interface{}) error {
- return json.Unmarshal([]byte(input), v)
- }
-
- tests := []struct {
- name string
- arg string
- assertion ErrorAssertionFunc
- }{
- {"1.2 is number", "1.2", NoError},
- {"1.2.3 not number", "1.2.3", Error},
- {"true is not number", "true", Error},
- {"3 is number", "3", NoError},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var x float64
- tt.assertion(t, dumbParseNum(tt.arg, &x))
- })
- }
-}
-
-func TestErrorAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- err error
- assertion ErrorAssertionFunc
- }{
- {"noError", nil, NoError},
- {"error", errors.New("whoops"), Error},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.err)
- })
- }
-}
-
-func TestEventuallyFalse(t *testing.T) {
- mockT := new(testing.T)
-
- condition := func() bool {
- return false
- }
-
- False(t, Eventually(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-func TestEventuallyTrue(t *testing.T) {
- state := 0
- condition := func() bool {
- defer func() {
- state += 1
- }()
- return state == 2
- }
-
- True(t, Eventually(t, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-func TestNeverFalse(t *testing.T) {
- condition := func() bool {
- return false
- }
-
- True(t, Never(t, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-func TestNeverTrue(t *testing.T) {
- mockT := new(testing.T)
- state := 0
- condition := func() bool {
- defer func() {
- state = state + 1
- }()
- return state == 2
- }
-
- False(t, Never(mockT, condition, 100*time.Millisecond, 20*time.Millisecond))
-}
-
-func TestEventuallyIssue805(t *testing.T) {
- mockT := new(testing.T)
-
- NotPanics(t, func() {
- condition := func() bool { <-time.After(time.Millisecond); return true }
- False(t, Eventually(mockT, condition, time.Millisecond, time.Microsecond))
- })
-}
-
-func Test_validateEqualArgs(t *testing.T) {
- if validateEqualArgs(func() {}, func() {}) == nil {
- t.Error("non-nil functions should error")
- }
-
- if validateEqualArgs(func() {}, func() {}) == nil {
- t.Error("non-nil functions should error")
- }
-
- if validateEqualArgs(nil, nil) != nil {
- t.Error("nil functions are equal")
- }
-}
-
-func Test_truncatingFormat(t *testing.T) {
-
- original := strings.Repeat("a", bufio.MaxScanTokenSize-102)
- result := truncatingFormat(original)
- Equal(t, fmt.Sprintf("%#v", original), result, "string should not be truncated")
-
- original = original + "x"
- result = truncatingFormat(original)
- NotEqual(t, fmt.Sprintf("%#v", original), result, "string should have been truncated.")
-
- if !strings.HasSuffix(result, "<... truncated>") {
- t.Error("truncated string should have <... truncated> suffix")
- }
-}
-
-func TestErrorIs(t *testing.T) {
- mockT := new(testing.T)
- tests := []struct {
- err error
- target error
- result bool
- }{
- {io.EOF, io.EOF, true},
- {fmt.Errorf("wrap: %w", io.EOF), io.EOF, true},
- {io.EOF, io.ErrClosedPipe, false},
- {nil, io.EOF, false},
- {io.EOF, nil, false},
- {nil, nil, true},
- }
- for _, tt := range tests {
- tt := tt
- t.Run(fmt.Sprintf("ErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
- res := ErrorIs(mockT, tt.err, tt.target)
- if res != tt.result {
- t.Errorf("ErrorIs(%#v,%#v) should return %t", tt.err, tt.target, tt.result)
- }
- })
- }
-}
-
-func TestNotErrorIs(t *testing.T) {
- mockT := new(testing.T)
- tests := []struct {
- err error
- target error
- result bool
- }{
- {io.EOF, io.EOF, false},
- {fmt.Errorf("wrap: %w", io.EOF), io.EOF, false},
- {io.EOF, io.ErrClosedPipe, true},
- {nil, io.EOF, true},
- {io.EOF, nil, true},
- {nil, nil, false},
- }
- for _, tt := range tests {
- tt := tt
- t.Run(fmt.Sprintf("NotErrorIs(%#v,%#v)", tt.err, tt.target), func(t *testing.T) {
- res := NotErrorIs(mockT, tt.err, tt.target)
- if res != tt.result {
- t.Errorf("NotErrorIs(%#v,%#v) should return %t", tt.err, tt.target, tt.result)
- }
- })
- }
-}
-
-func TestErrorAs(t *testing.T) {
- mockT := new(testing.T)
- tests := []struct {
- err error
- result bool
- }{
- {fmt.Errorf("wrap: %w", &customError{}), true},
- {io.EOF, false},
- {nil, false},
- }
- for _, tt := range tests {
- tt := tt
- var target *customError
- t.Run(fmt.Sprintf("ErrorAs(%#v,%#v)", tt.err, target), func(t *testing.T) {
- res := ErrorAs(mockT, tt.err, &target)
- if res != tt.result {
- t.Errorf("ErrorAs(%#v,%#v) should return %t)", tt.err, target, tt.result)
- }
- })
- }
-}
-
-func TestIsNil(t *testing.T) {
- var n unsafe.Pointer = nil
- if !isNil(n) {
- t.Fatal("fail")
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/doc.go
deleted file mode 100644
index c9dccc4d6cd0aad89a9ecf638d8cde1ea043a37a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/doc.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
-//
-// Example Usage
-//
-// The following is a complete example using assert in a standard test function:
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// )
-//
-// func TestSomething(t *testing.T) {
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// assert.Equal(t, a, b, "The two words should be the same.")
-//
-// }
-//
-// if you assert many times, use the format below:
-//
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// )
-//
-// func TestSomething(t *testing.T) {
-// assert := assert.New(t)
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// assert.Equal(a, b, "The two words should be the same.")
-// }
-//
-// Assertions
-//
-// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
-// All assertion functions take, as the first argument, the `*testing.T` object provided by the
-// testing framework. This allows the assertion funcs to write the failings and other details to
-// the correct place.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package assert
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/errors.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/errors.go
deleted file mode 100644
index ac9dc9d1d6156b64c31ac0b130e7a2b1ca86f06d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/errors.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package assert
-
-import (
- "errors"
-)
-
-// AnError is an error instance useful for testing. If the code does not care
-// about error specifics, and only needs to return the error for example, this
-// error should be used to make the test code more readable.
-var AnError = errors.New("assert.AnError general error for testing")
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions.go
deleted file mode 100644
index df189d2348f17a3d16888e2581d2a3b7a9d47e93..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package assert
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
- t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
- return &Assertions{
- t: t,
- }
-}
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs"
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions_test.go
deleted file mode 100644
index 496d3c0db78704e6d6b9af20bca666f475e44619..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/forward_assertions_test.go
+++ /dev/null
@@ -1,752 +0,0 @@
-package assert
-
-import (
- "errors"
- "regexp"
- "testing"
- "time"
-)
-
-func TestImplementsWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) {
- t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface")
- }
- if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) {
- t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface")
- }
-}
-
-func TestIsTypeWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) {
- t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject")
- }
- if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) {
- t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject")
- }
-
-}
-
-func TestEqualWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Equal("Hello World", "Hello World") {
- t.Error("Equal should return true")
- }
- if !assert.Equal(123, 123) {
- t.Error("Equal should return true")
- }
- if !assert.Equal(123.5, 123.5) {
- t.Error("Equal should return true")
- }
- if !assert.Equal([]byte("Hello World"), []byte("Hello World")) {
- t.Error("Equal should return true")
- }
- if !assert.Equal(nil, nil) {
- t.Error("Equal should return true")
- }
-}
-
-func TestEqualValuesWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.EqualValues(uint32(10), int32(10)) {
- t.Error("EqualValues should return true")
- }
-}
-
-func TestNotNilWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.NotNil(new(AssertionTesterConformingObject)) {
- t.Error("NotNil should return true: object is not nil")
- }
- if assert.NotNil(nil) {
- t.Error("NotNil should return false: object is nil")
- }
-
-}
-
-func TestNilWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.Nil(nil) {
- t.Error("Nil should return true: object is nil")
- }
- if assert.Nil(new(AssertionTesterConformingObject)) {
- t.Error("Nil should return false: object is not nil")
- }
-
-}
-
-func TestTrueWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.True(true) {
- t.Error("True should return true")
- }
- if assert.True(false) {
- t.Error("True should return false")
- }
-
-}
-
-func TestFalseWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- if !assert.False(false) {
- t.Error("False should return true")
- }
- if assert.False(true) {
- t.Error("False should return false")
- }
-
-}
-
-func TestExactlyWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- a := float32(1)
- b := float64(1)
- c := float32(1)
- d := float32(2)
-
- if assert.Exactly(a, b) {
- t.Error("Exactly should return false")
- }
- if assert.Exactly(a, d) {
- t.Error("Exactly should return false")
- }
- if !assert.Exactly(a, c) {
- t.Error("Exactly should return true")
- }
-
- if assert.Exactly(nil, a) {
- t.Error("Exactly should return false")
- }
- if assert.Exactly(a, nil) {
- t.Error("Exactly should return false")
- }
-
-}
-
-func TestNotEqualWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotEqual("Hello World", "Hello World!") {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(123, 1234) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(123.5, 123.55) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) {
- t.Error("NotEqual should return true")
- }
- if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) {
- t.Error("NotEqual should return true")
- }
-}
-
-func TestNotEqualValuesWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotEqualValues("Hello World", "Hello World!") {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(123, 1234) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(123.5, 123.55) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues([]byte("Hello World"), []byte("Hello World!")) {
- t.Error("NotEqualValues should return true")
- }
- if !assert.NotEqualValues(nil, new(AssertionTesterConformingObject)) {
- t.Error("NotEqualValues should return true")
- }
- if assert.NotEqualValues(10, uint(10)) {
- t.Error("NotEqualValues should return false")
- }
-}
-
-func TestContainsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
- list := []string{"Foo", "Bar"}
-
- if !assert.Contains("Hello World", "Hello") {
- t.Error("Contains should return true: \"Hello World\" contains \"Hello\"")
- }
- if assert.Contains("Hello World", "Salut") {
- t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"")
- }
-
- if !assert.Contains(list, "Foo") {
- t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
- }
- if assert.Contains(list, "Salut") {
- t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"")
- }
-
-}
-
-func TestNotContainsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
- list := []string{"Foo", "Bar"}
-
- if !assert.NotContains("Hello World", "Hello!") {
- t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"")
- }
- if assert.NotContains("Hello World", "Hello") {
- t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"")
- }
-
- if !assert.NotContains(list, "Foo!") {
- t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"")
- }
- if assert.NotContains(list, "Foo") {
- t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"")
- }
-
-}
-
-func TestConditionWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.Condition(func() bool { return true }, "Truth") {
- t.Error("Condition should return true")
- }
-
- if assert.Condition(func() bool { return false }, "Lie") {
- t.Error("Condition should return false")
- }
-
-}
-
-func TestDidPanicWrapper(t *testing.T) {
-
- if funcDidPanic, _, _ := didPanic(func() {
- panic("Panic!")
- }); !funcDidPanic {
- t.Error("didPanic should return true")
- }
-
- if funcDidPanic, _, _ := didPanic(func() {
- }); funcDidPanic {
- t.Error("didPanic should return false")
- }
-
-}
-
-func TestPanicsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.Panics(func() {
- panic("Panic!")
- }) {
- t.Error("Panics should return true")
- }
-
- if assert.Panics(func() {
- }) {
- t.Error("Panics should return false")
- }
-
-}
-
-func TestNotPanicsWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- if !assert.NotPanics(func() {
- }) {
- t.Error("NotPanics should return true")
- }
-
- if assert.NotPanics(func() {
- panic("Panic!")
- }) {
- t.Error("NotPanics should return false")
- }
-
-}
-
-func TestNoErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
-
- assert.True(mockAssert.NoError(err), "NoError should return True for nil arg")
-
- // now set an error
- err = errors.New("Some error")
-
- assert.False(mockAssert.NoError(err), "NoError with error should return False")
-
-}
-
-func TestErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
-
- assert.False(mockAssert.Error(err), "Error should return False for nil arg")
-
- // now set an error
- err = errors.New("Some error")
-
- assert.True(mockAssert.Error(err), "Error with error should return True")
-
-}
-
-func TestErrorContainsWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
- assert.False(mockAssert.ErrorContains(err, ""),
- "ErrorContains should return false for nil arg")
-
- // now set an error
- err = errors.New("some error: another error")
- assert.False(mockAssert.ErrorContains(err, "different error"),
- "ErrorContains should return false for different error string")
- assert.True(mockAssert.ErrorContains(err, "some error"),
- "ErrorContains should return true")
- assert.True(mockAssert.ErrorContains(err, "another error"),
- "ErrorContains should return true")
-}
-
-func TestEqualErrorWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- // start with a nil error
- var err error
- assert.False(mockAssert.EqualError(err, ""),
- "EqualError should return false for nil arg")
-
- // now set an error
- err = errors.New("some error")
- assert.False(mockAssert.EqualError(err, "Not some error"),
- "EqualError should return false for different error string")
- assert.True(mockAssert.EqualError(err, "some error"),
- "EqualError should return true")
-}
-
-func TestEmptyWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.True(mockAssert.Empty(""), "Empty string is empty")
- assert.True(mockAssert.Empty(nil), "Nil is empty")
- assert.True(mockAssert.Empty([]string{}), "Empty string array is empty")
- assert.True(mockAssert.Empty(0), "Zero int value is empty")
- assert.True(mockAssert.Empty(false), "False value is empty")
-
- assert.False(mockAssert.Empty("something"), "Non Empty string is not empty")
- assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty")
- assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty")
- assert.False(mockAssert.Empty(1), "Non-zero int value is not empty")
- assert.False(mockAssert.Empty(true), "True value is not empty")
-
-}
-
-func TestNotEmptyWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.False(mockAssert.NotEmpty(""), "Empty string is empty")
- assert.False(mockAssert.NotEmpty(nil), "Nil is empty")
- assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty")
- assert.False(mockAssert.NotEmpty(0), "Zero int value is empty")
- assert.False(mockAssert.NotEmpty(false), "False value is empty")
-
- assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty")
- assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty")
- assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty")
- assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty")
- assert.True(mockAssert.NotEmpty(true), "True value is not empty")
-
-}
-
-func TestLenWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.False(mockAssert.Len(nil, 0), "nil does not have length")
- assert.False(mockAssert.Len(0, 0), "int does not have length")
- assert.False(mockAssert.Len(true, 0), "true does not have length")
- assert.False(mockAssert.Len(false, 0), "false does not have length")
- assert.False(mockAssert.Len('A', 0), "Rune does not have length")
- assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length")
-
- ch := make(chan int, 5)
- ch <- 1
- ch <- 2
- ch <- 3
-
- cases := []struct {
- v interface{}
- l int
- }{
- {[]int{1, 2, 3}, 3},
- {[...]int{1, 2, 3}, 3},
- {"ABC", 3},
- {map[int]int{1: 2, 2: 4, 3: 6}, 3},
- {ch, 3},
-
- {[]int{}, 0},
- {map[int]int{}, 0},
- {make(chan int), 0},
-
- {[]int(nil), 0},
- {map[int]int(nil), 0},
- {(chan int)(nil), 0},
- }
-
- for _, c := range cases {
- assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l)
- }
-}
-
-func TestWithinDurationWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference")
- assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference")
-
- assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference")
- assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference")
-}
-
-func TestInDeltaWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01")
- True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01")
- True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1")
- False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail")
- False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail")
- False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail")
-
- cases := []struct {
- a, b interface{}
- delta float64
- }{
- {uint8(2), uint8(1), 1},
- {uint16(2), uint16(1), 1},
- {uint32(2), uint32(1), 1},
- {uint64(2), uint64(1), 1},
-
- {int(2), int(1), 1},
- {int8(2), int8(1), 1},
- {int16(2), int16(1), 1},
- {int32(2), int32(1), 1},
- {int64(2), int64(1), 1},
-
- {float32(2), float32(1), 1},
- {float64(2), float64(1), 1},
- }
-
- for _, tc := range cases {
- True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta)
- }
-}
-
-func TestInEpsilonWrapper(t *testing.T) {
- assert := New(new(testing.T))
-
- cases := []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), uint16(2), .001},
- {2.1, 2.2, 0.1},
- {2.2, 2.1, 0.1},
- {-2.1, -2.2, 0.1},
- {-2.2, -2.1, 0.1},
- {uint64(100), uint8(101), 0.01},
- {0.1, -0.1, 2},
- }
-
- for _, tc := range cases {
- True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-
- cases = []struct {
- a, b interface{}
- epsilon float64
- }{
- {uint8(2), int16(-2), .001},
- {uint64(100), uint8(102), 0.01},
- {2.1, 2.2, 0.001},
- {2.2, 2.1, 0.001},
- {2.1, -2.2, 1},
- {2.1, "bla-bla", 0},
- {0.1, -0.1, 1.99},
- }
-
- for _, tc := range cases {
- False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon))
- }
-}
-
-func TestRegexpWrapper(t *testing.T) {
-
- assert := New(new(testing.T))
-
- cases := []struct {
- rx, str string
- }{
- {"^start", "start of the line"},
- {"end$", "in the end"},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"},
- }
-
- for _, tc := range cases {
- True(t, assert.Regexp(tc.rx, tc.str))
- True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
- False(t, assert.NotRegexp(tc.rx, tc.str))
- False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
- }
-
- cases = []struct {
- rx, str string
- }{
- {"^asdfastart", "Not the start of the line"},
- {"end$", "in the end."},
- {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"},
- }
-
- for _, tc := range cases {
- False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str)
- False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str))
- True(t, assert.NotRegexp(tc.rx, tc.str))
- True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str))
- }
-}
-
-func TestZeroWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- for _, test := range zeros {
- assert.True(mockAssert.Zero(test), "Zero should return true for %v", test)
- }
-
- for _, test := range nonZeros {
- assert.False(mockAssert.Zero(test), "Zero should return false for %v", test)
- }
-}
-
-func TestNotZeroWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- for _, test := range zeros {
- assert.False(mockAssert.NotZero(test), "Zero should return true for %v", test)
- }
-
- for _, test := range nonZeros {
- assert.True(mockAssert.NotZero(test), "Zero should return false for %v", test)
- }
-}
-
-func TestJSONEqWrapper_EqualSONString(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") {
- t.Error("JSONEq should return true")
- }
-}
-
-func TestJSONEqWrapper_Array(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) {
- t.Error("JSONEq should return true")
- }
-
-}
-
-func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`{"foo": "bar"}`, "Not JSON") {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq("Not JSON", "Not JSON") {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- assert := New(new(testing.T))
- if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) {
- t.Error("JSONEq should return false")
- }
-}
-
-func TestYAMLEqWrapper_EqualYAMLString(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) {
- t.Error("YAMLEq should return true")
- }
-
-}
-
-func TestYAMLEqWrapper_EquivalentButNotEqual(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("YAMLEq should return true")
- }
-
-}
-
-func TestYAMLEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- assert := New(new(testing.T))
- expected := `
-numeric: 1.5
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-`
-
- actual := `
-numeric: 1.5
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-`
- if !assert.YAMLEq(expected, actual) {
- t.Error("YAMLEq should return true")
- }
-}
-
-func TestYAMLEqWrapper_Array(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) {
- t.Error("YAMLEq should return true")
- }
-
-}
-
-func TestYAMLEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) {
- t.Error("YAMLEq should return false")
- }
-}
-
-func TestYAMLEqWrapper_HashesNotEquivalent(t *testing.T) {
- assert := New(new(testing.T))
- if assert.YAMLEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) {
- t.Error("YAMLEq should return false")
- }
-}
-
-func TestYAMLEqWrapper_ActualIsSimpleString(t *testing.T) {
- assert := New(new(testing.T))
- if assert.YAMLEq(`{"foo": "bar"}`, "Simple String") {
- t.Error("YAMLEq should return false")
- }
-}
-
-func TestYAMLEqWrapper_ExpectedIsSimpleString(t *testing.T) {
- assert := New(new(testing.T))
- if assert.YAMLEq("Simple String", `{"foo": "bar", "hello": "world"}`) {
- t.Error("YAMLEq should return false")
- }
-}
-
-func TestYAMLEqWrapper_ExpectedAndActualSimpleString(t *testing.T) {
- assert := New(new(testing.T))
- if !assert.YAMLEq("Simple String", "Simple String") {
- t.Error("YAMLEq should return true")
- }
-}
-
-func TestYAMLEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- assert := New(new(testing.T))
- if assert.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) {
- t.Error("YAMLEq should return false")
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions.go
deleted file mode 100644
index 4ed341dd28934c102aa7a40c74ee24b6555c1db1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions.go
+++ /dev/null
@@ -1,162 +0,0 @@
-package assert
-
-import (
- "fmt"
- "net/http"
- "net/http/httptest"
- "net/url"
- "strings"
-)
-
-// httpCode is a helper that returns HTTP code of the response. It returns -1 and
-// an error if building a new request fails.
-func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
- w := httptest.NewRecorder()
- req, err := http.NewRequest(method, url, nil)
- if err != nil {
- return -1, err
- }
- req.URL.RawQuery = values.Encode()
- handler(w, req)
- return w.Code, nil
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
- }
-
- isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
- if !isSuccessCode {
- Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code))
- }
-
- return isSuccessCode
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
- }
-
- isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
- if !isRedirectCode {
- Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code))
- }
-
- return isRedirectCode
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
- }
-
- isErrorCode := code >= http.StatusBadRequest
- if !isErrorCode {
- Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code))
- }
-
- return isErrorCode
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- code, err := httpCode(handler, method, url, values)
- if err != nil {
- Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
- }
-
- successful := code == statuscode
- if !successful {
- Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code))
- }
-
- return successful
-}
-
-// HTTPBody is a helper that returns HTTP body of the response. It returns
-// empty string if building a new request fails.
-func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
- w := httptest.NewRecorder()
- req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
- if err != nil {
- return ""
- }
- handler(w, req)
- return w.Body.String()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- body := HTTPBody(handler, method, url, values)
-
- contains := strings.Contains(body, fmt.Sprint(str))
- if !contains {
- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
- }
-
- return contains
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- body := HTTPBody(handler, method, url, values)
-
- contains := strings.Contains(body, fmt.Sprint(str))
- if contains {
- Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
- }
-
- return !contains
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions_test.go
deleted file mode 100644
index 413c9714f77bdfc78f83c4b4ddb3ac0af5324b8b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/assert/http_assertions_test.go
+++ /dev/null
@@ -1,182 +0,0 @@
-package assert
-
-import (
- "fmt"
- "net/http"
- "net/url"
- "testing"
-)
-
-func httpOK(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusOK)
-}
-
-func httpRedirect(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusTemporaryRedirect)
-}
-
-func httpError(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusInternalServerError)
-}
-
-func httpStatusCode(w http.ResponseWriter, r *http.Request) {
- w.WriteHeader(http.StatusSwitchingProtocols)
-}
-
-func TestHTTPSuccess(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT1, httpOK, "GET", "/", nil), true)
- assert.False(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false)
- assert.True(mockT2.Failed())
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT3, httpError, "GET", "/", nil), false)
- assert.True(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPSuccess(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-}
-
-func TestHTTPRedirect(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT1, httpOK, "GET", "/", nil), false)
- assert.True(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true)
- assert.False(mockT2.Failed())
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT3, httpError, "GET", "/", nil), false)
- assert.True(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPRedirect(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-}
-
-func TestHTTPError(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false)
- assert.True(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPError(mockT2, httpRedirect, "GET", "/", nil), false)
- assert.True(mockT2.Failed())
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true)
- assert.False(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPError(mockT4, httpStatusCode, "GET", "/", nil), false)
- assert.True(mockT4.Failed())
-}
-
-func TestHTTPStatusCode(t *testing.T) {
- assert := New(t)
-
- mockT1 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT1, httpOK, "GET", "/", nil, http.StatusSwitchingProtocols), false)
- assert.True(mockT1.Failed())
-
- mockT2 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT2, httpRedirect, "GET", "/", nil, http.StatusSwitchingProtocols), false)
- assert.True(mockT2.Failed())
-
- mockT3 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT3, httpError, "GET", "/", nil, http.StatusSwitchingProtocols), false)
- assert.True(mockT3.Failed())
-
- mockT4 := new(testing.T)
- assert.Equal(HTTPStatusCode(mockT4, httpStatusCode, "GET", "/", nil, http.StatusSwitchingProtocols), true)
- assert.False(mockT4.Failed())
-}
-
-func TestHTTPStatusesWrapper(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true)
- assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false)
-
- assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true)
- assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false)
-
- assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false)
- assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true)
-}
-
-func httpHelloName(w http.ResponseWriter, r *http.Request) {
- name := r.FormValue("name")
- _, _ = w.Write([]byte(fmt.Sprintf("Hello, %s!", name)))
-}
-
-func TestHTTPRequestWithNoParams(t *testing.T) {
- var got *http.Request
- handler := func(w http.ResponseWriter, r *http.Request) {
- got = r
- w.WriteHeader(http.StatusOK)
- }
-
- True(t, HTTPSuccess(t, handler, "GET", "/url", nil))
-
- Empty(t, got.URL.Query())
- Equal(t, "/url", got.URL.RequestURI())
-}
-
-func TestHTTPRequestWithParams(t *testing.T) {
- var got *http.Request
- handler := func(w http.ResponseWriter, r *http.Request) {
- got = r
- w.WriteHeader(http.StatusOK)
- }
- params := url.Values{}
- params.Add("id", "12345")
-
- True(t, HTTPSuccess(t, handler, "GET", "/url", params))
-
- Equal(t, url.Values{"id": []string{"12345"}}, got.URL.Query())
- Equal(t, "/url?id=12345", got.URL.String())
- Equal(t, "/url?id=12345", got.URL.RequestURI())
-}
-
-func TestHttpBody(t *testing.T) {
- assert := New(t)
- mockT := new(testing.T)
-
- assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-
- assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-}
-
-func TestHttpBodyWrappers(t *testing.T) {
- assert := New(t)
- mockAssert := New(new(testing.T))
-
- assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-
- assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"))
- assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World"))
- assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world"))
-
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/doc.go
deleted file mode 100644
index 3460b46b10c25a0f538c39dd14f77ac6328d8494..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/doc.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// ** We are working on testify v2 and would love to hear what you'd like to see in it, have your say here: https://cutt.ly/testify **
-// Package testify is a set of packages that provide many tools for testifying that your code will behave as you intend.
-//
-// testify contains the following packages:
-//
-// The assert package provides a comprehensive set of assertion functions that tie in to the Go testing system.
-//
-// The http package contains tools to make it easier to test http activity using the Go testing system.
-//
-// The mock package provides a system by which it is possible to mock your objects and verify calls are happening as expected.
-//
-// The suite package provides a basic structure for using structs as testing suites, and methods on those structs as tests. It includes setup/teardown functionality in the way of interfaces.
-package testify
-
-// blank imports help docs.
-import (
- // assert package
- _ "github.com/stretchr/testify/assert"
- // http package
- _ "github.com/stretchr/testify/http"
- // mock package
- _ "github.com/stretchr/testify/mock"
-)
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.mod b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.mod
deleted file mode 100644
index 3fe9bab670c5e6ad956dceff38315b494412a429..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module github.com/stretchr/testify
-
-go 1.13
-
-require (
- github.com/davecgh/go-spew v1.1.1
- github.com/pmezard/go-difflib v1.0.0
- github.com/stretchr/objx v0.5.0
- gopkg.in/yaml.v3 v3.0.1
-)
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.sum b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.sum
deleted file mode 100644
index 4f3ced6f3277f399b685c77f4b6d07018df66990..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/go.sum
+++ /dev/null
@@ -1,16 +0,0 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/doc.go
deleted file mode 100644
index 695167c6de1986d439f27ded95d720c106f71a83..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package http DEPRECATED USE net/http/httptest
-package http
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_response_writer.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_response_writer.go
deleted file mode 100644
index 300a63b8c93217b37527ca84e274100411107baf..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_response_writer.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package http
-
-import (
- "net/http"
-)
-
-// TestResponseWriter DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
-type TestResponseWriter struct {
-
- // StatusCode is the last int written by the call to WriteHeader(int)
- StatusCode int
-
- // Output is a string containing the written bytes using the Write([]byte) func.
- Output string
-
- // header is the internal storage of the http.Header object
- header http.Header
-}
-
-// Header DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
-func (rw *TestResponseWriter) Header() http.Header {
-
- if rw.header == nil {
- rw.header = make(http.Header)
- }
-
- return rw.header
-}
-
-// Write DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
-func (rw *TestResponseWriter) Write(bytes []byte) (int, error) {
-
- // assume 200 success if no header has been set
- if rw.StatusCode == 0 {
- rw.WriteHeader(200)
- }
-
- // add these bytes to the output string
- rw.Output += string(bytes)
-
- // return normal values
- return 0, nil
-
-}
-
-// WriteHeader DEPRECATED: We recommend you use http://golang.org/pkg/net/http/httptest instead.
-func (rw *TestResponseWriter) WriteHeader(i int) {
- rw.StatusCode = i
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_round_tripper.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_round_tripper.go
deleted file mode 100644
index 11a024ec3961c150ba442a85d3cac6175bada10f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/http/test_round_tripper.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package http
-
-import (
- "net/http"
-
- "github.com/stretchr/testify/mock"
-)
-
-// TestRoundTripper DEPRECATED USE net/http/httptest
-type TestRoundTripper struct {
- mock.Mock
-}
-
-// RoundTrip DEPRECATED USE net/http/httptest
-func (t *TestRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
- args := t.Called(req)
- return args.Get(0).(*http.Response), args.Error(1)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/doc.go
deleted file mode 100644
index 7324128ef19c51d1cc74cd2cae8c886b2a71e7df..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/doc.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Package mock provides a system by which it is possible to mock your objects
-// and verify calls are happening as expected.
-//
-// Example Usage
-//
-// The mock package provides an object, Mock, that tracks activity on another object. It is usually
-// embedded into a test object as shown below:
-//
-// type MyTestObject struct {
-// // add a Mock object instance
-// mock.Mock
-//
-// // other fields go here as normal
-// }
-//
-// When implementing the methods of an interface, you wire your functions up
-// to call the Mock.Called(args...) method, and return the appropriate values.
-//
-// For example, to mock a method that saves the name and age of a person and returns
-// the year of their birth or an error, you might write this:
-//
-// func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) {
-// args := o.Called(firstname, lastname, age)
-// return args.Int(0), args.Error(1)
-// }
-//
-// The Int, Error and Bool methods are examples of strongly typed getters that take the argument
-// index position. Given this argument list:
-//
-// (12, true, "Something")
-//
-// You could read them out strongly typed like this:
-//
-// args.Int(0)
-// args.Bool(1)
-// args.String(2)
-//
-// For objects of your own type, use the generic Arguments.Get(index) method and make a type assertion:
-//
-// return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine)
-//
-// This may cause a panic if the object you are getting is nil (the type assertion will fail), in those
-// cases you should check for nil first.
-package mock
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock.go
deleted file mode 100644
index e6ff8dfeb2014a548402c7d126ad30ea884798b0..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock.go
+++ /dev/null
@@ -1,1104 +0,0 @@
-package mock
-
-import (
- "errors"
- "fmt"
- "reflect"
- "regexp"
- "runtime"
- "strings"
- "sync"
- "time"
-
- "github.com/davecgh/go-spew/spew"
- "github.com/pmezard/go-difflib/difflib"
- "github.com/stretchr/objx"
- "github.com/stretchr/testify/assert"
-)
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
- Logf(format string, args ...interface{})
- Errorf(format string, args ...interface{})
- FailNow()
-}
-
-/*
- Call
-*/
-
-// Call represents a method call and is used for setting expectations,
-// as well as recording activity.
-type Call struct {
- Parent *Mock
-
- // The name of the method that was or will be called.
- Method string
-
- // Holds the arguments of the method.
- Arguments Arguments
-
- // Holds the arguments that should be returned when
- // this method is called.
- ReturnArguments Arguments
-
- // Holds the caller info for the On() call
- callerInfo []string
-
- // The number of times to return the return arguments when setting
- // expectations. 0 means to always return the value.
- Repeatability int
-
- // Amount of times this call has been called
- totalCalls int
-
- // Call to this method can be optional
- optional bool
-
- // Holds a channel that will be used to block the Return until it either
- // receives a message or is closed. nil means it returns immediately.
- WaitFor <-chan time.Time
-
- waitTime time.Duration
-
- // Holds a handler used to manipulate arguments content that are passed by
- // reference. It's useful when mocking methods such as unmarshalers or
- // decoders.
- RunFn func(Arguments)
-
- // PanicMsg holds msg to be used to mock panic on the function call
- // if the PanicMsg is set to a non nil string the function call will panic
- // irrespective of other settings
- PanicMsg *string
-
- // Calls which must be satisfied before this call can be
- requires []*Call
-}
-
-func newCall(parent *Mock, methodName string, callerInfo []string, methodArguments ...interface{}) *Call {
- return &Call{
- Parent: parent,
- Method: methodName,
- Arguments: methodArguments,
- ReturnArguments: make([]interface{}, 0),
- callerInfo: callerInfo,
- Repeatability: 0,
- WaitFor: nil,
- RunFn: nil,
- PanicMsg: nil,
- }
-}
-
-func (c *Call) lock() {
- c.Parent.mutex.Lock()
-}
-
-func (c *Call) unlock() {
- c.Parent.mutex.Unlock()
-}
-
-// Return specifies the return arguments for the expectation.
-//
-// Mock.On("DoSomething").Return(errors.New("failed"))
-func (c *Call) Return(returnArguments ...interface{}) *Call {
- c.lock()
- defer c.unlock()
-
- c.ReturnArguments = returnArguments
-
- return c
-}
-
-// Panic specifies if the functon call should fail and the panic message
-//
-// Mock.On("DoSomething").Panic("test panic")
-func (c *Call) Panic(msg string) *Call {
- c.lock()
- defer c.unlock()
-
- c.PanicMsg = &msg
-
- return c
-}
-
-// Once indicates that that the mock should only return the value once.
-//
-// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()
-func (c *Call) Once() *Call {
- return c.Times(1)
-}
-
-// Twice indicates that that the mock should only return the value twice.
-//
-// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()
-func (c *Call) Twice() *Call {
- return c.Times(2)
-}
-
-// Times indicates that that the mock should only return the indicated number
-// of times.
-//
-// Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5)
-func (c *Call) Times(i int) *Call {
- c.lock()
- defer c.unlock()
- c.Repeatability = i
- return c
-}
-
-// WaitUntil sets the channel that will block the mock's return until its closed
-// or a message is received.
-//
-// Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second))
-func (c *Call) WaitUntil(w <-chan time.Time) *Call {
- c.lock()
- defer c.unlock()
- c.WaitFor = w
- return c
-}
-
-// After sets how long to block until the call returns
-//
-// Mock.On("MyMethod", arg1, arg2).After(time.Second)
-func (c *Call) After(d time.Duration) *Call {
- c.lock()
- defer c.unlock()
- c.waitTime = d
- return c
-}
-
-// Run sets a handler to be called before returning. It can be used when
-// mocking a method (such as an unmarshaler) that takes a pointer to a struct and
-// sets properties in such struct
-//
-// Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) {
-// arg := args.Get(0).(*map[string]interface{})
-// arg["foo"] = "bar"
-// })
-func (c *Call) Run(fn func(args Arguments)) *Call {
- c.lock()
- defer c.unlock()
- c.RunFn = fn
- return c
-}
-
-// Maybe allows the method call to be optional. Not calling an optional method
-// will not cause an error while asserting expectations
-func (c *Call) Maybe() *Call {
- c.lock()
- defer c.unlock()
- c.optional = true
- return c
-}
-
-// On chains a new expectation description onto the mocked interface. This
-// allows syntax like.
-//
-// Mock.
-// On("MyMethod", 1).Return(nil).
-// On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error"))
-//go:noinline
-func (c *Call) On(methodName string, arguments ...interface{}) *Call {
- return c.Parent.On(methodName, arguments...)
-}
-
-// Unset removes a mock handler from being called.
-// test.On("func", mock.Anything).Unset()
-func (c *Call) Unset() *Call {
- var unlockOnce sync.Once
-
- for _, arg := range c.Arguments {
- if v := reflect.ValueOf(arg); v.Kind() == reflect.Func {
- panic(fmt.Sprintf("cannot use Func in expectations. Use mock.AnythingOfType(\"%T\")", arg))
- }
- }
-
- c.lock()
- defer unlockOnce.Do(c.unlock)
-
- foundMatchingCall := false
-
- // in-place filter slice for calls to be removed - iterate from 0'th to last skipping unnecessary ones
- var index int // write index
- for _, call := range c.Parent.ExpectedCalls {
- if call.Method == c.Method {
- _, diffCount := call.Arguments.Diff(c.Arguments)
- if diffCount == 0 {
- foundMatchingCall = true
- // Remove from ExpectedCalls - just skip it
- continue
- }
- }
- c.Parent.ExpectedCalls[index] = call
- index++
- }
- // trim slice up to last copied index
- c.Parent.ExpectedCalls = c.Parent.ExpectedCalls[:index]
-
- if !foundMatchingCall {
- unlockOnce.Do(c.unlock)
- c.Parent.fail("\n\nmock: Could not find expected call\n-----------------------------\n\n%s\n\n",
- callString(c.Method, c.Arguments, true),
- )
- }
-
- return c
-}
-
-// NotBefore indicates that the mock should only be called after the referenced
-// calls have been called as expected. The referenced calls may be from the
-// same mock instance and/or other mock instances.
-//
-// Mock.On("Do").Return(nil).Notbefore(
-// Mock.On("Init").Return(nil)
-// )
-func (c *Call) NotBefore(calls ...*Call) *Call {
- c.lock()
- defer c.unlock()
-
- for _, call := range calls {
- if call.Parent == nil {
- panic("not before calls must be created with Mock.On()")
- }
- }
-
- c.requires = append(c.requires, calls...)
- return c
-}
-
-// Mock is the workhorse used to track activity on another object.
-// For an example of its usage, refer to the "Example Usage" section at the top
-// of this document.
-type Mock struct {
- // Represents the calls that are expected of
- // an object.
- ExpectedCalls []*Call
-
- // Holds the calls that were made to this mocked object.
- Calls []Call
-
- // test is An optional variable that holds the test struct, to be used when an
- // invalid mock call was made.
- test TestingT
-
- // TestData holds any data that might be useful for testing. Testify ignores
- // this data completely allowing you to do whatever you like with it.
- testData objx.Map
-
- mutex sync.Mutex
-}
-
-// String provides a %v format string for Mock.
-// Note: this is used implicitly by Arguments.Diff if a Mock is passed.
-// It exists because go's default %v formatting traverses the struct
-// without acquiring the mutex, which is detected by go test -race.
-func (m *Mock) String() string {
- return fmt.Sprintf("%[1]T<%[1]p>", m)
-}
-
-// TestData holds any data that might be useful for testing. Testify ignores
-// this data completely allowing you to do whatever you like with it.
-func (m *Mock) TestData() objx.Map {
- if m.testData == nil {
- m.testData = make(objx.Map)
- }
-
- return m.testData
-}
-
-/*
- Setting expectations
-*/
-
-// Test sets the test struct variable of the mock object
-func (m *Mock) Test(t TestingT) {
- m.mutex.Lock()
- defer m.mutex.Unlock()
- m.test = t
-}
-
-// fail fails the current test with the given formatted format and args.
-// In case that a test was defined, it uses the test APIs for failing a test,
-// otherwise it uses panic.
-func (m *Mock) fail(format string, args ...interface{}) {
- m.mutex.Lock()
- defer m.mutex.Unlock()
-
- if m.test == nil {
- panic(fmt.Sprintf(format, args...))
- }
- m.test.Errorf(format, args...)
- m.test.FailNow()
-}
-
-// On starts a description of an expectation of the specified method
-// being called.
-//
-// Mock.On("MyMethod", arg1, arg2)
-func (m *Mock) On(methodName string, arguments ...interface{}) *Call {
- for _, arg := range arguments {
- if v := reflect.ValueOf(arg); v.Kind() == reflect.Func {
- panic(fmt.Sprintf("cannot use Func in expectations. Use mock.AnythingOfType(\"%T\")", arg))
- }
- }
-
- m.mutex.Lock()
- defer m.mutex.Unlock()
- c := newCall(m, methodName, assert.CallerInfo(), arguments...)
- m.ExpectedCalls = append(m.ExpectedCalls, c)
- return c
-}
-
-// /*
-// Recording and responding to activity
-// */
-
-func (m *Mock) findExpectedCall(method string, arguments ...interface{}) (int, *Call) {
- var expectedCall *Call
-
- for i, call := range m.ExpectedCalls {
- if call.Method == method {
- _, diffCount := call.Arguments.Diff(arguments)
- if diffCount == 0 {
- expectedCall = call
- if call.Repeatability > -1 {
- return i, call
- }
- }
- }
- }
-
- return -1, expectedCall
-}
-
-type matchCandidate struct {
- call *Call
- mismatch string
- diffCount int
-}
-
-func (c matchCandidate) isBetterMatchThan(other matchCandidate) bool {
- if c.call == nil {
- return false
- }
- if other.call == nil {
- return true
- }
-
- if c.diffCount > other.diffCount {
- return false
- }
- if c.diffCount < other.diffCount {
- return true
- }
-
- if c.call.Repeatability > 0 && other.call.Repeatability <= 0 {
- return true
- }
- return false
-}
-
-func (m *Mock) findClosestCall(method string, arguments ...interface{}) (*Call, string) {
- var bestMatch matchCandidate
-
- for _, call := range m.expectedCalls() {
- if call.Method == method {
-
- errInfo, tempDiffCount := call.Arguments.Diff(arguments)
- tempCandidate := matchCandidate{
- call: call,
- mismatch: errInfo,
- diffCount: tempDiffCount,
- }
- if tempCandidate.isBetterMatchThan(bestMatch) {
- bestMatch = tempCandidate
- }
- }
- }
-
- return bestMatch.call, bestMatch.mismatch
-}
-
-func callString(method string, arguments Arguments, includeArgumentValues bool) string {
- var argValsString string
- if includeArgumentValues {
- var argVals []string
- for argIndex, arg := range arguments {
- argVals = append(argVals, fmt.Sprintf("%d: %#v", argIndex, arg))
- }
- argValsString = fmt.Sprintf("\n\t\t%s", strings.Join(argVals, "\n\t\t"))
- }
-
- return fmt.Sprintf("%s(%s)%s", method, arguments.String(), argValsString)
-}
-
-// Called tells the mock object that a method has been called, and gets an array
-// of arguments to return. Panics if the call is unexpected (i.e. not preceded by
-// appropriate .On .Return() calls)
-// If Call.WaitFor is set, blocks until the channel is closed or receives a message.
-func (m *Mock) Called(arguments ...interface{}) Arguments {
- // get the calling function's name
- pc, _, _, ok := runtime.Caller(1)
- if !ok {
- panic("Couldn't get the caller information")
- }
- functionPath := runtime.FuncForPC(pc).Name()
- // Next four lines are required to use GCCGO function naming conventions.
- // For Ex: github_com_docker_libkv_store_mock.WatchTree.pN39_github_com_docker_libkv_store_mock.Mock
- // uses interface information unlike golang github.com/docker/libkv/store/mock.(*Mock).WatchTree
- // With GCCGO we need to remove interface information starting from pN<dd>.
- re := regexp.MustCompile("\\.pN\\d+_")
- if re.MatchString(functionPath) {
- functionPath = re.Split(functionPath, -1)[0]
- }
- parts := strings.Split(functionPath, ".")
- functionName := parts[len(parts)-1]
- return m.MethodCalled(functionName, arguments...)
-}
-
-// MethodCalled tells the mock object that the given method has been called, and gets
-// an array of arguments to return. Panics if the call is unexpected (i.e. not preceded
-// by appropriate .On .Return() calls)
-// If Call.WaitFor is set, blocks until the channel is closed or receives a message.
-func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Arguments {
- m.mutex.Lock()
- // TODO: could combine expected and closes in single loop
- found, call := m.findExpectedCall(methodName, arguments...)
-
- if found < 0 {
- // expected call found but it has already been called with repeatable times
- if call != nil {
- m.mutex.Unlock()
- m.fail("\nassert: mock: The method has been called over %d times.\n\tEither do one more Mock.On(\"%s\").Return(...), or remove extra call.\n\tThis call was unexpected:\n\t\t%s\n\tat: %s", call.totalCalls, methodName, callString(methodName, arguments, true), assert.CallerInfo())
- }
- // we have to fail here - because we don't know what to do
- // as the return arguments. This is because:
- //
- // a) this is a totally unexpected call to this method,
- // b) the arguments are not what was expected, or
- // c) the developer has forgotten to add an accompanying On...Return pair.
- closestCall, mismatch := m.findClosestCall(methodName, arguments...)
- m.mutex.Unlock()
-
- if closestCall != nil {
- m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s",
- callString(methodName, arguments, true),
- callString(methodName, closestCall.Arguments, true),
- diffArguments(closestCall.Arguments, arguments),
- strings.TrimSpace(mismatch),
- )
- } else {
- m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(\"%s\").Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo())
- }
- }
-
- for _, requirement := range call.requires {
- if satisfied, _ := requirement.Parent.checkExpectation(requirement); !satisfied {
- m.mutex.Unlock()
- m.fail("mock: Unexpected Method Call\n-----------------------------\n\n%s\n\nMust not be called before%s:\n\n%s",
- callString(call.Method, call.Arguments, true),
- func() (s string) {
- if requirement.totalCalls > 0 {
- s = " another call of"
- }
- if call.Parent != requirement.Parent {
- s += " method from another mock instance"
- }
- return
- }(),
- callString(requirement.Method, requirement.Arguments, true),
- )
- }
- }
-
- if call.Repeatability == 1 {
- call.Repeatability = -1
- } else if call.Repeatability > 1 {
- call.Repeatability--
- }
- call.totalCalls++
-
- // add the call
- m.Calls = append(m.Calls, *newCall(m, methodName, assert.CallerInfo(), arguments...))
- m.mutex.Unlock()
-
- // block if specified
- if call.WaitFor != nil {
- <-call.WaitFor
- } else {
- time.Sleep(call.waitTime)
- }
-
- m.mutex.Lock()
- panicMsg := call.PanicMsg
- m.mutex.Unlock()
- if panicMsg != nil {
- panic(*panicMsg)
- }
-
- m.mutex.Lock()
- runFn := call.RunFn
- m.mutex.Unlock()
-
- if runFn != nil {
- runFn(arguments)
- }
-
- m.mutex.Lock()
- returnArgs := call.ReturnArguments
- m.mutex.Unlock()
-
- return returnArgs
-}
-
-/*
- Assertions
-*/
-
-type assertExpectationser interface {
- AssertExpectations(TestingT) bool
-}
-
-// AssertExpectationsForObjects asserts that everything specified with On and Return
-// of the specified objects was in fact called as expected.
-//
-// Calls may have occurred in any order.
-func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- for _, obj := range testObjects {
- if m, ok := obj.(*Mock); ok {
- t.Logf("Deprecated mock.AssertExpectationsForObjects(myMock.Mock) use mock.AssertExpectationsForObjects(myMock)")
- obj = m
- }
- m := obj.(assertExpectationser)
- if !m.AssertExpectations(t) {
- t.Logf("Expectations didn't match for Mock: %+v", reflect.TypeOf(m))
- return false
- }
- }
- return true
-}
-
-// AssertExpectations asserts that everything specified with On and Return was
-// in fact called as expected. Calls may have occurred in any order.
-func (m *Mock) AssertExpectations(t TestingT) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- m.mutex.Lock()
- defer m.mutex.Unlock()
- var failedExpectations int
-
- // iterate through each expectation
- expectedCalls := m.expectedCalls()
- for _, expectedCall := range expectedCalls {
- satisfied, reason := m.checkExpectation(expectedCall)
- if !satisfied {
- failedExpectations++
- }
- t.Logf(reason)
- }
-
- if failedExpectations != 0 {
- t.Errorf("FAIL: %d out of %d expectation(s) were met.\n\tThe code you are testing needs to make %d more call(s).\n\tat: %s", len(expectedCalls)-failedExpectations, len(expectedCalls), failedExpectations, assert.CallerInfo())
- }
-
- return failedExpectations == 0
-}
-
-func (m *Mock) checkExpectation(call *Call) (bool, string) {
- if !call.optional && !m.methodWasCalled(call.Method, call.Arguments) && call.totalCalls == 0 {
- return false, fmt.Sprintf("FAIL:\t%s(%s)\n\t\tat: %s", call.Method, call.Arguments.String(), call.callerInfo)
- }
- if call.Repeatability > 0 {
- return false, fmt.Sprintf("FAIL:\t%s(%s)\n\t\tat: %s", call.Method, call.Arguments.String(), call.callerInfo)
- }
- return true, fmt.Sprintf("PASS:\t%s(%s)", call.Method, call.Arguments.String())
-}
-
-// AssertNumberOfCalls asserts that the method was called expectedCalls times.
-func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls int) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- m.mutex.Lock()
- defer m.mutex.Unlock()
- var actualCalls int
- for _, call := range m.calls() {
- if call.Method == methodName {
- actualCalls++
- }
- }
- return assert.Equal(t, expectedCalls, actualCalls, fmt.Sprintf("Expected number of calls (%d) does not match the actual number of calls (%d).", expectedCalls, actualCalls))
-}
-
-// AssertCalled asserts that the method was called.
-// It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method.
-func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- m.mutex.Lock()
- defer m.mutex.Unlock()
- if !m.methodWasCalled(methodName, arguments) {
- var calledWithArgs []string
- for _, call := range m.calls() {
- calledWithArgs = append(calledWithArgs, fmt.Sprintf("%v", call.Arguments))
- }
- if len(calledWithArgs) == 0 {
- return assert.Fail(t, "Should have called with given arguments",
- fmt.Sprintf("Expected %q to have been called with:\n%v\nbut no actual calls happened", methodName, arguments))
- }
- return assert.Fail(t, "Should have called with given arguments",
- fmt.Sprintf("Expected %q to have been called with:\n%v\nbut actual calls were:\n %v", methodName, arguments, strings.Join(calledWithArgs, "\n")))
- }
- return true
-}
-
-// AssertNotCalled asserts that the method was not called.
-// It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method.
-func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- m.mutex.Lock()
- defer m.mutex.Unlock()
- if m.methodWasCalled(methodName, arguments) {
- return assert.Fail(t, "Should not have called with given arguments",
- fmt.Sprintf("Expected %q to not have been called with:\n%v\nbut actually it was.", methodName, arguments))
- }
- return true
-}
-
-// IsMethodCallable checking that the method can be called
-// If the method was called more than `Repeatability` return false
-func (m *Mock) IsMethodCallable(t TestingT, methodName string, arguments ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- m.mutex.Lock()
- defer m.mutex.Unlock()
-
- for _, v := range m.ExpectedCalls {
- if v.Method != methodName {
- continue
- }
- if len(arguments) != len(v.Arguments) {
- continue
- }
- if v.Repeatability < v.totalCalls {
- continue
- }
- if isArgsEqual(v.Arguments, arguments) {
- return true
- }
- }
- return false
-}
-
-// isArgsEqual compares arguments
-func isArgsEqual(expected Arguments, args []interface{}) bool {
- if len(expected) != len(args) {
- return false
- }
- for i, v := range args {
- if !reflect.DeepEqual(expected[i], v) {
- return false
- }
- }
- return true
-}
-
-func (m *Mock) methodWasCalled(methodName string, expected []interface{}) bool {
- for _, call := range m.calls() {
- if call.Method == methodName {
-
- _, differences := Arguments(expected).Diff(call.Arguments)
-
- if differences == 0 {
- // found the expected call
- return true
- }
-
- }
- }
- // we didn't find the expected call
- return false
-}
-
-func (m *Mock) expectedCalls() []*Call {
- return append([]*Call{}, m.ExpectedCalls...)
-}
-
-func (m *Mock) calls() []Call {
- return append([]Call{}, m.Calls...)
-}
-
-/*
- Arguments
-*/
-
-// Arguments holds an array of method arguments or return values.
-type Arguments []interface{}
-
-const (
- // Anything is used in Diff and Assert when the argument being tested
- // shouldn't be taken into consideration.
- Anything = "mock.Anything"
-)
-
-// AnythingOfTypeArgument is a string that contains the type of an argument
-// for use when type checking. Used in Diff and Assert.
-type AnythingOfTypeArgument string
-
-// AnythingOfType returns an AnythingOfTypeArgument object containing the
-// name of the type to check for. Used in Diff and Assert.
-//
-// For example:
-// Assert(t, AnythingOfType("string"), AnythingOfType("int"))
-func AnythingOfType(t string) AnythingOfTypeArgument {
- return AnythingOfTypeArgument(t)
-}
-
-// IsTypeArgument is a struct that contains the type of an argument
-// for use when type checking. This is an alternative to AnythingOfType.
-// Used in Diff and Assert.
-type IsTypeArgument struct {
- t interface{}
-}
-
-// IsType returns an IsTypeArgument object containing the type to check for.
-// You can provide a zero-value of the type to check. This is an
-// alternative to AnythingOfType. Used in Diff and Assert.
-//
-// For example:
-// Assert(t, IsType(""), IsType(0))
-func IsType(t interface{}) *IsTypeArgument {
- return &IsTypeArgument{t: t}
-}
-
-// argumentMatcher performs custom argument matching, returning whether or
-// not the argument is matched by the expectation fixture function.
-type argumentMatcher struct {
- // fn is a function which accepts one argument, and returns a bool.
- fn reflect.Value
-}
-
-func (f argumentMatcher) Matches(argument interface{}) bool {
- expectType := f.fn.Type().In(0)
- expectTypeNilSupported := false
- switch expectType.Kind() {
- case reflect.Interface, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Ptr:
- expectTypeNilSupported = true
- }
-
- argType := reflect.TypeOf(argument)
- var arg reflect.Value
- if argType == nil {
- arg = reflect.New(expectType).Elem()
- } else {
- arg = reflect.ValueOf(argument)
- }
-
- if argType == nil && !expectTypeNilSupported {
- panic(errors.New("attempting to call matcher with nil for non-nil expected type"))
- }
- if argType == nil || argType.AssignableTo(expectType) {
- result := f.fn.Call([]reflect.Value{arg})
- return result[0].Bool()
- }
- return false
-}
-
-func (f argumentMatcher) String() string {
- return fmt.Sprintf("func(%s) bool", f.fn.Type().In(0).String())
-}
-
-// MatchedBy can be used to match a mock call based on only certain properties
-// from a complex struct or some calculation. It takes a function that will be
-// evaluated with the called argument and will return true when there's a match
-// and false otherwise.
-//
-// Example:
-// m.On("Do", MatchedBy(func(req *http.Request) bool { return req.Host == "example.com" }))
-//
-// |fn|, must be a function accepting a single argument (of the expected type)
-// which returns a bool. If |fn| doesn't match the required signature,
-// MatchedBy() panics.
-func MatchedBy(fn interface{}) argumentMatcher {
- fnType := reflect.TypeOf(fn)
-
- if fnType.Kind() != reflect.Func {
- panic(fmt.Sprintf("assert: arguments: %s is not a func", fn))
- }
- if fnType.NumIn() != 1 {
- panic(fmt.Sprintf("assert: arguments: %s does not take exactly one argument", fn))
- }
- if fnType.NumOut() != 1 || fnType.Out(0).Kind() != reflect.Bool {
- panic(fmt.Sprintf("assert: arguments: %s does not return a bool", fn))
- }
-
- return argumentMatcher{fn: reflect.ValueOf(fn)}
-}
-
-// Get Returns the argument at the specified index.
-func (args Arguments) Get(index int) interface{} {
- if index+1 > len(args) {
- panic(fmt.Sprintf("assert: arguments: Cannot call Get(%d) because there are %d argument(s).", index, len(args)))
- }
- return args[index]
-}
-
-// Is gets whether the objects match the arguments specified.
-func (args Arguments) Is(objects ...interface{}) bool {
- for i, obj := range args {
- if obj != objects[i] {
- return false
- }
- }
- return true
-}
-
-// Diff gets a string describing the differences between the arguments
-// and the specified objects.
-//
-// Returns the diff string and number of differences found.
-func (args Arguments) Diff(objects []interface{}) (string, int) {
- // TODO: could return string as error and nil for No difference
-
- output := "\n"
- var differences int
-
- maxArgCount := len(args)
- if len(objects) > maxArgCount {
- maxArgCount = len(objects)
- }
-
- for i := 0; i < maxArgCount; i++ {
- var actual, expected interface{}
- var actualFmt, expectedFmt string
-
- if len(objects) <= i {
- actual = "(Missing)"
- actualFmt = "(Missing)"
- } else {
- actual = objects[i]
- actualFmt = fmt.Sprintf("(%[1]T=%[1]v)", actual)
- }
-
- if len(args) <= i {
- expected = "(Missing)"
- expectedFmt = "(Missing)"
- } else {
- expected = args[i]
- expectedFmt = fmt.Sprintf("(%[1]T=%[1]v)", expected)
- }
-
- if matcher, ok := expected.(argumentMatcher); ok {
- var matches bool
- func() {
- defer func() {
- if r := recover(); r != nil {
- actualFmt = fmt.Sprintf("panic in argument matcher: %v", r)
- }
- }()
- matches = matcher.Matches(actual)
- }()
- if matches {
- output = fmt.Sprintf("%s\t%d: PASS: %s matched by %s\n", output, i, actualFmt, matcher)
- } else {
- differences++
- output = fmt.Sprintf("%s\t%d: FAIL: %s not matched by %s\n", output, i, actualFmt, matcher)
- }
- } else if reflect.TypeOf(expected) == reflect.TypeOf((*AnythingOfTypeArgument)(nil)).Elem() {
- // type checking
- if reflect.TypeOf(actual).Name() != string(expected.(AnythingOfTypeArgument)) && reflect.TypeOf(actual).String() != string(expected.(AnythingOfTypeArgument)) {
- // not match
- differences++
- output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, expected, reflect.TypeOf(actual).Name(), actualFmt)
- }
- } else if reflect.TypeOf(expected) == reflect.TypeOf((*IsTypeArgument)(nil)) {
- t := expected.(*IsTypeArgument).t
- if reflect.TypeOf(t) != reflect.TypeOf(actual) {
- differences++
- output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, reflect.TypeOf(t).Name(), reflect.TypeOf(actual).Name(), actualFmt)
- }
- } else {
- // normal checking
-
- if assert.ObjectsAreEqual(expected, Anything) || assert.ObjectsAreEqual(actual, Anything) || assert.ObjectsAreEqual(actual, expected) {
- // match
- output = fmt.Sprintf("%s\t%d: PASS: %s == %s\n", output, i, actualFmt, expectedFmt)
- } else {
- // not match
- differences++
- output = fmt.Sprintf("%s\t%d: FAIL: %s != %s\n", output, i, actualFmt, expectedFmt)
- }
- }
-
- }
-
- if differences == 0 {
- return "No differences.", differences
- }
-
- return output, differences
-}
-
-// Assert compares the arguments with the specified objects and fails if
-// they do not exactly match.
-func (args Arguments) Assert(t TestingT, objects ...interface{}) bool {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
-
- // get the differences
- diff, diffCount := args.Diff(objects)
-
- if diffCount == 0 {
- return true
- }
-
- // there are differences... report them...
- t.Logf(diff)
- t.Errorf("%sArguments do not match.", assert.CallerInfo())
-
- return false
-}
-
-// String gets the argument at the specified index. Panics if there is no argument, or
-// if the argument is of the wrong type.
-//
-// If no index is provided, String() returns a complete string representation
-// of the arguments.
-func (args Arguments) String(indexOrNil ...int) string {
- if len(indexOrNil) == 0 {
- // normal String() method - return a string representation of the args
- var argsStr []string
- for _, arg := range args {
- argsStr = append(argsStr, fmt.Sprintf("%T", arg)) // handles nil nicely
- }
- return strings.Join(argsStr, ",")
- } else if len(indexOrNil) == 1 {
- // Index has been specified - get the argument at that index
- index := indexOrNil[0]
- var s string
- var ok bool
- if s, ok = args.Get(index).(string); !ok {
- panic(fmt.Sprintf("assert: arguments: String(%d) failed because object wasn't correct type: %s", index, args.Get(index)))
- }
- return s
- }
-
- panic(fmt.Sprintf("assert: arguments: Wrong number of arguments passed to String. Must be 0 or 1, not %d", len(indexOrNil)))
-}
-
-// Int gets the argument at the specified index. Panics if there is no argument, or
-// if the argument is of the wrong type.
-func (args Arguments) Int(index int) int {
- var s int
- var ok bool
- if s, ok = args.Get(index).(int); !ok {
- panic(fmt.Sprintf("assert: arguments: Int(%d) failed because object wasn't correct type: %v", index, args.Get(index)))
- }
- return s
-}
-
-// Error gets the argument at the specified index. Panics if there is no argument, or
-// if the argument is of the wrong type.
-func (args Arguments) Error(index int) error {
- obj := args.Get(index)
- var s error
- var ok bool
- if obj == nil {
- return nil
- }
- if s, ok = obj.(error); !ok {
- panic(fmt.Sprintf("assert: arguments: Error(%d) failed because object wasn't correct type: %v", index, args.Get(index)))
- }
- return s
-}
-
-// Bool gets the argument at the specified index. Panics if there is no argument, or
-// if the argument is of the wrong type.
-func (args Arguments) Bool(index int) bool {
- var s bool
- var ok bool
- if s, ok = args.Get(index).(bool); !ok {
- panic(fmt.Sprintf("assert: arguments: Bool(%d) failed because object wasn't correct type: %v", index, args.Get(index)))
- }
- return s
-}
-
-func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
- t := reflect.TypeOf(v)
- k := t.Kind()
-
- if k == reflect.Ptr {
- t = t.Elem()
- k = t.Kind()
- }
- return t, k
-}
-
-func diffArguments(expected Arguments, actual Arguments) string {
- if len(expected) != len(actual) {
- return fmt.Sprintf("Provided %v arguments, mocked for %v arguments", len(expected), len(actual))
- }
-
- for x := range expected {
- if diffString := diff(expected[x], actual[x]); diffString != "" {
- return fmt.Sprintf("Difference found in argument %v:\n\n%s", x, diffString)
- }
- }
-
- return ""
-}
-
-// diff returns a diff of both values as long as both are of the same type and
-// are a struct, map, slice or array. Otherwise it returns an empty string.
-func diff(expected interface{}, actual interface{}) string {
- if expected == nil || actual == nil {
- return ""
- }
-
- et, ek := typeAndKind(expected)
- at, _ := typeAndKind(actual)
-
- if et != at {
- return ""
- }
-
- if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array {
- return ""
- }
-
- e := spewConfig.Sdump(expected)
- a := spewConfig.Sdump(actual)
-
- diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
- A: difflib.SplitLines(e),
- B: difflib.SplitLines(a),
- FromFile: "Expected",
- FromDate: "",
- ToFile: "Actual",
- ToDate: "",
- Context: 1,
- })
-
- return diff
-}
-
-var spewConfig = spew.ConfigState{
- Indent: " ",
- DisablePointerAddresses: true,
- DisableCapacities: true,
- SortKeys: true,
-}
-
-type tHelper interface {
- Helper()
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock_test.go
deleted file mode 100644
index 260bb9c4f2f23d956d6fb69f657ebeeaf221d96c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/mock/mock_test.go
+++ /dev/null
@@ -1,2084 +0,0 @@
-package mock
-
-import (
- "errors"
- "fmt"
- "regexp"
- "runtime"
- "sync"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
-)
-
-/*
- Test objects
-*/
-
-// ExampleInterface represents an example interface.
-type ExampleInterface interface {
- TheExampleMethod(a, b, c int) (int, error)
-}
-
-// TestExampleImplementation is a test implementation of ExampleInterface
-type TestExampleImplementation struct {
- Mock
-}
-
-func (i *TestExampleImplementation) TheExampleMethod(a, b, c int) (int, error) {
- args := i.Called(a, b, c)
- return args.Int(0), errors.New("Whoops")
-}
-
-//go:noinline
-func (i *TestExampleImplementation) TheExampleMethod2(yesorno bool) {
- i.Called(yesorno)
-}
-
-type ExampleType struct {
- ran bool
-}
-
-func (i *TestExampleImplementation) TheExampleMethod3(et *ExampleType) error {
- args := i.Called(et)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethod4(v ExampleInterface) error {
- args := i.Called(v)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethod5(ch chan struct{}) error {
- args := i.Called(ch)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethod6(m map[string]bool) error {
- args := i.Called(m)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethod7(slice []bool) error {
- args := i.Called(slice)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethodFunc(fn func(string) error) error {
- args := i.Called(fn)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethodVariadic(a ...int) error {
- args := i.Called(a)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethodVariadicInterface(a ...interface{}) error {
- args := i.Called(a)
- return args.Error(0)
-}
-
-func (i *TestExampleImplementation) TheExampleMethodMixedVariadic(a int, b ...int) error {
- args := i.Called(a, b)
- return args.Error(0)
-}
-
-type ExampleFuncType func(string) error
-
-func (i *TestExampleImplementation) TheExampleMethodFuncType(fn ExampleFuncType) error {
- args := i.Called(fn)
- return args.Error(0)
-}
-
-// MockTestingT mocks a test struct
-type MockTestingT struct {
- logfCount, errorfCount, failNowCount int
-}
-
-const mockTestingTFailNowCalled = "FailNow was called"
-
-func (m *MockTestingT) Logf(string, ...interface{}) {
- m.logfCount++
-}
-
-func (m *MockTestingT) Errorf(string, ...interface{}) {
- m.errorfCount++
-}
-
-// FailNow mocks the FailNow call.
-// It panics in order to mimic the FailNow behavior in the sense that
-// the execution stops.
-// When expecting this method, the call that invokes it should use the following code:
-//
-// assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() {...})
-func (m *MockTestingT) FailNow() {
- m.failNowCount++
-
- // this function should panic now to stop the execution as expected
- panic(mockTestingTFailNowCalled)
-}
-
-/*
- Mock
-*/
-
-func Test_Mock_TestData(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- if assert.NotNil(t, mockedService.TestData()) {
-
- mockedService.TestData().Set("something", 123)
- assert.Equal(t, 123, mockedService.TestData().Get("something").Data())
- }
-}
-
-func Test_Mock_On(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.On("TheExampleMethod")
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, "TheExampleMethod", c.Method)
-}
-
-func Test_Mock_Chained_On(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- // determine our current line number so we can assert the expected calls callerInfo properly
- _, filename, line, _ := runtime.Caller(0)
- mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(0).
- On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
- Return(nil)
-
- expectedCalls := []*Call{
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethod",
- Arguments: []interface{}{1, 2, 3},
- ReturnArguments: []interface{}{0},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+2)},
- },
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethod3",
- Arguments: []interface{}{AnythingOfType("*mock.ExampleType")},
- ReturnArguments: []interface{}{nil},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+4)},
- },
- }
- assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
-}
-
-func Test_Mock_On_WithArgs(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.On("TheExampleMethod", 1, 2, 3, 4)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, "TheExampleMethod", c.Method)
- assert.Equal(t, Arguments{1, 2, 3, 4}, c.Arguments)
-}
-
-func Test_Mock_On_WithFuncArg(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethodFunc", AnythingOfType("func(string) error")).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, "TheExampleMethodFunc", c.Method)
- assert.Equal(t, 1, len(c.Arguments))
- assert.Equal(t, AnythingOfType("func(string) error"), c.Arguments[0])
-
- fn := func(string) error { return nil }
-
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodFunc(fn)
- })
-}
-
-func Test_Mock_On_WithIntArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod",
- MatchedBy(func(a int) bool {
- return a == 1
- }), MatchedBy(func(b int) bool {
- return b == 2
- }), MatchedBy(func(c int) bool {
- return c == 3
- })).Return(0, nil)
-
- assert.Panics(t, func() {
- mockedService.TheExampleMethod(1, 2, 4)
- })
- assert.Panics(t, func() {
- mockedService.TheExampleMethod(2, 2, 3)
- })
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethod(1, 2, 3)
- })
-}
-
-func Test_Mock_On_WithArgMatcherThatPanics(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod2", MatchedBy(func(_ interface{}) bool {
- panic("try to lock mockedService")
- })).Return()
-
- defer func() {
- assertedExpectations := make(chan struct{})
- go func() {
- tt := new(testing.T)
- mockedService.AssertExpectations(tt)
- close(assertedExpectations)
- }()
- select {
- case <-assertedExpectations:
- case <-time.After(time.Second):
- t.Fatal("AssertExpectations() deadlocked, did the panic leave mockedService locked?")
- }
- }()
-
- assert.Panics(t, func() {
- mockedService.TheExampleMethod2(false)
- })
-}
-
-func TestMock_WithTest(t *testing.T) {
- var (
- mockedService TestExampleImplementation
- mockedTest MockTestingT
- )
-
- mockedService.Test(&mockedTest)
- mockedService.On("TheExampleMethod", 1, 2, 3).Return(0, nil)
-
- // Test that on an expected call, the test was not failed
-
- mockedService.TheExampleMethod(1, 2, 3)
-
- // Assert that Errorf and FailNow were not called
- assert.Equal(t, 0, mockedTest.errorfCount)
- assert.Equal(t, 0, mockedTest.failNowCount)
-
- // Test that on unexpected call, the mocked test was called to fail the test
-
- assert.PanicsWithValue(t, mockTestingTFailNowCalled, func() {
- mockedService.TheExampleMethod(1, 1, 1)
- })
-
- // Assert that Errorf and FailNow were called once
- assert.Equal(t, 1, mockedTest.errorfCount)
- assert.Equal(t, 1, mockedTest.failNowCount)
-}
-
-func Test_Mock_On_WithPtrArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod3",
- MatchedBy(func(a *ExampleType) bool { return a != nil && a.ran == true }),
- ).Return(nil)
-
- mockedService.On("TheExampleMethod3",
- MatchedBy(func(a *ExampleType) bool { return a != nil && a.ran == false }),
- ).Return(errors.New("error"))
-
- mockedService.On("TheExampleMethod3",
- MatchedBy(func(a *ExampleType) bool { return a == nil }),
- ).Return(errors.New("error2"))
-
- assert.Equal(t, mockedService.TheExampleMethod3(&ExampleType{true}), nil)
- assert.EqualError(t, mockedService.TheExampleMethod3(&ExampleType{false}), "error")
- assert.EqualError(t, mockedService.TheExampleMethod3(nil), "error2")
-}
-
-func Test_Mock_On_WithFuncArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- fixture1, fixture2 := errors.New("fixture1"), errors.New("fixture2")
-
- mockedService.On("TheExampleMethodFunc",
- MatchedBy(func(a func(string) error) bool { return a != nil && a("string") == fixture1 }),
- ).Return(errors.New("fixture1"))
-
- mockedService.On("TheExampleMethodFunc",
- MatchedBy(func(a func(string) error) bool { return a != nil && a("string") == fixture2 }),
- ).Return(errors.New("fixture2"))
-
- mockedService.On("TheExampleMethodFunc",
- MatchedBy(func(a func(string) error) bool { return a == nil }),
- ).Return(errors.New("fixture3"))
-
- assert.EqualError(t, mockedService.TheExampleMethodFunc(
- func(string) error { return fixture1 }), "fixture1")
- assert.EqualError(t, mockedService.TheExampleMethodFunc(
- func(string) error { return fixture2 }), "fixture2")
- assert.EqualError(t, mockedService.TheExampleMethodFunc(nil), "fixture3")
-}
-
-func Test_Mock_On_WithInterfaceArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod4",
- MatchedBy(func(a ExampleInterface) bool { return a == nil }),
- ).Return(errors.New("fixture1"))
-
- assert.EqualError(t, mockedService.TheExampleMethod4(nil), "fixture1")
-}
-
-func Test_Mock_On_WithChannelArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod5",
- MatchedBy(func(ch chan struct{}) bool { return ch == nil }),
- ).Return(errors.New("fixture1"))
-
- assert.EqualError(t, mockedService.TheExampleMethod5(nil), "fixture1")
-}
-
-func Test_Mock_On_WithMapArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod6",
- MatchedBy(func(m map[string]bool) bool { return m == nil }),
- ).Return(errors.New("fixture1"))
-
- assert.EqualError(t, mockedService.TheExampleMethod6(nil), "fixture1")
-}
-
-func Test_Mock_On_WithSliceArgMatcher(t *testing.T) {
- var mockedService TestExampleImplementation
-
- mockedService.On("TheExampleMethod7",
- MatchedBy(func(slice []bool) bool { return slice == nil }),
- ).Return(errors.New("fixture1"))
-
- assert.EqualError(t, mockedService.TheExampleMethod7(nil), "fixture1")
-}
-
-func Test_Mock_On_WithVariadicFunc(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethodVariadic", []int{1, 2, 3}).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, 1, len(c.Arguments))
- assert.Equal(t, []int{1, 2, 3}, c.Arguments[0])
-
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodVariadic(1, 2, 3)
- })
- assert.Panics(t, func() {
- mockedService.TheExampleMethodVariadic(1, 2)
- })
-
-}
-
-func Test_Mock_On_WithMixedVariadicFunc(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethodMixedVariadic", 1, []int{2, 3, 4}).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, 2, len(c.Arguments))
- assert.Equal(t, 1, c.Arguments[0])
- assert.Equal(t, []int{2, 3, 4}, c.Arguments[1])
-
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 4)
- })
- assert.Panics(t, func() {
- mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 5)
- })
-
-}
-
-func Test_Mock_On_WithVariadicFuncWithInterface(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.On("TheExampleMethodVariadicInterface", []interface{}{1, 2, 3}).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, 1, len(c.Arguments))
- assert.Equal(t, []interface{}{1, 2, 3}, c.Arguments[0])
-
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodVariadicInterface(1, 2, 3)
- })
- assert.Panics(t, func() {
- mockedService.TheExampleMethodVariadicInterface(1, 2)
- })
-
-}
-
-func Test_Mock_On_WithVariadicFuncWithEmptyInterfaceArray(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- var expected []interface{}
- c := mockedService.
- On("TheExampleMethodVariadicInterface", expected).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, 1, len(c.Arguments))
- assert.Equal(t, expected, c.Arguments[0])
-
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodVariadicInterface()
- })
- assert.Panics(t, func() {
- mockedService.TheExampleMethodVariadicInterface(1, 2)
- })
-
-}
-
-func Test_Mock_On_WithFuncPanics(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- assert.Panics(t, func() {
- mockedService.On("TheExampleMethodFunc", func(string) error { return nil })
- })
-}
-
-func Test_Mock_On_WithFuncTypeArg(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethodFuncType", AnythingOfType("mock.ExampleFuncType")).
- Return(nil)
-
- assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
- assert.Equal(t, 1, len(c.Arguments))
- assert.Equal(t, AnythingOfType("mock.ExampleFuncType"), c.Arguments[0])
-
- fn := func(string) error { return nil }
- assert.NotPanics(t, func() {
- mockedService.TheExampleMethodFuncType(fn)
- })
-}
-
-func Test_Mock_Unset(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- call := mockedService.
- On("TheExampleMethodFuncType", "argA").
- Return("blah")
-
- found, foundCall := mockedService.findExpectedCall("TheExampleMethodFuncType", "argA")
- require.NotEqual(t, -1, found)
- require.Equal(t, foundCall, call)
-
- call.Unset()
-
- found, foundCall = mockedService.findExpectedCall("TheExampleMethodFuncType", "argA")
- require.Equal(t, -1, found)
-
- var expectedCall *Call
- require.Equal(t, expectedCall, foundCall)
-
- fn := func(string) error { return nil }
- assert.Panics(t, func() {
- mockedService.TheExampleMethodFuncType(fn)
- })
-}
-
-// Since every time you call On it creates a new object
-// the last time you call Unset it will only unset the last call
-func Test_Mock_Chained_UnsetOnlyUnsetsLastCall(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- // determine our current line number so we can assert the expected calls callerInfo properly
- _, filename, line, _ := runtime.Caller(0)
- mockedService.
- On("TheExampleMethod1", 1, 1).
- Return(0).
- On("TheExampleMethod2", 2, 2).
- On("TheExampleMethod3", 3, 3, 3).
- Return(nil).
- Unset()
-
- expectedCalls := []*Call{
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethod1",
- Arguments: []interface{}{1, 1},
- ReturnArguments: []interface{}{0},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+2)},
- },
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethod2",
- Arguments: []interface{}{2, 2},
- ReturnArguments: []interface{}{},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+4)},
- },
- }
- assert.Equal(t, 2, len(expectedCalls))
- assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
-}
-
-func Test_Mock_UnsetIfAlreadyUnsetFails(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- mock1 := mockedService.
- On("TheExampleMethod1", 1, 1).
- Return(1)
-
- assert.Equal(t, 1, len(mockedService.ExpectedCalls))
- mock1.Unset()
- assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-
- assert.Panics(t, func() {
- mock1.Unset()
- })
-
- assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-}
-
-func Test_Mock_UnsetByOnMethodSpec(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- mock1 := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(0, nil)
-
- assert.Equal(t, 1, len(mockedService.ExpectedCalls))
- mock1.On("TheExampleMethod", 1, 2, 3).
- Return(0, nil).Unset()
-
- assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-
- assert.Panics(t, func() {
- mock1.Unset()
- })
-
- assert.Equal(t, 0, len(mockedService.ExpectedCalls))
-}
-
-func Test_Mock_UnsetByOnMethodSpecAmongOthers(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- _, filename, line, _ := runtime.Caller(0)
- mock1 := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(0, nil).
- On("TheExampleMethodVariadic", 1, 2, 3, 4, 5).Once().
- Return(nil)
- mock1.
- On("TheExampleMethodFuncType", Anything).
- Return(nil)
-
- assert.Equal(t, 3, len(mockedService.ExpectedCalls))
- mock1.On("TheExampleMethod", 1, 2, 3).
- Return(0, nil).Unset()
-
- assert.Equal(t, 2, len(mockedService.ExpectedCalls))
-
- expectedCalls := []*Call{
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethodVariadic",
- Repeatability: 1,
- Arguments: []interface{}{1, 2, 3, 4, 5},
- ReturnArguments: []interface{}{nil},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+4)},
- },
- {
- Parent: &mockedService.Mock,
- Method: "TheExampleMethodFuncType",
- Arguments: []interface{}{Anything},
- ReturnArguments: []interface{}{nil},
- callerInfo: []string{fmt.Sprintf("%s:%d", filename, line+7)},
- },
- }
-
- assert.Equal(t, 2, len(mockedService.ExpectedCalls))
- assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
-}
-
-func Test_Mock_Unset_WithFuncPanics(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
- mock1 := mockedService.On("TheExampleMethod", 1)
- mock1.Arguments = append(mock1.Arguments, func(string) error { return nil })
-
- assert.Panics(t, func() {
- mock1.Unset()
- })
-}
-
-func Test_Mock_Return(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethod", "A", "B", true).
- Return(1, "two", true)
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 0, call.Repeatability)
- assert.Nil(t, call.WaitFor)
-}
-
-func Test_Mock_Panic(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethod", "A", "B", true).
- Panic("panic message for example method")
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 0, call.Repeatability)
- assert.Equal(t, 0, call.Repeatability)
- assert.Equal(t, "panic message for example method", *call.PanicMsg)
- assert.Nil(t, call.WaitFor)
-}
-
-func Test_Mock_Return_WaitUntil(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
- ch := time.After(time.Second)
-
- c := mockedService.Mock.
- On("TheExampleMethod", "A", "B", true).
- WaitUntil(ch).
- Return(1, "two", true)
-
- // assert that the call was created
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 0, call.Repeatability)
- assert.Equal(t, ch, call.WaitFor)
-}
-
-func Test_Mock_Return_After(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.Mock.
- On("TheExampleMethod", "A", "B", true).
- Return(1, "two", true).
- After(time.Second)
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.Mock.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 0, call.Repeatability)
- assert.NotEqual(t, nil, call.WaitFor)
-
-}
-
-func Test_Mock_Return_Run(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- fn := func(args Arguments) {
- arg := args.Get(0).(*ExampleType)
- arg.ran = true
- }
-
- c := mockedService.Mock.
- On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
- Return(nil).
- Run(fn)
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.Mock.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod3", call.Method)
- assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0])
- assert.Equal(t, nil, call.ReturnArguments[0])
- assert.Equal(t, 0, call.Repeatability)
- assert.NotEqual(t, nil, call.WaitFor)
- assert.NotNil(t, call.Run)
-
- et := ExampleType{}
- assert.Equal(t, false, et.ran)
- mockedService.TheExampleMethod3(&et)
- assert.Equal(t, true, et.ran)
-}
-
-func Test_Mock_Return_Run_Out_Of_Order(t *testing.T) {
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
- f := func(args Arguments) {
- arg := args.Get(0).(*ExampleType)
- arg.ran = true
- }
-
- c := mockedService.Mock.
- On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
- Run(f).
- Return(nil)
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.Mock.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod3", call.Method)
- assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0])
- assert.Equal(t, nil, call.ReturnArguments[0])
- assert.Equal(t, 0, call.Repeatability)
- assert.NotEqual(t, nil, call.WaitFor)
- assert.NotNil(t, call.Run)
-}
-
-func Test_Mock_Return_Once(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.On("TheExampleMethod", "A", "B", true).
- Return(1, "two", true).
- Once()
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 1, call.Repeatability)
- assert.Nil(t, call.WaitFor)
-}
-
-func Test_Mock_Return_Twice(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethod", "A", "B", true).
- Return(1, "two", true).
- Twice()
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 2, call.Repeatability)
- assert.Nil(t, call.WaitFor)
-}
-
-func Test_Mock_Return_Times(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethod", "A", "B", true).
- Return(1, "two", true).
- Times(5)
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 1, call.ReturnArguments[0])
- assert.Equal(t, "two", call.ReturnArguments[1])
- assert.Equal(t, true, call.ReturnArguments[2])
- assert.Equal(t, 5, call.Repeatability)
- assert.Nil(t, call.WaitFor)
-}
-
-func Test_Mock_Return_Nothing(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- c := mockedService.
- On("TheExampleMethod", "A", "B", true).
- Return()
-
- require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
-
- call := mockedService.ExpectedCalls[0]
-
- assert.Equal(t, "TheExampleMethod", call.Method)
- assert.Equal(t, "A", call.Arguments[0])
- assert.Equal(t, "B", call.Arguments[1])
- assert.Equal(t, true, call.Arguments[2])
- assert.Equal(t, 0, len(call.ReturnArguments))
-}
-
-func Test_Mock_Return_NotBefore_In_Order(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- b := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil)
- c := mockedService.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(b)
-
- require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod(1, 2, 3)
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod2(true)
- })
-}
-
-func Test_Mock_Return_NotBefore_Out_Of_Order(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- b := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil).Twice()
- c := mockedService.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(b)
-
- require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
-
- expectedPanicString := `mock: Unexpected Method Call
------------------------------
-
-TheExampleMethod2(bool)
- 0: true
-
-Must not be called before:
-
-TheExampleMethod(int,int,int)
- 0: 1
- 1: 2
- 2: 3`
- require.PanicsWithValue(t, expectedPanicString, func() {
- mockedService.TheExampleMethod2(true)
- })
-}
-
-func Test_Mock_Return_NotBefore_Not_Enough_Times(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- b := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil).Twice()
- c := mockedService.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(b)
-
- require.Equal(t, []*Call{b, c}, mockedService.ExpectedCalls)
-
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod(1, 2, 3)
- })
- expectedPanicString := `mock: Unexpected Method Call
------------------------------
-
-TheExampleMethod2(bool)
- 0: true
-
-Must not be called before another call of:
-
-TheExampleMethod(int,int,int)
- 0: 1
- 1: 2
- 2: 3`
- require.PanicsWithValue(t, expectedPanicString, func() {
- mockedService.TheExampleMethod2(true)
- })
-}
-
-func Test_Mock_Return_NotBefore_Different_Mock_In_Order(t *testing.T) {
- var (
- mockedService1 = new(TestExampleImplementation)
- mockedService2 = new(TestExampleImplementation)
- )
-
- b := mockedService1.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil)
- c := mockedService2.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(b)
-
- require.Equal(t, []*Call{c}, mockedService2.ExpectedCalls)
- require.NotPanics(t, func() {
- mockedService1.TheExampleMethod(1, 2, 3)
- })
- require.NotPanics(t, func() {
- mockedService2.TheExampleMethod2(true)
- })
-}
-func Test_Mock_Return_NotBefore_Different_Mock_Out_Of_Order(t *testing.T) {
- var (
- mockedService1 = new(TestExampleImplementation)
- mockedService2 = new(TestExampleImplementation)
- )
-
- b := mockedService1.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil)
- c := mockedService2.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(b)
-
- require.Equal(t, []*Call{c}, mockedService2.ExpectedCalls)
-
- expectedPanicString := `mock: Unexpected Method Call
------------------------------
-
-TheExampleMethod2(bool)
- 0: true
-
-Must not be called before method from another mock instance:
-
-TheExampleMethod(int,int,int)
- 0: 1
- 1: 2
- 2: 3`
- require.PanicsWithValue(t, expectedPanicString, func() {
- mockedService2.TheExampleMethod2(true)
- })
-}
-
-func Test_Mock_Return_NotBefore_In_Order_With_Non_Dependant(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- a := mockedService.
- On("TheExampleMethod", 1, 2, 3).
- Return(4, nil)
- b := mockedService.
- On("TheExampleMethod", 4, 5, 6).
- Return(4, nil)
- c := mockedService.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(a, b)
- d := mockedService.
- On("TheExampleMethod7", []bool{}).Return(nil)
-
- require.Equal(t, []*Call{a, b, c, d}, mockedService.ExpectedCalls)
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod7([]bool{})
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod(1, 2, 3)
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod7([]bool{})
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod(4, 5, 6)
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod7([]bool{})
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod2(true)
- })
- require.NotPanics(t, func() {
- mockedService.TheExampleMethod7([]bool{})
- })
-}
-
-func Test_Mock_Return_NotBefore_Orphan_Call(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- require.PanicsWithValue(t, "not before calls must be created with Mock.On()", func() {
- mockedService.
- On("TheExampleMethod2", true).
- Return().
- NotBefore(&Call{Method: "Not", Arguments: Arguments{"how", "it's"}, ReturnArguments: Arguments{"done"}})
- })
-}
-
-func Test_Mock_findExpectedCall(t *testing.T) {
-
- m := new(Mock)
- m.On("One", 1).Return("one")
- m.On("Two", 2).Return("two")
- m.On("Two", 3).Return("three")
-
- f, c := m.findExpectedCall("Two", 3)
-
- if assert.Equal(t, 2, f) {
- if assert.NotNil(t, c) {
- assert.Equal(t, "Two", c.Method)
- assert.Equal(t, 3, c.Arguments[0])
- assert.Equal(t, "three", c.ReturnArguments[0])
- }
- }
-
-}
-
-func Test_Mock_findExpectedCall_For_Unknown_Method(t *testing.T) {
-
- m := new(Mock)
- m.On("One", 1).Return("one")
- m.On("Two", 2).Return("two")
- m.On("Two", 3).Return("three")
-
- f, _ := m.findExpectedCall("Two")
-
- assert.Equal(t, -1, f)
-
-}
-
-func Test_Mock_findExpectedCall_Respects_Repeatability(t *testing.T) {
-
- m := new(Mock)
- m.On("One", 1).Return("one")
- m.On("Two", 2).Return("two").Once()
- m.On("Two", 3).Return("three").Twice()
- m.On("Two", 3).Return("three").Times(8)
-
- f, c := m.findExpectedCall("Two", 3)
-
- if assert.Equal(t, 2, f) {
- if assert.NotNil(t, c) {
- assert.Equal(t, "Two", c.Method)
- assert.Equal(t, 3, c.Arguments[0])
- assert.Equal(t, "three", c.ReturnArguments[0])
- }
- }
-
- c = m.On("Once", 1).Return("one").Once()
- c.Repeatability = -1
- f, c = m.findExpectedCall("Once", 1)
- if assert.Equal(t, -1, f) {
- if assert.NotNil(t, c) {
- assert.Equal(t, "Once", c.Method)
- assert.Equal(t, 1, c.Arguments[0])
- assert.Equal(t, "one", c.ReturnArguments[0])
- }
- }
-}
-
-func Test_callString(t *testing.T) {
-
- assert.Equal(t, `Method(int,bool,string)`, callString("Method", []interface{}{1, true, "something"}, false))
- assert.Equal(t, `Method(<nil>)`, callString("Method", []interface{}{nil}, false))
-
-}
-
-func Test_Mock_Called(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_Called", 1, 2, 3).Return(5, "6", true)
-
- returnArguments := mockedService.Called(1, 2, 3)
-
- if assert.Equal(t, 1, len(mockedService.Calls)) {
- assert.Equal(t, "Test_Mock_Called", mockedService.Calls[0].Method)
- assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
- assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
- assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
- }
-
- if assert.Equal(t, 3, len(returnArguments)) {
- assert.Equal(t, 5, returnArguments[0])
- assert.Equal(t, "6", returnArguments[1])
- assert.Equal(t, true, returnArguments[2])
- }
-
-}
-
-func asyncCall(m *Mock, ch chan Arguments) {
- ch <- m.Called(1, 2, 3)
-}
-
-func Test_Mock_Called_blocks(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.Mock.On("asyncCall", 1, 2, 3).Return(5, "6", true).After(2 * time.Millisecond)
-
- ch := make(chan Arguments)
-
- go asyncCall(&mockedService.Mock, ch)
-
- select {
- case <-ch:
- t.Fatal("should have waited")
- case <-time.After(1 * time.Millisecond):
- }
-
- returnArguments := <-ch
-
- if assert.Equal(t, 1, len(mockedService.Mock.Calls)) {
- assert.Equal(t, "asyncCall", mockedService.Mock.Calls[0].Method)
- assert.Equal(t, 1, mockedService.Mock.Calls[0].Arguments[0])
- assert.Equal(t, 2, mockedService.Mock.Calls[0].Arguments[1])
- assert.Equal(t, 3, mockedService.Mock.Calls[0].Arguments[2])
- }
-
- if assert.Equal(t, 3, len(returnArguments)) {
- assert.Equal(t, 5, returnArguments[0])
- assert.Equal(t, "6", returnArguments[1])
- assert.Equal(t, true, returnArguments[2])
- }
-
-}
-
-func Test_Mock_Called_For_Bounded_Repeatability(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.
- On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3).
- Return(5, "6", true).
- Once()
- mockedService.
- On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3).
- Return(-1, "hi", false)
-
- returnArguments1 := mockedService.Called(1, 2, 3)
- returnArguments2 := mockedService.Called(1, 2, 3)
-
- if assert.Equal(t, 2, len(mockedService.Calls)) {
- assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[0].Method)
- assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
- assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
- assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
-
- assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[1].Method)
- assert.Equal(t, 1, mockedService.Calls[1].Arguments[0])
- assert.Equal(t, 2, mockedService.Calls[1].Arguments[1])
- assert.Equal(t, 3, mockedService.Calls[1].Arguments[2])
- }
-
- if assert.Equal(t, 3, len(returnArguments1)) {
- assert.Equal(t, 5, returnArguments1[0])
- assert.Equal(t, "6", returnArguments1[1])
- assert.Equal(t, true, returnArguments1[2])
- }
-
- if assert.Equal(t, 3, len(returnArguments2)) {
- assert.Equal(t, -1, returnArguments2[0])
- assert.Equal(t, "hi", returnArguments2[1])
- assert.Equal(t, false, returnArguments2[2])
- }
-
-}
-
-func Test_Mock_Called_For_SetTime_Expectation(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("TheExampleMethod", 1, 2, 3).Return(5, "6", true).Times(4)
-
- mockedService.TheExampleMethod(1, 2, 3)
- mockedService.TheExampleMethod(1, 2, 3)
- mockedService.TheExampleMethod(1, 2, 3)
- mockedService.TheExampleMethod(1, 2, 3)
- assert.Panics(t, func() {
- mockedService.TheExampleMethod(1, 2, 3)
- })
-
-}
-
-func Test_Mock_Called_Unexpected(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- // make sure it panics if no expectation was made
- assert.Panics(t, func() {
- mockedService.Called(1, 2, 3)
- }, "Calling unexpected method should panic")
-
-}
-
-func Test_AssertExpectationsForObjects_Helper(t *testing.T) {
-
- var mockedService1 = new(TestExampleImplementation)
- var mockedService2 = new(TestExampleImplementation)
- var mockedService3 = new(TestExampleImplementation)
- var mockedService4 = new(TestExampleImplementation) // No expectations does not cause a panic
-
- mockedService1.On("Test_AssertExpectationsForObjects_Helper", 1).Return()
- mockedService2.On("Test_AssertExpectationsForObjects_Helper", 2).Return()
- mockedService3.On("Test_AssertExpectationsForObjects_Helper", 3).Return()
-
- mockedService1.Called(1)
- mockedService2.Called(2)
- mockedService3.Called(3)
-
- assert.True(t, AssertExpectationsForObjects(t, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock, &mockedService4.Mock))
- assert.True(t, AssertExpectationsForObjects(t, mockedService1, mockedService2, mockedService3, mockedService4))
-
-}
-
-func Test_AssertExpectationsForObjects_Helper_Failed(t *testing.T) {
-
- var mockedService1 = new(TestExampleImplementation)
- var mockedService2 = new(TestExampleImplementation)
- var mockedService3 = new(TestExampleImplementation)
-
- mockedService1.On("Test_AssertExpectationsForObjects_Helper_Failed", 1).Return()
- mockedService2.On("Test_AssertExpectationsForObjects_Helper_Failed", 2).Return()
- mockedService3.On("Test_AssertExpectationsForObjects_Helper_Failed", 3).Return()
-
- mockedService1.Called(1)
- mockedService3.Called(3)
-
- tt := new(testing.T)
- assert.False(t, AssertExpectationsForObjects(tt, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock))
- assert.False(t, AssertExpectationsForObjects(tt, mockedService1, mockedService2, mockedService3))
-
-}
-
-func Test_Mock_AssertExpectations(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertExpectations", 1, 2, 3).Return(5, 6, 7)
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make the call now
- mockedService.Called(1, 2, 3)
-
- // now assert expectations
- assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectations_Placeholder_NoArgs(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(5, 6, 7).Once()
- mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(7, 6, 5)
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make the call now
- mockedService.Called()
-
- // now assert expectations
- assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectations_Placeholder(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertExpectations_Placeholder", 1, 2, 3).Return(5, 6, 7).Once()
- mockedService.On("Test_Mock_AssertExpectations_Placeholder", 3, 2, 1).Return(7, 6, 5)
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make the call now
- mockedService.Called(1, 2, 3)
-
- // now assert expectations
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make call to the second expectation
- mockedService.Called(3, 2, 1)
-
- // now assert expectations again
- assert.True(t, mockedService.AssertExpectations(tt))
-}
-
-func Test_Mock_AssertExpectations_With_Pointers(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{1}).Return(1)
- mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{2}).Return(2)
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- s := struct{ Foo int }{1}
- // make the calls now
- mockedService.Called(&s)
- s.Foo = 2
- mockedService.Called(&s)
-
- // now assert expectations
- assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectationsCustomType(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).Return(nil).Once()
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make the call now
- mockedService.TheExampleMethod3(&ExampleType{})
-
- // now assert expectations
- assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_AssertExpectations_With_Repeatability(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertExpectations_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Twice()
-
- tt := new(testing.T)
- assert.False(t, mockedService.AssertExpectations(tt))
-
- // make the call now
- mockedService.Called(1, 2, 3)
-
- assert.False(t, mockedService.AssertExpectations(tt))
-
- mockedService.Called(1, 2, 3)
-
- // now assert expectations
- assert.True(t, mockedService.AssertExpectations(tt))
-
-}
-
-func Test_Mock_TwoCallsWithDifferentArguments(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 1, 2, 3).Return(5, 6, 7)
- mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 4, 5, 6).Return(5, 6, 7)
-
- args1 := mockedService.Called(1, 2, 3)
- assert.Equal(t, 5, args1.Int(0))
- assert.Equal(t, 6, args1.Int(1))
- assert.Equal(t, 7, args1.Int(2))
-
- args2 := mockedService.Called(4, 5, 6)
- assert.Equal(t, 5, args2.Int(0))
- assert.Equal(t, 6, args2.Int(1))
- assert.Equal(t, 7, args2.Int(2))
-
-}
-
-func Test_Mock_AssertNumberOfCalls(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertNumberOfCalls", 1, 2, 3).Return(5, 6, 7)
-
- mockedService.Called(1, 2, 3)
- assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 1))
-
- mockedService.Called(1, 2, 3)
- assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 2))
-
-}
-
-func Test_Mock_AssertCalled(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertCalled", 1, 2, 3).Return(5, 6, 7)
-
- mockedService.Called(1, 2, 3)
-
- assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled", 1, 2, 3))
-
-}
-
-func Test_Mock_AssertCalled_WithAnythingOfTypeArgument(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.
- On("Test_Mock_AssertCalled_WithAnythingOfTypeArgument", Anything, Anything, Anything).
- Return()
-
- mockedService.Called(1, "two", []uint8("three"))
-
- assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled_WithAnythingOfTypeArgument", AnythingOfType("int"), AnythingOfType("string"), AnythingOfType("[]uint8")))
-
-}
-
-func Test_Mock_AssertCalled_WithArguments(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertCalled_WithArguments", 1, 2, 3).Return(5, 6, 7)
-
- mockedService.Called(1, 2, 3)
-
- tt := new(testing.T)
- assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 1, 2, 3))
- assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 2, 3, 4))
-
-}
-
-func Test_Mock_AssertCalled_WithArguments_With_Repeatability(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Once()
- mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4).Return(5, 6, 7).Once()
-
- mockedService.Called(1, 2, 3)
- mockedService.Called(2, 3, 4)
-
- tt := new(testing.T)
- assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3))
- assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4))
- assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 3, 4, 5))
-
-}
-
-func Test_Mock_AssertNotCalled(t *testing.T) {
-
- var mockedService = new(TestExampleImplementation)
-
- mockedService.On("Test_Mock_AssertNotCalled", 1, 2, 3).Return(5, 6, 7)
-
- mockedService.Called(1, 2, 3)
-
- assert.True(t, mockedService.AssertNotCalled(t, "Test_Mock_NotCalled"))
-
-}
-
-func Test_Mock_IsMethodCallable(t *testing.T) {
- var mockedService = new(TestExampleImplementation)
-
- arg := []Call{{Repeatability: 1}, {Repeatability: 2}}
- arg2 := []Call{{Repeatability: 1}, {Repeatability: 1}}
- arg3 := []Call{{Repeatability: 1}, {Repeatability: 1}}
-
- mockedService.On("Test_Mock_IsMethodCallable", arg2).Return(true).Twice()
-
- assert.False(t, mockedService.IsMethodCallable(t, "Test_Mock_IsMethodCallable", arg))
- assert.True(t, mockedService.IsMethodCallable(t, "Test_Mock_IsMethodCallable", arg2))
- assert.True(t, mockedService.IsMethodCallable(t, "Test_Mock_IsMethodCallable", arg3))
-
- mockedService.MethodCalled("Test_Mock_IsMethodCallable", arg2)
- mockedService.MethodCalled("Test_Mock_IsMethodCallable", arg2)
-
- assert.False(t, mockedService.IsMethodCallable(t, "Test_Mock_IsMethodCallable", arg2))
-}
-
-func TestIsArgsEqual(t *testing.T) {
- var expected = Arguments{5, 3, 4, 6, 7, 2}
- var args = make([]interface{}, 5)
- for i := 1; i < len(expected); i++ {
- args[i-1] = expected[i]
- }
- args[2] = expected[1]
- assert.False(t, isArgsEqual(expected, args))
-
- var arr = make([]interface{}, 6)
- for i := 0; i < len(expected); i++ {
- arr[i] = expected[i]
- }
- assert.True(t, isArgsEqual(expected, arr))
-}
-
-func Test_Mock_AssertOptional(t *testing.T) {
- // Optional called
- var ms1 = new(TestExampleImplementation)
- ms1.On("TheExampleMethod", 1, 2, 3).Maybe().Return(4, nil)
- ms1.TheExampleMethod(1, 2, 3)
-
- tt1 := new(testing.T)
- assert.Equal(t, true, ms1.AssertExpectations(tt1))
-
- // Optional not called
- var ms2 = new(TestExampleImplementation)
- ms2.On("TheExampleMethod", 1, 2, 3).Maybe().Return(4, nil)
-
- tt2 := new(testing.T)
- assert.Equal(t, true, ms2.AssertExpectations(tt2))
-
- // Non-optional called
- var ms3 = new(TestExampleImplementation)
- ms3.On("TheExampleMethod", 1, 2, 3).Return(4, nil)
- ms3.TheExampleMethod(1, 2, 3)
-
- tt3 := new(testing.T)
- assert.Equal(t, true, ms3.AssertExpectations(tt3))
-}
-
-/*
- Arguments helper methods
-*/
-func Test_Arguments_Get(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
-
- assert.Equal(t, "string", args.Get(0).(string))
- assert.Equal(t, 123, args.Get(1).(int))
- assert.Equal(t, true, args.Get(2).(bool))
-
-}
-
-func Test_Arguments_Is(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
-
- assert.True(t, args.Is("string", 123, true))
- assert.False(t, args.Is("wrong", 456, false))
-
-}
-
-func Test_Arguments_Diff(t *testing.T) {
-
- var args = Arguments([]interface{}{"Hello World", 123, true})
- var diff string
- var count int
- diff, count = args.Diff([]interface{}{"Hello World", 456, "false"})
-
- assert.Equal(t, 2, count)
- assert.Contains(t, diff, `(int=456) != (int=123)`)
- assert.Contains(t, diff, `(string=false) != (bool=true)`)
-
-}
-
-func Test_Arguments_Diff_DifferentNumberOfArgs(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- var diff string
- var count int
- diff, count = args.Diff([]interface{}{"string", 456, "false", "extra"})
-
- assert.Equal(t, 3, count)
- assert.Contains(t, diff, `(string=extra) != (Missing)`)
-
-}
-
-func Test_Arguments_Diff_WithAnythingArgument(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- var count int
- _, count = args.Diff([]interface{}{"string", Anything, true})
-
- assert.Equal(t, 0, count)
-
-}
-
-func Test_Arguments_Diff_WithAnythingArgument_InActualToo(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", Anything, true})
- var count int
- _, count = args.Diff([]interface{}{"string", 123, true})
-
- assert.Equal(t, 0, count)
-
-}
-
-func Test_Arguments_Diff_WithAnythingOfTypeArgument(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", AnythingOfType("int"), true})
- var count int
- _, count = args.Diff([]interface{}{"string", 123, true})
-
- assert.Equal(t, 0, count)
-
-}
-
-func Test_Arguments_Diff_WithAnythingOfTypeArgument_Failing(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", AnythingOfType("string"), true})
- var count int
- var diff string
- diff, count = args.Diff([]interface{}{"string", 123, true})
-
- assert.Equal(t, 1, count)
- assert.Contains(t, diff, `string != type int - (int=123)`)
-
-}
-
-func Test_Arguments_Diff_WithIsTypeArgument(t *testing.T) {
- var args = Arguments([]interface{}{"string", IsType(0), true})
- var count int
- _, count = args.Diff([]interface{}{"string", 123, true})
-
- assert.Equal(t, 0, count)
-}
-
-func Test_Arguments_Diff_WithIsTypeArgument_Failing(t *testing.T) {
- var args = Arguments([]interface{}{"string", IsType(""), true})
- var count int
- var diff string
- diff, count = args.Diff([]interface{}{"string", 123, true})
-
- assert.Equal(t, 1, count)
- assert.Contains(t, diff, `string != type int - (int=123)`)
-}
-
-func Test_Arguments_Diff_WithArgMatcher(t *testing.T) {
- matchFn := func(a int) bool {
- return a == 123
- }
- var args = Arguments([]interface{}{"string", MatchedBy(matchFn), true})
-
- diff, count := args.Diff([]interface{}{"string", 124, true})
- assert.Equal(t, 1, count)
- assert.Contains(t, diff, `(int=124) not matched by func(int) bool`)
-
- diff, count = args.Diff([]interface{}{"string", false, true})
- assert.Equal(t, 1, count)
- assert.Contains(t, diff, `(bool=false) not matched by func(int) bool`)
-
- diff, count = args.Diff([]interface{}{"string", 123, false})
- assert.Equal(t, 1, count)
- assert.Contains(t, diff, `(int=123) matched by func(int) bool`)
-
- diff, count = args.Diff([]interface{}{"string", 123, true})
- assert.Equal(t, 0, count)
- assert.Contains(t, diff, `No differences.`)
-}
-
-func Test_Arguments_Assert(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
-
- assert.True(t, args.Assert(t, "string", 123, true))
-
-}
-
-func Test_Arguments_String_Representation(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- assert.Equal(t, `string,int,bool`, args.String())
-
-}
-
-func Test_Arguments_String(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- assert.Equal(t, "string", args.String(0))
-
-}
-
-func Test_Arguments_Error(t *testing.T) {
-
- var err = errors.New("An Error")
- var args = Arguments([]interface{}{"string", 123, true, err})
- assert.Equal(t, err, args.Error(3))
-
-}
-
-func Test_Arguments_Error_Nil(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true, nil})
- assert.Equal(t, nil, args.Error(3))
-
-}
-
-func Test_Arguments_Int(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- assert.Equal(t, 123, args.Int(1))
-
-}
-
-func Test_Arguments_Bool(t *testing.T) {
-
- var args = Arguments([]interface{}{"string", 123, true})
- assert.Equal(t, true, args.Bool(2))
-
-}
-
-func Test_WaitUntil_Parallel(t *testing.T) {
-
- // make a test impl object
- var mockedService = new(TestExampleImplementation)
-
- ch1 := make(chan time.Time)
- ch2 := make(chan time.Time)
-
- mockedService.Mock.On("TheExampleMethod2", true).Return().WaitUntil(ch2).Run(func(args Arguments) {
- ch1 <- time.Now()
- })
-
- mockedService.Mock.On("TheExampleMethod2", false).Return().WaitUntil(ch1)
-
- // Lock both goroutines on the .WaitUntil method
- go func() {
- mockedService.TheExampleMethod2(false)
- }()
- go func() {
- mockedService.TheExampleMethod2(true)
- }()
-
- // Allow the first call to execute, so the second one executes afterwards
- ch2 <- time.Now()
-}
-
-func Test_MockMethodCalled(t *testing.T) {
- m := new(Mock)
- m.On("foo", "hello").Return("world")
-
- retArgs := m.MethodCalled("foo", "hello")
- require.True(t, len(retArgs) == 1)
- require.Equal(t, "world", retArgs[0])
- m.AssertExpectations(t)
-}
-
-func Test_MockMethodCalled_Panic(t *testing.T) {
- m := new(Mock)
- m.On("foo", "hello").Panic("world panics")
-
- require.PanicsWithValue(t, "world panics", func() { m.MethodCalled("foo", "hello") })
- m.AssertExpectations(t)
-}
-
-// Test to validate fix for racy concurrent call access in MethodCalled()
-func Test_MockReturnAndCalledConcurrent(t *testing.T) {
- iterations := 1000
- m := &Mock{}
- call := m.On("ConcurrencyTestMethod")
-
- wg := sync.WaitGroup{}
- wg.Add(2)
-
- go func() {
- for i := 0; i < iterations; i++ {
- call.Return(10)
- }
- wg.Done()
- }()
- go func() {
- for i := 0; i < iterations; i++ {
- ConcurrencyTestMethod(m)
- }
- wg.Done()
- }()
- wg.Wait()
-}
-
-type timer struct{ Mock }
-
-func (s *timer) GetTime(i int) string {
- return s.Called(i).Get(0).(string)
-}
-
-func (s *timer) GetTimes(times []int) string {
- return s.Called(times).Get(0).(string)
-}
-
-type tCustomLogger struct {
- *testing.T
- logs []string
- errs []string
-}
-
-func (tc *tCustomLogger) Logf(format string, args ...interface{}) {
- tc.T.Logf(format, args...)
- tc.logs = append(tc.logs, fmt.Sprintf(format, args...))
-}
-
-func (tc *tCustomLogger) Errorf(format string, args ...interface{}) {
- tc.errs = append(tc.errs, fmt.Sprintf(format, args...))
-}
-
-func (tc *tCustomLogger) FailNow() {}
-
-func TestLoggingAssertExpectations(t *testing.T) {
- m := new(timer)
- m.On("GetTime", 0).Return("")
- tcl := &tCustomLogger{t, []string{}, []string{}}
-
- AssertExpectationsForObjects(tcl, m, new(TestExampleImplementation))
-
- require.Equal(t, 1, len(tcl.errs))
- assert.Regexp(t, regexp.MustCompile("(?s)FAIL: 0 out of 1 expectation\\(s\\) were met.*The code you are testing needs to make 1 more call\\(s\\).*"), tcl.errs[0])
- require.Equal(t, 2, len(tcl.logs))
- assert.Regexp(t, regexp.MustCompile("(?s)FAIL:\tGetTime\\(int\\).*"), tcl.logs[0])
- require.Equal(t, "Expectations didn't match for Mock: *mock.timer", tcl.logs[1])
-}
-
-func TestAfterTotalWaitTimeWhileExecution(t *testing.T) {
- waitDuration := 1
- total, waitMs := 5, time.Millisecond*time.Duration(waitDuration)
- aTimer := new(timer)
- for i := 0; i < total; i++ {
- aTimer.On("GetTime", i).After(waitMs).Return(fmt.Sprintf("Time%d", i)).Once()
- }
- time.Sleep(waitMs)
- start := time.Now()
- var results []string
-
- for i := 0; i < total; i++ {
- results = append(results, aTimer.GetTime(i))
- }
-
- end := time.Now()
- elapsedTime := end.Sub(start)
- assert.True(t, elapsedTime > waitMs, fmt.Sprintf("Total elapsed time:%v should be atleast greater than %v", elapsedTime, waitMs))
- assert.Equal(t, total, len(results))
- for i := range results {
- assert.Equal(t, fmt.Sprintf("Time%d", i), results[i], "Return value of method should be same")
- }
-}
-
-func TestArgumentMatcherToPrintMismatch(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- matchingExp := regexp.MustCompile(
- `\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool`)
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(timer)
- m.On("GetTime", MatchedBy(func(i int) bool { return false })).Return("SomeTime").Once()
-
- res := m.GetTime(1)
- require.Equal(t, "SomeTime", res)
- m.AssertExpectations(t)
-}
-
-func TestArgumentMatcherToPrintMismatchWithReferenceType(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- matchingExp := regexp.MustCompile(
- `\s+mock: Unexpected Method Call\s+-*\s+GetTimes\(\[\]int\)\s+0: \[\]int\{1\}\s+The closest call I have is:\s+GetTimes\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(\[\]int=\[1\]\) not matched by func\(\[\]int\) bool`)
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(timer)
- m.On("GetTimes", MatchedBy(func(_ []int) bool { return false })).Return("SomeTime").Once()
-
- res := m.GetTimes([]int{1})
- require.Equal(t, "SomeTime", res)
- m.AssertExpectations(t)
-}
-
-func TestClosestCallMismatchedArgumentInformationShowsTheClosest(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod(int,int,int)`, `0: 1\s+1: 1\s+2: 2`, `0: 1\s+1: 1\s+2: 1`, `Diff: 0: PASS: \(int=1\) == \(int=1\)\s+1: PASS: \(int=1\) == \(int=1\)\s+2: FAIL: \(int=2\) != \(int=1\)`))
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(TestExampleImplementation)
- m.On("TheExampleMethod", 1, 1, 1).Return(1, nil).Once()
- m.On("TheExampleMethod", 2, 2, 2).Return(2, nil).Once()
-
- m.TheExampleMethod(1, 1, 2)
-}
-
-func TestClosestCallFavorsFirstMock(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -2,4 \+2,4 @@\s+\(bool\) true,\s+- \(bool\) true,\s+- \(bool\) true\s+\+ \(bool\) false,\s+\+ \(bool\) false\s+}\s+`
- matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, false, false}`, `0: \[\]bool{true, true, true}`, diffRegExp))
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(TestExampleImplementation)
- m.On("TheExampleMethod7", []bool{true, true, true}).Return(nil).Once()
- m.On("TheExampleMethod7", []bool{false, false, false}).Return(nil).Once()
-
- m.TheExampleMethod7([]bool{true, false, false})
-}
-
-func TestClosestCallUsesRepeatabilityToFindClosest(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -1,4 \+1,4 @@\s+\(\[\]bool\) \(len=3\) {\s+- \(bool\) false,\s+- \(bool\) false,\s+\+ \(bool\) true,\s+\+ \(bool\) true,\s+\(bool\) false\s+`
- matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, true, false}`, `0: \[\]bool{false, false, false}`, diffRegExp))
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(TestExampleImplementation)
- m.On("TheExampleMethod7", []bool{true, true, true}).Return(nil).Once()
- m.On("TheExampleMethod7", []bool{false, false, false}).Return(nil).Once()
-
- m.TheExampleMethod7([]bool{true, true, true})
-
- // Since the first mocked call has already been used, it now has no repeatability,
- // thus the second mock should be shown as the closest match
- m.TheExampleMethod7([]bool{true, true, false})
-}
-
-func TestClosestCallMismatchedArgumentValueInformation(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- matchingExp := regexp.MustCompile(unexpectedCallRegex(`GetTime(int)`, "0: 1", "0: 999", `Diff: 0: FAIL: \(int=1\) != \(int=999\)`))
- assert.Regexp(t, matchingExp, r)
- }
- }()
-
- m := new(timer)
- m.On("GetTime", 999).Return("SomeTime").Once()
-
- _ = m.GetTime(1)
-}
-
-func Test_isBetterMatchThanReturnsFalseIfCandidateCallIsNil(t *testing.T) {
- assert.False(t, matchCandidate{}.isBetterMatchThan(matchCandidate{}))
-}
-
-func Test_isBetterMatchThanReturnsTrueIfOtherCandidateCallIsNil(t *testing.T) {
- assert.True(t, matchCandidate{call: &Call{}}.isBetterMatchThan(matchCandidate{}))
-}
-
-func Test_isBetterMatchThanReturnsFalseIfDiffCountIsGreaterThanOther(t *testing.T) {
- assert.False(t, matchCandidate{call: &Call{}, diffCount: 2}.isBetterMatchThan(matchCandidate{call: &Call{}, diffCount: 1}))
-}
-
-func Test_isBetterMatchThanReturnsTrueIfDiffCountIsLessThanOther(t *testing.T) {
- assert.True(t, matchCandidate{call: &Call{}, diffCount: 1}.isBetterMatchThan(matchCandidate{call: &Call{}, diffCount: 2}))
-}
-
-func Test_isBetterMatchThanReturnsTrueIfRepeatabilityIsGreaterThanOther(t *testing.T) {
- assert.True(t, matchCandidate{call: &Call{Repeatability: 1}, diffCount: 1}.isBetterMatchThan(matchCandidate{call: &Call{Repeatability: -1}, diffCount: 1}))
-}
-
-func Test_isBetterMatchThanReturnsFalseIfRepeatabilityIsLessThanOrEqualToOther(t *testing.T) {
- assert.False(t, matchCandidate{call: &Call{Repeatability: 1}, diffCount: 1}.isBetterMatchThan(matchCandidate{call: &Call{Repeatability: 1}, diffCount: 1}))
-}
-
-func unexpectedCallRegex(method, calledArg, expectedArg, diff string) string {
- rMethod := regexp.QuoteMeta(method)
- return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+%s`,
- rMethod, calledArg, rMethod, expectedArg, diff)
-}
-
-//go:noinline
-func ConcurrencyTestMethod(m *Mock) {
- m.Called()
-}
-
-func TestConcurrentArgumentRead(t *testing.T) {
- methodUnderTest := func(c caller, u user) {
- go u.Use(c)
- c.Call()
- }
-
- c := &mockCaller{}
- defer c.AssertExpectations(t)
-
- u := &mockUser{}
- defer u.AssertExpectations(t)
-
- done := make(chan struct{})
-
- c.On("Call").Return().Once()
- u.On("Use", c).Return().Once().Run(func(args Arguments) { close(done) })
-
- methodUnderTest(c, u)
- <-done // wait until Use is called or assertions will fail
-}
-
-type caller interface {
- Call()
-}
-
-type mockCaller struct{ Mock }
-
-func (m *mockCaller) Call() { m.Called() }
-
-type user interface {
- Use(caller)
-}
-
-type mockUser struct{ Mock }
-
-func (m *mockUser) Use(c caller) { m.Called(c) }
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/package_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/package_test.go
deleted file mode 100644
index f17ff153e1406c90a880e0fc6290b27f87ee2028..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/package_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package testify
-
-import (
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestImports(t *testing.T) {
- if assert.Equal(t, 1, 1) != true {
- t.Error("Something is wrong.")
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/doc.go
deleted file mode 100644
index 169de39221c73123409330785477fdee95131445..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/doc.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Package require implements the same assertions as the `assert` package but
-// stops test execution when a test fails.
-//
-// Example Usage
-//
-// The following is a complete example using require in a standard test function:
-// import (
-// "testing"
-// "github.com/stretchr/testify/require"
-// )
-//
-// func TestSomething(t *testing.T) {
-//
-// var a string = "Hello"
-// var b string = "Hello"
-//
-// require.Equal(t, a, b, "The two words should be the same.")
-//
-// }
-//
-// Assertions
-//
-// The `require` package have same global functions as in the `assert` package,
-// but instead of returning a boolean result they call `t.FailNow()`.
-//
-// Every assertion function also takes an optional string message as the final argument,
-// allowing custom error messages to be appended to the message the assertion method outputs.
-package require
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements.go
deleted file mode 100644
index 1dcb2338c4c4627f67b6a981a6fd38a76833b20c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package require
-
-// Assertions provides assertion methods around the
-// TestingT interface.
-type Assertions struct {
- t TestingT
-}
-
-// New makes a new Assertions object for the specified TestingT.
-func New(t TestingT) *Assertions {
- return &Assertions{
- t: t,
- }
-}
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs"
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements_test.go
deleted file mode 100644
index 8fbcc153033225ea73c62386284288baadcefb74..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/forward_requirements_test.go
+++ /dev/null
@@ -1,523 +0,0 @@
-package require
-
-import (
- "errors"
- "testing"
- "time"
-)
-
-func TestImplementsWrapper(t *testing.T) {
- require := New(t)
-
- require.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestIsTypeWrapper(t *testing.T) {
- require := New(t)
- require.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualWrapper(t *testing.T) {
- require := New(t)
- require.Equal(1, 1)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Equal(1, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEqualWrapper(t *testing.T) {
- require := New(t)
- require.NotEqual(1, 2)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotEqual(2, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestExactlyWrapper(t *testing.T) {
- require := New(t)
-
- a := float32(1)
- b := float32(1)
- c := float64(1)
-
- require.Exactly(a, b)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Exactly(a, c)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotNilWrapper(t *testing.T) {
- require := New(t)
- require.NotNil(t, new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotNil(nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNilWrapper(t *testing.T) {
- require := New(t)
- require.Nil(nil)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Nil(new(AssertionTesterConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestTrueWrapper(t *testing.T) {
- require := New(t)
- require.True(true)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.True(false)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestFalseWrapper(t *testing.T) {
- require := New(t)
- require.False(false)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.False(true)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestContainsWrapper(t *testing.T) {
- require := New(t)
- require.Contains("Hello World", "Hello")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Contains("Hello World", "Salut")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotContainsWrapper(t *testing.T) {
- require := New(t)
- require.NotContains("Hello World", "Hello!")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotContains("Hello World", "Hello")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestPanicsWrapper(t *testing.T) {
- require := New(t)
- require.Panics(func() {
- panic("Panic!")
- })
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Panics(func() {})
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotPanicsWrapper(t *testing.T) {
- require := New(t)
- require.NotPanics(func() {})
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotPanics(func() {
- panic("Panic!")
- })
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNoErrorWrapper(t *testing.T) {
- require := New(t)
- require.NoError(nil)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NoError(errors.New("some error"))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorWrapper(t *testing.T) {
- require := New(t)
- require.Error(errors.New("some error"))
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Error(nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorContainsWrapper(t *testing.T) {
- require := New(t)
- require.ErrorContains(errors.New("some error: another error"), "some error")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.ErrorContains(errors.New("some error: another error"), "different error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualErrorWrapper(t *testing.T) {
- require := New(t)
- require.EqualError(errors.New("some error"), "some error")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.EqualError(errors.New("some error"), "Not some error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEmptyWrapper(t *testing.T) {
- require := New(t)
- require.Empty("")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Empty("x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEmptyWrapper(t *testing.T) {
- require := New(t)
- require.NotEmpty("x")
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotEmpty("")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestWithinDurationWrapper(t *testing.T) {
- require := New(t)
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- require.WithinDuration(a, b, 15*time.Second)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.WithinDuration(a, b, 5*time.Second)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestInDeltaWrapper(t *testing.T) {
- require := New(t)
- require.InDelta(1.001, 1, 0.01)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.InDelta(1, 2, 0.5)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestZeroWrapper(t *testing.T) {
- require := New(t)
- require.Zero(0)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.Zero(1)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotZeroWrapper(t *testing.T) {
- require := New(t)
- require.NotZero(1)
-
- mockT := new(MockT)
- mockRequire := New(mockT)
- mockRequire.NotZero(0)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_EqualSONString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_Array(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`{"foo": "bar"}`, "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq("Not JSON", "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEqWrapper_EqualYAMLString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEqWrapper_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEqWrapper_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- expected := `
-numeric: 1.5
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-`
-
- actual := `
-numeric: 1.5
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-`
-
- mockRequire.YAMLEq(expected, actual)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEqWrapper_Array(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEqWrapper_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEqWrapper_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEqWrapper_ActualIsSimpleString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`{"foo": "bar"}`, "Simple String")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEqWrapper_ExpectedIsSimpleString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq("Simple String", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEqWrapper_ExpectedAndActualSimpleString(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq("Simple String", "Simple String")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEqWrapper_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- mockRequire := New(mockT)
-
- mockRequire.YAMLEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go
deleted file mode 100644
index 880853f5a2c59901bcb82fb099bb0f1eace5b2fe..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go
+++ /dev/null
@@ -1,1935 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package require
-
-import (
- assert "github.com/stretchr/testify/assert"
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Condition(t, comp, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func Conditionf(t TestingT, comp assert.Comparison, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Conditionf(t, comp, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Contains(t, "Hello World", "World")
-// assert.Contains(t, ["Hello", "World"], "World")
-// assert.Contains(t, {"Hello": "World"}, "Hello")
-func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Contains(t, s, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
-// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
-// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
-func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Containsf(t, s, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.DirExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func DirExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.DirExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])
-func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ElementsMatch(t, listA, listB, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ElementsMatchf(t, listA, listB, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Empty(t, obj)
-func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Empty(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// assert.Emptyf(t, obj, "error message %s", "formatted")
-func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Emptyf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Equal asserts that two objects are equal.
-//
-// assert.Equal(t, 123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Equal(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualError(t, err, expectedErrorString)
-func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualError(t, theError, errString, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted")
-func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualErrorf(t, theError, errString, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// assert.EqualValues(t, uint32(123), int32(123))
-func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualValues(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
-func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.EqualValuesf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Equalf asserts that two objects are equal.
-//
-// assert.Equalf(t, 123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Equalf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Error(t, err) {
-// assert.Equal(t, expectedError, err)
-// }
-func Error(t TestingT, err error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Error(t, err, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorAs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorAsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContains(t, err, expectedErrorSubString)
-func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorContains(t, theError, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// assert.ErrorContainsf(t, err, expectedErrorSubString, "error message %s", "formatted")
-func ErrorContainsf(t TestingT, theError error, contains string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorContainsf(t, theError, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorIs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.ErrorIsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.Errorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func Errorf(t TestingT, err error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Errorf(t, err, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)
-func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Eventually(t, condition, waitFor, tick, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// assert.Eventuallyf(t, func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Eventuallyf(t, condition, waitFor, tick, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// assert.Exactly(t, int32(123), int64(123))
-func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Exactly(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// assert.Exactlyf(t, int32(123), int64(123), "error message %s", "formatted")
-func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Exactlyf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Fail reports a failure through
-func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Fail(t, failureMessage, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FailNow fails test
-func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FailNow(t, failureMessage, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FailNowf fails test
-func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FailNowf(t, failureMessage, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Failf reports a failure through
-func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Failf(t, failureMessage, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// False asserts that the specified value is false.
-//
-// assert.False(t, myBool)
-func False(t TestingT, value bool, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.False(t, value, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Falsef asserts that the specified value is false.
-//
-// assert.Falsef(t, myBool, "error message %s", "formatted")
-func Falsef(t TestingT, value bool, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Falsef(t, value, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FileExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func FileExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.FileExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// assert.Greater(t, 2, 1)
-// assert.Greater(t, float64(2), float64(1))
-// assert.Greater(t, "b", "a")
-func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Greater(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqual(t, 2, 1)
-// assert.GreaterOrEqual(t, 2, 2)
-// assert.GreaterOrEqual(t, "b", "a")
-// assert.GreaterOrEqual(t, "b", "b")
-func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.GreaterOrEqual(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// assert.GreaterOrEqualf(t, 2, 1, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "a", "error message %s", "formatted")
-// assert.GreaterOrEqualf(t, "b", "b", "error message %s", "formatted")
-func GreaterOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.GreaterOrEqualf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// assert.Greaterf(t, 2, 1, "error message %s", "formatted")
-// assert.Greaterf(t, float64(2), float64(1), "error message %s", "formatted")
-// assert.Greaterf(t, "b", "a", "error message %s", "formatted")
-func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Greaterf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyContains(t, handler, method, url, values, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyContainsf(t, handler, method, url, values, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyNotContains(t, handler, method, url, values, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPBodyNotContainsf(t, handler, method, url, values, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPError(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPErrorf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPRedirect(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPRedirectf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPStatusCode(t, handler, method, url, values, statuscode, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// assert.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPStatusCodef(t, handler, method, url, values, statuscode, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPSuccess(t, handler, method, url, values, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.HTTPSuccessf(t, handler, method, url, values, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// assert.Implements(t, (*MyInterface)(nil), new(MyObject))
-func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Implements(t, interfaceObject, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// assert.Implementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Implementsf(t, interfaceObject, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// assert.InDelta(t, math.Pi, 22/7.0, 0.01)
-func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDelta(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValues(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaMapValues(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaMapValuesf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaSlicef(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// assert.InDeltaf(t, math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InDeltaf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonSlicef(t, expected, actual, epsilon, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.InEpsilonf(t, expected, actual, epsilon, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// assert.IsDecreasing(t, []int{2, 1, 0})
-// assert.IsDecreasing(t, []float{2, 1})
-// assert.IsDecreasing(t, []string{"b", "a"})
-func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsDecreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// assert.IsDecreasingf(t, []int{2, 1, 0}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsDecreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsDecreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// assert.IsIncreasing(t, []int{1, 2, 3})
-// assert.IsIncreasing(t, []float{1, 2})
-// assert.IsIncreasing(t, []string{"a", "b"})
-func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsIncreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// assert.IsIncreasingf(t, []int{1, 2, 3}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsIncreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsIncreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasing(t, []int{1, 1, 2})
-// assert.IsNonDecreasing(t, []float{1, 2})
-// assert.IsNonDecreasing(t, []string{"a", "b"})
-func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonDecreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// assert.IsNonDecreasingf(t, []int{1, 1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []float{1, 2}, "error message %s", "formatted")
-// assert.IsNonDecreasingf(t, []string{"a", "b"}, "error message %s", "formatted")
-func IsNonDecreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonDecreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// assert.IsNonIncreasing(t, []int{2, 1, 1})
-// assert.IsNonIncreasing(t, []float{2, 1})
-// assert.IsNonIncreasing(t, []string{"b", "a"})
-func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonIncreasing(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// assert.IsNonIncreasingf(t, []int{2, 1, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []float{2, 1}, "error message %s", "formatted")
-// assert.IsNonIncreasingf(t, []string{"b", "a"}, "error message %s", "formatted")
-func IsNonIncreasingf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsNonIncreasingf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// IsType asserts that the specified objects are of the same type.
-func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsType(t, expectedType, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.IsTypef(t, expectedType, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.JSONEq(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.JSONEqf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// assert.Len(t, mySlice, 3)
-func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Len(t, object, length, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
-func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Lenf(t, object, length, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Less asserts that the first element is less than the second
-//
-// assert.Less(t, 1, 2)
-// assert.Less(t, float64(1), float64(2))
-// assert.Less(t, "a", "b")
-func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Less(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqual(t, 1, 2)
-// assert.LessOrEqual(t, 2, 2)
-// assert.LessOrEqual(t, "a", "b")
-// assert.LessOrEqual(t, "b", "b")
-func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.LessOrEqual(t, e1, e2, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// assert.LessOrEqualf(t, 1, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, 2, 2, "error message %s", "formatted")
-// assert.LessOrEqualf(t, "a", "b", "error message %s", "formatted")
-// assert.LessOrEqualf(t, "b", "b", "error message %s", "formatted")
-func LessOrEqualf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.LessOrEqualf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// assert.Lessf(t, 1, 2, "error message %s", "formatted")
-// assert.Lessf(t, float64(1), float64(2), "error message %s", "formatted")
-// assert.Lessf(t, "a", "b", "error message %s", "formatted")
-func Lessf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Lessf(t, e1, e2, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Negative asserts that the specified element is negative
-//
-// assert.Negative(t, -1)
-// assert.Negative(t, -1.23)
-func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Negative(t, e, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Negativef asserts that the specified element is negative
-//
-// assert.Negativef(t, -1, "error message %s", "formatted")
-// assert.Negativef(t, -1.23, "error message %s", "formatted")
-func Negativef(t TestingT, e interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Negativef(t, e, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)
-func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Never(t, condition, waitFor, tick, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// assert.Neverf(t, func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func Neverf(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Neverf(t, condition, waitFor, tick, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Nil asserts that the specified object is nil.
-//
-// assert.Nil(t, err)
-func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Nil(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// assert.Nilf(t, err, "error message %s", "formatted")
-func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Nilf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoDirExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoDirExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoError(t, err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoError(t, err, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if assert.NoErrorf(t, err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func NoErrorf(t TestingT, err error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoErrorf(t, err, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExists(t TestingT, path string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoFileExists(t, path, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func NoFileExistsf(t TestingT, path string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NoFileExistsf(t, path, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContains(t, "Hello World", "Earth")
-// assert.NotContains(t, ["Hello", "World"], "Earth")
-// assert.NotContains(t, {"Hello": "World"}, "Earth")
-func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotContains(t, s, contains, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
-// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
-func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotContainsf(t, s, contains, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmpty(t, obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEmpty(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEmptyf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// assert.NotEqual(t, obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqual(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValues(t, obj1, obj2)
-func NotEqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualValues(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// assert.NotEqualValuesf(t, obj1, obj2, "error message %s", "formatted")
-func NotEqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualValuesf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotEqualf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIs(t TestingT, err error, target error, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotErrorIs(t, err, target, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotErrorIsf(t, err, target, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// assert.NotNil(t, err)
-func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotNil(t, object, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// assert.NotNilf(t, err, "error message %s", "formatted")
-func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotNilf(t, object, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanics(t, func(){ RemainCalm() })
-func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotPanics(t, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
-func NotPanicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotPanicsf(t, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
-// assert.NotRegexp(t, "^start", "it's not starting")
-func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotRegexp(t, rx, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// assert.NotRegexpf(t, regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
-func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotRegexpf(t, rx, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// assert.NotSame(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSame(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSame(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// assert.NotSamef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSamef(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
-func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSubset(t, list, subset, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotSubsetf(t, list, subset, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotZero(t, i, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.NotZerof(t, i, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panics(t, func(){ GoCrazy() })
-func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Panics(t, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithError(t, errString, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// assert.PanicsWithErrorf(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithErrorf(t TestingT, errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithErrorf(t, errString, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })
-func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithValue(t, expected, f, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func PanicsWithValuef(t TestingT, expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.PanicsWithValuef(t, expected, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
-func Panicsf(t TestingT, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Panicsf(t, f, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Positive asserts that the specified element is positive
-//
-// assert.Positive(t, 1)
-// assert.Positive(t, 1.23)
-func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Positive(t, e, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Positivef asserts that the specified element is positive
-//
-// assert.Positivef(t, 1, "error message %s", "formatted")
-// assert.Positivef(t, 1.23, "error message %s", "formatted")
-func Positivef(t TestingT, e interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Positivef(t, e, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
-// assert.Regexp(t, "start...$", "it's not starting")
-func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Regexp(t, rx, str, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// assert.Regexpf(t, regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
-func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Regexpf(t, rx, str, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// assert.Same(t, ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Same(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Same(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// assert.Samef(t, ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func Samef(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Samef(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
-func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Subset(t, list, subset, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Subsetf(t, list, subset, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// True asserts that the specified value is true.
-//
-// assert.True(t, myBool)
-func True(t TestingT, value bool, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.True(t, value, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Truef asserts that the specified value is true.
-//
-// assert.Truef(t, myBool, "error message %s", "formatted")
-func Truef(t TestingT, value bool, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Truef(t, value, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)
-func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinDurationf(t, expected, actual, delta, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func WithinRange(t TestingT, actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinRange(t, actual, start, end, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// assert.WithinRangef(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.WithinRangef(t, actual, start, end, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// YAMLEq asserts that two YAML strings are equivalent.
-func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.YAMLEq(t, expected, actual, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// YAMLEqf asserts that two YAML strings are equivalent.
-func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.YAMLEqf(t, expected, actual, msg, args...) {
- return
- }
- t.FailNow()
-}
-
-// Zero asserts that i is the zero value for its type.
-func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Zero(t, i, msgAndArgs...) {
- return
- }
- t.FailNow()
-}
-
-// Zerof asserts that i is the zero value for its type.
-func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) {
- if h, ok := t.(tHelper); ok {
- h.Helper()
- }
- if assert.Zerof(t, i, msg, args...) {
- return
- }
- t.FailNow()
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go.tmpl b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go.tmpl
deleted file mode 100644
index 55e42ddebdc45db4a80e88cf35b10b9b852e1460..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require.go.tmpl
+++ /dev/null
@@ -1,6 +0,0 @@
-{{.Comment}}
-func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
- if h, ok := t.(tHelper); ok { h.Helper() }
- if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
- t.FailNow()
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go
deleted file mode 100644
index 960bf6f2cabfe777267733dcd6b321529cac3402..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go
+++ /dev/null
@@ -1,1515 +0,0 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
-
-package require
-
-import (
- assert "github.com/stretchr/testify/assert"
- http "net/http"
- url "net/url"
- time "time"
-)
-
-// Condition uses a Comparison to assert a complex condition.
-func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Condition(a.t, comp, msgAndArgs...)
-}
-
-// Conditionf uses a Comparison to assert a complex condition.
-func (a *Assertions) Conditionf(comp assert.Comparison, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Conditionf(a.t, comp, msg, args...)
-}
-
-// Contains asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Contains("Hello World", "World")
-// a.Contains(["Hello", "World"], "World")
-// a.Contains({"Hello": "World"}, "Hello")
-func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Contains(a.t, s, contains, msgAndArgs...)
-}
-
-// Containsf asserts that the specified string, list(array, slice...) or map contains the
-// specified substring or element.
-//
-// a.Containsf("Hello World", "World", "error message %s", "formatted")
-// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
-// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
-func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Containsf(a.t, s, contains, msg, args...)
-}
-
-// DirExists checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- DirExists(a.t, path, msgAndArgs...)
-}
-
-// DirExistsf checks whether a directory exists in the given path. It also fails
-// if the path is a file rather a directory or there is an error checking whether it exists.
-func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- DirExistsf(a.t, path, msg, args...)
-}
-
-// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])
-func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ElementsMatch(a.t, listA, listB, msgAndArgs...)
-}
-
-// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified
-// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements,
-// the number of appearances of each of them in both lists should match.
-//
-// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted")
-func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ElementsMatchf(a.t, listA, listB, msg, args...)
-}
-
-// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Empty(obj)
-func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Empty(a.t, object, msgAndArgs...)
-}
-
-// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// a.Emptyf(obj, "error message %s", "formatted")
-func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Emptyf(a.t, object, msg, args...)
-}
-
-// Equal asserts that two objects are equal.
-//
-// a.Equal(123, 123)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Equal(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualError asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualError(err, expectedErrorString)
-func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualError(a.t, theError, errString, msgAndArgs...)
-}
-
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
-// and that it is equal to the provided error.
-//
-// actualObj, err := SomeFunction()
-// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted")
-func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualErrorf(a.t, theError, errString, msg, args...)
-}
-
-// EqualValues asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// a.EqualValues(uint32(123), int32(123))
-func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// EqualValuesf asserts that two objects are equal or convertable to the same types
-// and equal.
-//
-// a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
-func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- EqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// Equalf asserts that two objects are equal.
-//
-// a.Equalf(123, 123, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses). Function equality
-// cannot be determined and will always fail.
-func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Equalf(a.t, expected, actual, msg, args...)
-}
-
-// Error asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Error(err) {
-// assert.Equal(t, expectedError, err)
-// }
-func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Error(a.t, err, msgAndArgs...)
-}
-
-// ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorAs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorAsf asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.
-// This is a wrapper for errors.As.
-func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorAsf(a.t, err, target, msg, args...)
-}
-
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContains(err, expectedErrorSubString)
-func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorContains(a.t, theError, contains, msgAndArgs...)
-}
-
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
-//
-// actualObj, err := SomeFunction()
-// a.ErrorContainsf(err, expectedErrorSubString, "error message %s", "formatted")
-func (a *Assertions) ErrorContainsf(theError error, contains string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorContainsf(a.t, theError, contains, msg, args...)
-}
-
-// ErrorIs asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// ErrorIsf asserts that at least one of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- ErrorIsf(a.t, err, target, msg, args...)
-}
-
-// Errorf asserts that a function returned an error (i.e. not `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.Errorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedErrorf, err)
-// }
-func (a *Assertions) Errorf(err error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Errorf(a.t, err, msg, args...)
-}
-
-// Eventually asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Eventually(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Eventuallyf asserts that given condition will be met in waitFor time,
-// periodically checking target function each tick.
-//
-// a.Eventuallyf(func() bool { return true; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Eventuallyf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Eventuallyf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Exactly asserts that two objects are equal in value and type.
-//
-// a.Exactly(int32(123), int64(123))
-func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Exactly(a.t, expected, actual, msgAndArgs...)
-}
-
-// Exactlyf asserts that two objects are equal in value and type.
-//
-// a.Exactlyf(int32(123), int64(123), "error message %s", "formatted")
-func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Exactlyf(a.t, expected, actual, msg, args...)
-}
-
-// Fail reports a failure through
-func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Fail(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNow fails test
-func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FailNow(a.t, failureMessage, msgAndArgs...)
-}
-
-// FailNowf fails test
-func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FailNowf(a.t, failureMessage, msg, args...)
-}
-
-// Failf reports a failure through
-func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Failf(a.t, failureMessage, msg, args...)
-}
-
-// False asserts that the specified value is false.
-//
-// a.False(myBool)
-func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- False(a.t, value, msgAndArgs...)
-}
-
-// Falsef asserts that the specified value is false.
-//
-// a.Falsef(myBool, "error message %s", "formatted")
-func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Falsef(a.t, value, msg, args...)
-}
-
-// FileExists checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FileExists(a.t, path, msgAndArgs...)
-}
-
-// FileExistsf checks whether a file exists in the given path. It also fails if
-// the path points to a directory or there is an error when trying to check the file.
-func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- FileExistsf(a.t, path, msg, args...)
-}
-
-// Greater asserts that the first element is greater than the second
-//
-// a.Greater(2, 1)
-// a.Greater(float64(2), float64(1))
-// a.Greater("b", "a")
-func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Greater(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqual asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqual(2, 1)
-// a.GreaterOrEqual(2, 2)
-// a.GreaterOrEqual("b", "a")
-// a.GreaterOrEqual("b", "b")
-func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- GreaterOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// GreaterOrEqualf asserts that the first element is greater than or equal to the second
-//
-// a.GreaterOrEqualf(2, 1, "error message %s", "formatted")
-// a.GreaterOrEqualf(2, 2, "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "a", "error message %s", "formatted")
-// a.GreaterOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) GreaterOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- GreaterOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Greaterf asserts that the first element is greater than the second
-//
-// a.Greaterf(2, 1, "error message %s", "formatted")
-// a.Greaterf(float64(2), float64(1), "error message %s", "formatted")
-// a.Greaterf("b", "a", "error message %s", "formatted")
-func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Greaterf(a.t, e1, e2, msg, args...)
-}
-
-// HTTPBodyContains asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyContainsf asserts that a specified handler returns a
-// body that contains a string.
-//
-// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPBodyNotContains asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...)
-}
-
-// HTTPBodyNotContainsf asserts that a specified handler returns a
-// body that does not contain a string.
-//
-// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...)
-}
-
-// HTTPError asserts that a specified handler returns an error status code.
-//
-// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPError(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPErrorf asserts that a specified handler returns an error status code.
-//
-// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPErrorf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPRedirect asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPRedirectf asserts that a specified handler returns a redirect status code.
-//
-// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPRedirectf(a.t, handler, method, url, values, msg, args...)
-}
-
-// HTTPStatusCode asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPStatusCode(a.t, handler, method, url, values, statuscode, msgAndArgs...)
-}
-
-// HTTPStatusCodef asserts that a specified handler returns a specified status code.
-//
-// a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPStatusCodef(a.t, handler, method, url, values, statuscode, msg, args...)
-}
-
-// HTTPSuccess asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...)
-}
-
-// HTTPSuccessf asserts that a specified handler returns a success status code.
-//
-// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
-func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- HTTPSuccessf(a.t, handler, method, url, values, msg, args...)
-}
-
-// Implements asserts that an object is implemented by the specified interface.
-//
-// a.Implements((*MyInterface)(nil), new(MyObject))
-func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Implements(a.t, interfaceObject, object, msgAndArgs...)
-}
-
-// Implementsf asserts that an object is implemented by the specified interface.
-//
-// a.Implementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
-func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Implementsf(a.t, interfaceObject, object, msg, args...)
-}
-
-// InDelta asserts that the two numerals are within delta of each other.
-//
-// a.InDelta(math.Pi, 22/7.0, 0.01)
-func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDelta(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.
-func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaSlice is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// InDeltaSlicef is the same as InDelta, except it compares two slices.
-func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
-}
-
-// InDeltaf asserts that the two numerals are within delta of each other.
-//
-// a.InDeltaf(math.Pi, 22/7.0, 0.01, "error message %s", "formatted")
-func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InDeltaf(a.t, expected, actual, delta, msg, args...)
-}
-
-// InEpsilon asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
-}
-
-// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
-func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// InEpsilonf asserts that expected and actual have a relative error less than epsilon
-func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
-}
-
-// IsDecreasing asserts that the collection is decreasing
-//
-// a.IsDecreasing([]int{2, 1, 0})
-// a.IsDecreasing([]float{2, 1})
-// a.IsDecreasing([]string{"b", "a"})
-func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsDecreasingf asserts that the collection is decreasing
-//
-// a.IsDecreasingf([]int{2, 1, 0}, "error message %s", "formatted")
-// a.IsDecreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsDecreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsDecreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsDecreasingf(a.t, object, msg, args...)
-}
-
-// IsIncreasing asserts that the collection is increasing
-//
-// a.IsIncreasing([]int{1, 2, 3})
-// a.IsIncreasing([]float{1, 2})
-// a.IsIncreasing([]string{"a", "b"})
-func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsIncreasingf asserts that the collection is increasing
-//
-// a.IsIncreasingf([]int{1, 2, 3}, "error message %s", "formatted")
-// a.IsIncreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsIncreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsIncreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsIncreasingf(a.t, object, msg, args...)
-}
-
-// IsNonDecreasing asserts that the collection is not decreasing
-//
-// a.IsNonDecreasing([]int{1, 1, 2})
-// a.IsNonDecreasing([]float{1, 2})
-// a.IsNonDecreasing([]string{"a", "b"})
-func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonDecreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonDecreasingf asserts that the collection is not decreasing
-//
-// a.IsNonDecreasingf([]int{1, 1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]float{1, 2}, "error message %s", "formatted")
-// a.IsNonDecreasingf([]string{"a", "b"}, "error message %s", "formatted")
-func (a *Assertions) IsNonDecreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonDecreasingf(a.t, object, msg, args...)
-}
-
-// IsNonIncreasing asserts that the collection is not increasing
-//
-// a.IsNonIncreasing([]int{2, 1, 1})
-// a.IsNonIncreasing([]float{2, 1})
-// a.IsNonIncreasing([]string{"b", "a"})
-func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonIncreasing(a.t, object, msgAndArgs...)
-}
-
-// IsNonIncreasingf asserts that the collection is not increasing
-//
-// a.IsNonIncreasingf([]int{2, 1, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]float{2, 1}, "error message %s", "formatted")
-// a.IsNonIncreasingf([]string{"b", "a"}, "error message %s", "formatted")
-func (a *Assertions) IsNonIncreasingf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsNonIncreasingf(a.t, object, msg, args...)
-}
-
-// IsType asserts that the specified objects are of the same type.
-func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsType(a.t, expectedType, object, msgAndArgs...)
-}
-
-// IsTypef asserts that the specified objects are of the same type.
-func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- IsTypef(a.t, expectedType, object, msg, args...)
-}
-
-// JSONEq asserts that two JSON strings are equivalent.
-//
-// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- JSONEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// JSONEqf asserts that two JSON strings are equivalent.
-//
-// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
-func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- JSONEqf(a.t, expected, actual, msg, args...)
-}
-
-// Len asserts that the specified object has specific length.
-// Len also fails if the object has a type that len() not accept.
-//
-// a.Len(mySlice, 3)
-func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Len(a.t, object, length, msgAndArgs...)
-}
-
-// Lenf asserts that the specified object has specific length.
-// Lenf also fails if the object has a type that len() not accept.
-//
-// a.Lenf(mySlice, 3, "error message %s", "formatted")
-func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Lenf(a.t, object, length, msg, args...)
-}
-
-// Less asserts that the first element is less than the second
-//
-// a.Less(1, 2)
-// a.Less(float64(1), float64(2))
-// a.Less("a", "b")
-func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Less(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqual asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqual(1, 2)
-// a.LessOrEqual(2, 2)
-// a.LessOrEqual("a", "b")
-// a.LessOrEqual("b", "b")
-func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- LessOrEqual(a.t, e1, e2, msgAndArgs...)
-}
-
-// LessOrEqualf asserts that the first element is less than or equal to the second
-//
-// a.LessOrEqualf(1, 2, "error message %s", "formatted")
-// a.LessOrEqualf(2, 2, "error message %s", "formatted")
-// a.LessOrEqualf("a", "b", "error message %s", "formatted")
-// a.LessOrEqualf("b", "b", "error message %s", "formatted")
-func (a *Assertions) LessOrEqualf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- LessOrEqualf(a.t, e1, e2, msg, args...)
-}
-
-// Lessf asserts that the first element is less than the second
-//
-// a.Lessf(1, 2, "error message %s", "formatted")
-// a.Lessf(float64(1), float64(2), "error message %s", "formatted")
-// a.Lessf("a", "b", "error message %s", "formatted")
-func (a *Assertions) Lessf(e1 interface{}, e2 interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Lessf(a.t, e1, e2, msg, args...)
-}
-
-// Negative asserts that the specified element is negative
-//
-// a.Negative(-1)
-// a.Negative(-1.23)
-func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Negative(a.t, e, msgAndArgs...)
-}
-
-// Negativef asserts that the specified element is negative
-//
-// a.Negativef(-1, "error message %s", "formatted")
-// a.Negativef(-1.23, "error message %s", "formatted")
-func (a *Assertions) Negativef(e interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Negativef(a.t, e, msg, args...)
-}
-
-// Never asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)
-func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Never(a.t, condition, waitFor, tick, msgAndArgs...)
-}
-
-// Neverf asserts that the given condition doesn't satisfy in waitFor time,
-// periodically checking the target function each tick.
-//
-// a.Neverf(func() bool { return false; }, time.Second, 10*time.Millisecond, "error message %s", "formatted")
-func (a *Assertions) Neverf(condition func() bool, waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Neverf(a.t, condition, waitFor, tick, msg, args...)
-}
-
-// Nil asserts that the specified object is nil.
-//
-// a.Nil(err)
-func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Nil(a.t, object, msgAndArgs...)
-}
-
-// Nilf asserts that the specified object is nil.
-//
-// a.Nilf(err, "error message %s", "formatted")
-func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Nilf(a.t, object, msg, args...)
-}
-
-// NoDirExists checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoDirExists(a.t, path, msgAndArgs...)
-}
-
-// NoDirExistsf checks whether a directory does not exist in the given path.
-// It fails if the path points to an existing _directory_ only.
-func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoDirExistsf(a.t, path, msg, args...)
-}
-
-// NoError asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoError(err) {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoError(a.t, err, msgAndArgs...)
-}
-
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
-//
-// actualObj, err := SomeFunction()
-// if a.NoErrorf(err, "error message %s", "formatted") {
-// assert.Equal(t, expectedObj, actualObj)
-// }
-func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoErrorf(a.t, err, msg, args...)
-}
-
-// NoFileExists checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoFileExists(a.t, path, msgAndArgs...)
-}
-
-// NoFileExistsf checks whether a file does not exist in a given path. It fails
-// if the path points to an existing _file_ only.
-func (a *Assertions) NoFileExistsf(path string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NoFileExistsf(a.t, path, msg, args...)
-}
-
-// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContains("Hello World", "Earth")
-// a.NotContains(["Hello", "World"], "Earth")
-// a.NotContains({"Hello": "World"}, "Earth")
-func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotContains(a.t, s, contains, msgAndArgs...)
-}
-
-// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
-// specified substring or element.
-//
-// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
-// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
-// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
-func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotContainsf(a.t, s, contains, msg, args...)
-}
-
-// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmpty(obj) {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEmpty(a.t, object, msgAndArgs...)
-}
-
-// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
-// a slice or a channel with len == 0.
-//
-// if a.NotEmptyf(obj, "error message %s", "formatted") {
-// assert.Equal(t, "two", obj[1])
-// }
-func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEmptyf(a.t, object, msg, args...)
-}
-
-// NotEqual asserts that the specified values are NOT equal.
-//
-// a.NotEqual(obj1, obj2)
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqual(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValues asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValues(obj1, obj2)
-func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualValues(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotEqualValuesf asserts that two objects are not equal even when converted to the same type
-//
-// a.NotEqualValuesf(obj1, obj2, "error message %s", "formatted")
-func (a *Assertions) NotEqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualValuesf(a.t, expected, actual, msg, args...)
-}
-
-// NotEqualf asserts that the specified values are NOT equal.
-//
-// a.NotEqualf(obj1, obj2, "error message %s", "formatted")
-//
-// Pointer variable equality is determined based on the equality of the
-// referenced values (as opposed to the memory addresses).
-func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotEqualf(a.t, expected, actual, msg, args...)
-}
-
-// NotErrorIs asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotErrorIs(a.t, err, target, msgAndArgs...)
-}
-
-// NotErrorIsf asserts that at none of the errors in err's chain matches target.
-// This is a wrapper for errors.Is.
-func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotErrorIsf(a.t, err, target, msg, args...)
-}
-
-// NotNil asserts that the specified object is not nil.
-//
-// a.NotNil(err)
-func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotNil(a.t, object, msgAndArgs...)
-}
-
-// NotNilf asserts that the specified object is not nil.
-//
-// a.NotNilf(err, "error message %s", "formatted")
-func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotNilf(a.t, object, msg, args...)
-}
-
-// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanics(func(){ RemainCalm() })
-func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotPanics(a.t, f, msgAndArgs...)
-}
-
-// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
-//
-// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
-func (a *Assertions) NotPanicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotPanicsf(a.t, f, msg, args...)
-}
-
-// NotRegexp asserts that a specified regexp does not match a string.
-//
-// a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
-// a.NotRegexp("^start", "it's not starting")
-func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotRegexp(a.t, rx, str, msgAndArgs...)
-}
-
-// NotRegexpf asserts that a specified regexp does not match a string.
-//
-// a.NotRegexpf(regexp.MustCompile("starts"), "it's starting", "error message %s", "formatted")
-// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotRegexpf(a.t, rx, str, msg, args...)
-}
-
-// NotSame asserts that two pointers do not reference the same object.
-//
-// a.NotSame(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSame(a.t, expected, actual, msgAndArgs...)
-}
-
-// NotSamef asserts that two pointers do not reference the same object.
-//
-// a.NotSamef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSamef(a.t, expected, actual, msg, args...)
-}
-
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
-func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSubset(a.t, list, subset, msgAndArgs...)
-}
-
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
-//
-// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
-func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotSubsetf(a.t, list, subset, msg, args...)
-}
-
-// NotZero asserts that i is not the zero value for its type.
-func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotZero(a.t, i, msgAndArgs...)
-}
-
-// NotZerof asserts that i is not the zero value for its type.
-func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- NotZerof(a.t, i, msg, args...)
-}
-
-// Panics asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panics(func(){ GoCrazy() })
-func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Panics(a.t, f, msgAndArgs...)
-}
-
-// PanicsWithError asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithError("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithError(a.t, errString, f, msgAndArgs...)
-}
-
-// PanicsWithErrorf asserts that the code inside the specified PanicTestFunc
-// panics, and that the recovered panic value is an error that satisfies the
-// EqualError comparison.
-//
-// a.PanicsWithErrorf("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithErrorf(errString string, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithErrorf(a.t, errString, f, msg, args...)
-}
-
-// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValue("crazy error", func(){ GoCrazy() })
-func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithValue(a.t, expected, f, msgAndArgs...)
-}
-
-// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
-// the recovered panic value equals the expected panic value.
-//
-// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) PanicsWithValuef(expected interface{}, f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- PanicsWithValuef(a.t, expected, f, msg, args...)
-}
-
-// Panicsf asserts that the code inside the specified PanicTestFunc panics.
-//
-// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
-func (a *Assertions) Panicsf(f assert.PanicTestFunc, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Panicsf(a.t, f, msg, args...)
-}
-
-// Positive asserts that the specified element is positive
-//
-// a.Positive(1)
-// a.Positive(1.23)
-func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Positive(a.t, e, msgAndArgs...)
-}
-
-// Positivef asserts that the specified element is positive
-//
-// a.Positivef(1, "error message %s", "formatted")
-// a.Positivef(1.23, "error message %s", "formatted")
-func (a *Assertions) Positivef(e interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Positivef(a.t, e, msg, args...)
-}
-
-// Regexp asserts that a specified regexp matches a string.
-//
-// a.Regexp(regexp.MustCompile("start"), "it's starting")
-// a.Regexp("start...$", "it's not starting")
-func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Regexp(a.t, rx, str, msgAndArgs...)
-}
-
-// Regexpf asserts that a specified regexp matches a string.
-//
-// a.Regexpf(regexp.MustCompile("start"), "it's starting", "error message %s", "formatted")
-// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
-func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Regexpf(a.t, rx, str, msg, args...)
-}
-
-// Same asserts that two pointers reference the same object.
-//
-// a.Same(ptr1, ptr2)
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Same(a.t, expected, actual, msgAndArgs...)
-}
-
-// Samef asserts that two pointers reference the same object.
-//
-// a.Samef(ptr1, ptr2, "error message %s", "formatted")
-//
-// Both arguments must be pointer variables. Pointer variable sameness is
-// determined based on the equality of both type and value.
-func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Samef(a.t, expected, actual, msg, args...)
-}
-
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
-func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Subset(a.t, list, subset, msgAndArgs...)
-}
-
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
-//
-// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
-func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Subsetf(a.t, list, subset, msg, args...)
-}
-
-// True asserts that the specified value is true.
-//
-// a.True(myBool)
-func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- True(a.t, value, msgAndArgs...)
-}
-
-// Truef asserts that the specified value is true.
-//
-// a.Truef(myBool, "error message %s", "formatted")
-func (a *Assertions) Truef(value bool, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Truef(a.t, value, msg, args...)
-}
-
-// WithinDuration asserts that the two times are within duration delta of each other.
-//
-// a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
-func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
-}
-
-// WithinDurationf asserts that the two times are within duration delta of each other.
-//
-// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
-func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinDurationf(a.t, expected, actual, delta, msg, args...)
-}
-
-// WithinRange asserts that a time is within a time range (inclusive).
-//
-// a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))
-func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinRange(a.t, actual, start, end, msgAndArgs...)
-}
-
-// WithinRangef asserts that a time is within a time range (inclusive).
-//
-// a.WithinRangef(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second), "error message %s", "formatted")
-func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Time, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- WithinRangef(a.t, actual, start, end, msg, args...)
-}
-
-// YAMLEq asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- YAMLEq(a.t, expected, actual, msgAndArgs...)
-}
-
-// YAMLEqf asserts that two YAML strings are equivalent.
-func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- YAMLEqf(a.t, expected, actual, msg, args...)
-}
-
-// Zero asserts that i is the zero value for its type.
-func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Zero(a.t, i, msgAndArgs...)
-}
-
-// Zerof asserts that i is the zero value for its type.
-func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) {
- if h, ok := a.t.(tHelper); ok {
- h.Helper()
- }
- Zerof(a.t, i, msg, args...)
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go.tmpl b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go.tmpl
deleted file mode 100644
index 54124df1d3bbed65addd5df5f9c57c4ea07d4253..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/require_forward.go.tmpl
+++ /dev/null
@@ -1,5 +0,0 @@
-{{.CommentWithoutT "a"}}
-func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
- if h, ok := a.t.(tHelper); ok { h.Helper() }
- {{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements.go
deleted file mode 100644
index 91772dfeb919224e3f35b7e9f13d4b866a8339f7..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package require
-
-// TestingT is an interface wrapper around *testing.T
-type TestingT interface {
- Errorf(format string, args ...interface{})
- FailNow()
-}
-
-type tHelper interface {
- Helper()
-}
-
-// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful
-// for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
-
-// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful
-// for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
-
-// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful
-// for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{})
-
-// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful
-// for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{})
-
-//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs"
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements_test.go
deleted file mode 100644
index febf0c1870ab8716d8c100954615d44dfc3384b5..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/require/requirements_test.go
+++ /dev/null
@@ -1,683 +0,0 @@
-package require
-
-import (
- "encoding/json"
- "errors"
- "testing"
- "time"
-)
-
-// AssertionTesterInterface defines an interface to be used for testing assertion methods
-type AssertionTesterInterface interface {
- TestMethod()
-}
-
-// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface
-type AssertionTesterConformingObject struct {
-}
-
-func (a *AssertionTesterConformingObject) TestMethod() {
-}
-
-// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface
-type AssertionTesterNonConformingObject struct {
-}
-
-type MockT struct {
- Failed bool
-}
-
-func (t *MockT) FailNow() {
- t.Failed = true
-}
-
-func (t *MockT) Errorf(format string, args ...interface{}) {
- _, _ = format, args
-}
-
-func TestImplements(t *testing.T) {
-
- Implements(t, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestIsType(t *testing.T) {
-
- IsType(t, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqual(t *testing.T) {
-
- Equal(t, 1, 1)
-
- mockT := new(MockT)
- Equal(mockT, 1, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-
-}
-
-func TestNotEqual(t *testing.T) {
-
- NotEqual(t, 1, 2)
- mockT := new(MockT)
- NotEqual(mockT, 2, 2)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestExactly(t *testing.T) {
-
- a := float32(1)
- b := float32(1)
- c := float64(1)
-
- Exactly(t, a, b)
-
- mockT := new(MockT)
- Exactly(mockT, a, c)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotNil(t *testing.T) {
-
- NotNil(t, new(AssertionTesterConformingObject))
-
- mockT := new(MockT)
- NotNil(mockT, nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNil(t *testing.T) {
-
- Nil(t, nil)
-
- mockT := new(MockT)
- Nil(mockT, new(AssertionTesterConformingObject))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestTrue(t *testing.T) {
-
- True(t, true)
-
- mockT := new(MockT)
- True(mockT, false)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestFalse(t *testing.T) {
-
- False(t, false)
-
- mockT := new(MockT)
- False(mockT, true)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestContains(t *testing.T) {
-
- Contains(t, "Hello World", "Hello")
-
- mockT := new(MockT)
- Contains(mockT, "Hello World", "Salut")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotContains(t *testing.T) {
-
- NotContains(t, "Hello World", "Hello!")
-
- mockT := new(MockT)
- NotContains(mockT, "Hello World", "Hello")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestPanics(t *testing.T) {
-
- Panics(t, func() {
- panic("Panic!")
- })
-
- mockT := new(MockT)
- Panics(mockT, func() {})
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotPanics(t *testing.T) {
-
- NotPanics(t, func() {})
-
- mockT := new(MockT)
- NotPanics(mockT, func() {
- panic("Panic!")
- })
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNoError(t *testing.T) {
-
- NoError(t, nil)
-
- mockT := new(MockT)
- NoError(mockT, errors.New("some error"))
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestError(t *testing.T) {
-
- Error(t, errors.New("some error"))
-
- mockT := new(MockT)
- Error(mockT, nil)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestErrorContains(t *testing.T) {
-
- ErrorContains(t, errors.New("some error: another error"), "some error")
-
- mockT := new(MockT)
- ErrorContains(mockT, errors.New("some error"), "different error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEqualError(t *testing.T) {
-
- EqualError(t, errors.New("some error"), "some error")
-
- mockT := new(MockT)
- EqualError(mockT, errors.New("some error"), "Not some error")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestEmpty(t *testing.T) {
-
- Empty(t, "")
-
- mockT := new(MockT)
- Empty(mockT, "x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotEmpty(t *testing.T) {
-
- NotEmpty(t, "x")
-
- mockT := new(MockT)
- NotEmpty(mockT, "")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestWithinDuration(t *testing.T) {
-
- a := time.Now()
- b := a.Add(10 * time.Second)
-
- WithinDuration(t, a, b, 15*time.Second)
-
- mockT := new(MockT)
- WithinDuration(mockT, a, b, 5*time.Second)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestInDelta(t *testing.T) {
-
- InDelta(t, 1.001, 1, 0.01)
-
- mockT := new(MockT)
- InDelta(mockT, 1, 2, 0.5)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestZero(t *testing.T) {
-
- Zero(t, "")
-
- mockT := new(MockT)
- Zero(mockT, "x")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestNotZero(t *testing.T) {
-
- NotZero(t, "x")
-
- mockT := new(MockT)
- NotZero(mockT, "")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_EqualSONString(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}",
- "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_Array(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ActualIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ExpectedIsNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, "Not JSON", "Not JSON")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEq_EqualYAMLString(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEq_EquivalentButNotEqual(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEq_HashOfArraysAndHashes(t *testing.T) {
- mockT := new(MockT)
- expected := `
-numeric: 1.5
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-`
-
- actual := `
-numeric: 1.5
-hash:
- nested: hash
- nested_slice: [this, is, nested]
-string: "foo"
-array:
- - foo: bar
- - 1
- - "string"
- - ["nested", "array", 5.5]
-`
- YAMLEq(mockT, expected, actual)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEq_Array(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEq_HashAndArrayNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEq_HashesNotEquivalent(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEq_ActualIsSimpleString(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `{"foo": "bar"}`, "Simple String")
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEq_ExpectedIsSimpleString(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, "Simple String", `{"foo": "bar", "hello": "world"}`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func TestYAMLEq_ExpectedAndActualSimpleString(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, "Simple String", "Simple String")
- if mockT.Failed {
- t.Error("Check should pass")
- }
-}
-
-func TestYAMLEq_ArraysOfDifferentOrder(t *testing.T) {
- mockT := new(MockT)
- YAMLEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)
- if !mockT.Failed {
- t.Error("Check should fail")
- }
-}
-
-func ExampleComparisonAssertionFunc() {
- t := &testing.T{} // provided by test
-
- adder := func(x, y int) int {
- return x + y
- }
-
- type args struct {
- x int
- y int
- }
-
- tests := []struct {
- name string
- args args
- expect int
- assertion ComparisonAssertionFunc
- }{
- {"2+2=4", args{2, 2}, 4, Equal},
- {"2+2!=5", args{2, 2}, 5, NotEqual},
- {"2+3==5", args{2, 3}, 5, Exactly},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y))
- })
- }
-}
-
-func TestComparisonAssertionFunc(t *testing.T) {
- type iface interface {
- Name() string
- }
-
- tests := []struct {
- name string
- expect interface{}
- got interface{}
- assertion ComparisonAssertionFunc
- }{
- {"implements", (*iface)(nil), t, Implements},
- {"isType", (*testing.T)(nil), t, IsType},
- {"equal", t, t, Equal},
- {"equalValues", t, t, EqualValues},
- {"exactly", t, t, Exactly},
- {"notEqual", t, nil, NotEqual},
- {"NotEqualValues", t, nil, NotEqualValues},
- {"notContains", []int{1, 2, 3}, 4, NotContains},
- {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset},
- {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset},
- {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch},
- {"regexp", "^t.*y$", "testify", Regexp},
- {"notRegexp", "^t.*y$", "Testify", NotRegexp},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.expect, tt.got)
- })
- }
-}
-
-func ExampleValueAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParse := func(input string) interface{} {
- var x interface{}
- json.Unmarshal([]byte(input), &x)
- return x
- }
-
- tests := []struct {
- name string
- arg string
- assertion ValueAssertionFunc
- }{
- {"true is not nil", "true", NotNil},
- {"empty string is nil", "", Nil},
- {"zero is not nil", "0", NotNil},
- {"zero is zero", "0", Zero},
- {"false is zero", "false", Zero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, dumbParse(tt.arg))
- })
- }
-}
-
-func TestValueAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value interface{}
- assertion ValueAssertionFunc
- }{
- {"notNil", true, NotNil},
- {"nil", nil, Nil},
- {"empty", []int{}, Empty},
- {"notEmpty", []int{1}, NotEmpty},
- {"zero", false, Zero},
- {"notZero", 42, NotZero},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleBoolAssertionFunc() {
- t := &testing.T{} // provided by test
-
- isOkay := func(x int) bool {
- return x >= 42
- }
-
- tests := []struct {
- name string
- arg int
- assertion BoolAssertionFunc
- }{
- {"-1 is bad", -1, False},
- {"42 is good", 42, True},
- {"41 is bad", 41, False},
- {"45 is cool", 45, True},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, isOkay(tt.arg))
- })
- }
-}
-
-func TestBoolAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- value bool
- assertion BoolAssertionFunc
- }{
- {"true", true, True},
- {"false", false, False},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.value)
- })
- }
-}
-
-func ExampleErrorAssertionFunc() {
- t := &testing.T{} // provided by test
-
- dumbParseNum := func(input string, v interface{}) error {
- return json.Unmarshal([]byte(input), v)
- }
-
- tests := []struct {
- name string
- arg string
- assertion ErrorAssertionFunc
- }{
- {"1.2 is number", "1.2", NoError},
- {"1.2.3 not number", "1.2.3", Error},
- {"true is not number", "true", Error},
- {"3 is number", "3", NoError},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- var x float64
- tt.assertion(t, dumbParseNum(tt.arg, &x))
- })
- }
-}
-
-func TestErrorAssertionFunc(t *testing.T) {
- tests := []struct {
- name string
- err error
- assertion ErrorAssertionFunc
- }{
- {"noError", nil, NoError},
- {"error", errors.New("whoops"), Error},
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- tt.assertion(t, tt.err)
- })
- }
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/doc.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/doc.go
deleted file mode 100644
index f91a245d3f8b4e191df196634960c06d882d0c9e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/doc.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// Package suite contains logic for creating testing suite structs
-// and running the methods on those structs as tests. The most useful
-// piece of this package is that you can create setup/teardown methods
-// on your testing suites, which will run before/after the whole suite
-// or individual tests (depending on which interface(s) you
-// implement).
-//
-// A testing suite is usually built by first extending the built-in
-// suite functionality from suite.Suite in testify. Alternatively,
-// you could reproduce that logic on your own if you wanted (you
-// just need to implement the TestingSuite interface from
-// suite/interfaces.go).
-//
-// After that, you can implement any of the interfaces in
-// suite/interfaces.go to add setup/teardown functionality to your
-// suite, and add any methods that start with "Test" to add tests.
-// Methods that do not match any suite interfaces and do not begin
-// with "Test" will not be run by testify, and can safely be used as
-// helper methods.
-//
-// Once you've built your testing suite, you need to run the suite
-// (using suite.Run from testify) inside any function that matches the
-// identity that "go test" is already looking for (i.e.
-// func(*testing.T)).
-//
-// Regular expression to select test suites specified command-line
-// argument "-run". Regular expression to select the methods
-// of test suites specified command-line argument "-m".
-// Suite object has assertion methods.
-//
-// A crude example:
-// // Basic imports
-// import (
-// "testing"
-// "github.com/stretchr/testify/assert"
-// "github.com/stretchr/testify/suite"
-// )
-//
-// // Define the suite, and absorb the built-in basic suite
-// // functionality from testify - including a T() method which
-// // returns the current testing context
-// type ExampleTestSuite struct {
-// suite.Suite
-// VariableThatShouldStartAtFive int
-// }
-//
-// // Make sure that VariableThatShouldStartAtFive is set to five
-// // before each test
-// func (suite *ExampleTestSuite) SetupTest() {
-// suite.VariableThatShouldStartAtFive = 5
-// }
-//
-// // All methods that begin with "Test" are run as tests within a
-// // suite.
-// func (suite *ExampleTestSuite) TestExample() {
-// assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
-// suite.Equal(5, suite.VariableThatShouldStartAtFive)
-// }
-//
-// // In order for 'go test' to run this suite, we need to create
-// // a normal test function and pass our suite to suite.Run
-// func TestExampleTestSuite(t *testing.T) {
-// suite.Run(t, new(ExampleTestSuite))
-// }
-package suite
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/interfaces.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/interfaces.go
deleted file mode 100644
index fed037d7f3e61c0a02d8458fea157378f939644e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/interfaces.go
+++ /dev/null
@@ -1,66 +0,0 @@
-package suite
-
-import "testing"
-
-// TestingSuite can store and return the current *testing.T context
-// generated by 'go test'.
-type TestingSuite interface {
- T() *testing.T
- SetT(*testing.T)
- SetS(suite TestingSuite)
-}
-
-// SetupAllSuite has a SetupSuite method, which will run before the
-// tests in the suite are run.
-type SetupAllSuite interface {
- SetupSuite()
-}
-
-// SetupTestSuite has a SetupTest method, which will run before each
-// test in the suite.
-type SetupTestSuite interface {
- SetupTest()
-}
-
-// TearDownAllSuite has a TearDownSuite method, which will run after
-// all the tests in the suite have been run.
-type TearDownAllSuite interface {
- TearDownSuite()
-}
-
-// TearDownTestSuite has a TearDownTest method, which will run after
-// each test in the suite.
-type TearDownTestSuite interface {
- TearDownTest()
-}
-
-// BeforeTest has a function to be executed right before the test
-// starts and receives the suite and test names as input
-type BeforeTest interface {
- BeforeTest(suiteName, testName string)
-}
-
-// AfterTest has a function to be executed right after the test
-// finishes and receives the suite and test names as input
-type AfterTest interface {
- AfterTest(suiteName, testName string)
-}
-
-// WithStats implements HandleStats, a function that will be executed
-// when a test suite is finished. The stats contain information about
-// the execution of that suite and its tests.
-type WithStats interface {
- HandleStats(suiteName string, stats *SuiteInformation)
-}
-
-// SetupSubTest has a SetupSubTest method, which will run before each
-// subtest in the suite.
-type SetupSubTest interface {
- SetupSubTest()
-}
-
-// TearDownSubTest has a TearDownSubTest method, which will run after
-// each subtest in the suite have been run.
-type TearDownSubTest interface {
- TearDownSubTest()
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats.go
deleted file mode 100644
index 261da37f78fbc5f5a02e1cab5123a0c93da15ed3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package suite
-
-import "time"
-
-// SuiteInformation stats stores stats for the whole suite execution.
-type SuiteInformation struct {
- Start, End time.Time
- TestStats map[string]*TestInformation
-}
-
-// TestInformation stores information about the execution of each test.
-type TestInformation struct {
- TestName string
- Start, End time.Time
- Passed bool
-}
-
-func newSuiteInformation() *SuiteInformation {
- testStats := make(map[string]*TestInformation)
-
- return &SuiteInformation{
- TestStats: testStats,
- }
-}
-
-func (s SuiteInformation) start(testName string) {
- s.TestStats[testName] = &TestInformation{
- TestName: testName,
- Start: time.Now(),
- }
-}
-
-func (s SuiteInformation) end(testName string, passed bool) {
- s.TestStats[testName].End = time.Now()
- s.TestStats[testName].Passed = passed
-}
-
-func (s SuiteInformation) Passed() bool {
- for _, stats := range s.TestStats {
- if !stats.Passed {
- return false
- }
- }
-
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats_test.go
deleted file mode 100644
index 4446a6d64fa0b9ee3fc46e3b0ac6459a47cf11d5..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/stats_test.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package suite
-
-import (
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestPassedReturnsTrueWhenAllTestsPass(t *testing.T) {
- sinfo := newSuiteInformation()
- sinfo.TestStats = map[string]*TestInformation{
- "Test1": {TestName: "Test1", Passed: true},
- "Test2": {TestName: "Test2", Passed: true},
- "Test3": {TestName: "Test3", Passed: true},
- }
-
- assert.True(t, sinfo.Passed())
-}
-
-func TestPassedReturnsFalseWhenSomeTestFails(t *testing.T) {
- sinfo := newSuiteInformation()
- sinfo.TestStats = map[string]*TestInformation{
- "Test1": {TestName: "Test1", Passed: true},
- "Test2": {TestName: "Test2", Passed: false},
- "Test3": {TestName: "Test3", Passed: true},
- }
-
- assert.False(t, sinfo.Passed())
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite.go
deleted file mode 100644
index 8b4202d8906d869c49aa9de9fda1994dfb2e2b8d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite.go
+++ /dev/null
@@ -1,248 +0,0 @@
-package suite
-
-import (
- "flag"
- "fmt"
- "os"
- "reflect"
- "regexp"
- "runtime/debug"
- "sync"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
-)
-
-var allTestsFilter = func(_, _ string) (bool, error) { return true, nil }
-var matchMethod = flag.String("testify.m", "", "regular expression to select tests of the testify suite to run")
-
-// Suite is a basic testing suite with methods for storing and
-// retrieving the current *testing.T context.
-type Suite struct {
- *assert.Assertions
-
- mu sync.RWMutex
- require *require.Assertions
- t *testing.T
-
- // Parent suite to have access to the implemented methods of parent struct
- s TestingSuite
-}
-
-// T retrieves the current *testing.T context.
-func (suite *Suite) T() *testing.T {
- suite.mu.RLock()
- defer suite.mu.RUnlock()
- return suite.t
-}
-
-// SetT sets the current *testing.T context.
-func (suite *Suite) SetT(t *testing.T) {
- suite.mu.Lock()
- defer suite.mu.Unlock()
- suite.t = t
- suite.Assertions = assert.New(t)
- suite.require = require.New(t)
-}
-
-// SetS needs to set the current test suite as parent
-// to get access to the parent methods
-func (suite *Suite) SetS(s TestingSuite) {
- suite.s = s
-}
-
-// Require returns a require context for suite.
-func (suite *Suite) Require() *require.Assertions {
- suite.mu.Lock()
- defer suite.mu.Unlock()
- if suite.require == nil {
- suite.require = require.New(suite.T())
- }
- return suite.require
-}
-
-// Assert returns an assert context for suite. Normally, you can call
-// `suite.NoError(expected, actual)`, but for situations where the embedded
-// methods are overridden (for example, you might want to override
-// assert.Assertions with require.Assertions), this method is provided so you
-// can call `suite.Assert().NoError()`.
-func (suite *Suite) Assert() *assert.Assertions {
- suite.mu.Lock()
- defer suite.mu.Unlock()
- if suite.Assertions == nil {
- suite.Assertions = assert.New(suite.T())
- }
- return suite.Assertions
-}
-
-func recoverAndFailOnPanic(t *testing.T) {
- r := recover()
- failOnPanic(t, r)
-}
-
-func failOnPanic(t *testing.T, r interface{}) {
- if r != nil {
- t.Errorf("test panicked: %v\n%s", r, debug.Stack())
- t.FailNow()
- }
-}
-
-// Run provides suite functionality around golang subtests. It should be
-// called in place of t.Run(name, func(t *testing.T)) in test suite code.
-// The passed-in func will be executed as a subtest with a fresh instance of t.
-// Provides compatibility with go test pkg -run TestSuite/TestName/SubTestName.
-func (suite *Suite) Run(name string, subtest func()) bool {
- oldT := suite.T()
-
- if setupSubTest, ok := suite.s.(SetupSubTest); ok {
- setupSubTest.SetupSubTest()
- }
-
- defer func() {
- suite.SetT(oldT)
- if tearDownSubTest, ok := suite.s.(TearDownSubTest); ok {
- tearDownSubTest.TearDownSubTest()
- }
- }()
-
- return oldT.Run(name, func(t *testing.T) {
- suite.SetT(t)
- subtest()
- })
-}
-
-// Run takes a testing suite and runs all of the tests attached
-// to it.
-func Run(t *testing.T, suite TestingSuite) {
- defer recoverAndFailOnPanic(t)
-
- suite.SetT(t)
- suite.SetS(suite)
-
- var suiteSetupDone bool
-
- var stats *SuiteInformation
- if _, ok := suite.(WithStats); ok {
- stats = newSuiteInformation()
- }
-
- tests := []testing.InternalTest{}
- methodFinder := reflect.TypeOf(suite)
- suiteName := methodFinder.Elem().Name()
-
- for i := 0; i < methodFinder.NumMethod(); i++ {
- method := methodFinder.Method(i)
-
- ok, err := methodFilter(method.Name)
- if err != nil {
- fmt.Fprintf(os.Stderr, "testify: invalid regexp for -m: %s\n", err)
- os.Exit(1)
- }
-
- if !ok {
- continue
- }
-
- if !suiteSetupDone {
- if stats != nil {
- stats.Start = time.Now()
- }
-
- if setupAllSuite, ok := suite.(SetupAllSuite); ok {
- setupAllSuite.SetupSuite()
- }
-
- suiteSetupDone = true
- }
-
- test := testing.InternalTest{
- Name: method.Name,
- F: func(t *testing.T) {
- parentT := suite.T()
- suite.SetT(t)
- defer recoverAndFailOnPanic(t)
- defer func() {
- r := recover()
-
- if stats != nil {
- passed := !t.Failed() && r == nil
- stats.end(method.Name, passed)
- }
-
- if afterTestSuite, ok := suite.(AfterTest); ok {
- afterTestSuite.AfterTest(suiteName, method.Name)
- }
-
- if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok {
- tearDownTestSuite.TearDownTest()
- }
-
- suite.SetT(parentT)
- failOnPanic(t, r)
- }()
-
- if setupTestSuite, ok := suite.(SetupTestSuite); ok {
- setupTestSuite.SetupTest()
- }
- if beforeTestSuite, ok := suite.(BeforeTest); ok {
- beforeTestSuite.BeforeTest(methodFinder.Elem().Name(), method.Name)
- }
-
- if stats != nil {
- stats.start(method.Name)
- }
-
- method.Func.Call([]reflect.Value{reflect.ValueOf(suite)})
- },
- }
- tests = append(tests, test)
- }
- if suiteSetupDone {
- defer func() {
- if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok {
- tearDownAllSuite.TearDownSuite()
- }
-
- if suiteWithStats, measureStats := suite.(WithStats); measureStats {
- stats.End = time.Now()
- suiteWithStats.HandleStats(suiteName, stats)
- }
- }()
- }
-
- runTests(t, tests)
-}
-
-// Filtering method according to set regular expression
-// specified command-line argument -m
-func methodFilter(name string) (bool, error) {
- if ok, _ := regexp.MatchString("^Test", name); !ok {
- return false, nil
- }
- return regexp.MatchString(*matchMethod, name)
-}
-
-func runTests(t testing.TB, tests []testing.InternalTest) {
- if len(tests) == 0 {
- t.Log("warning: no tests to run")
- return
- }
-
- r, ok := t.(runner)
- if !ok { // backwards compatibility with Go 1.6 and below
- if !testing.RunTests(allTestsFilter, tests) {
- t.Fail()
- }
- return
- }
-
- for _, test := range tests {
- r.Run(test.Name, test.F)
- }
-}
-
-type runner interface {
- Run(name string, f func(t *testing.T)) bool
-}
diff --git a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite_test.go b/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite_test.go
deleted file mode 100644
index d684f52b995dfaf0e0f2e7a8fb317e9a640e196d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/github.com/stretchr/testify@v1.8.2/suite/suite_test.go
+++ /dev/null
@@ -1,619 +0,0 @@
-package suite
-
-import (
- "bytes"
- "errors"
- "flag"
- "io/ioutil"
- "math/rand"
- "os"
- "os/exec"
- "strings"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
-)
-
-// SuiteRequireTwice is intended to test the usage of suite.Require in two
-// different tests
-type SuiteRequireTwice struct{ Suite }
-
-// TestSuiteRequireTwice checks for regressions of issue #149 where
-// suite.requirements was not initialised in suite.SetT()
-// A regression would result on these tests panicking rather than failing.
-func TestSuiteRequireTwice(t *testing.T) {
- ok := testing.RunTests(
- allTestsFilter,
- []testing.InternalTest{{
- Name: "TestSuiteRequireTwice",
- F: func(t *testing.T) {
- suite := new(SuiteRequireTwice)
- Run(t, suite)
- },
- }},
- )
- assert.Equal(t, false, ok)
-}
-
-func (s *SuiteRequireTwice) TestRequireOne() {
- r := s.Require()
- r.Equal(1, 2)
-}
-
-func (s *SuiteRequireTwice) TestRequireTwo() {
- r := s.Require()
- r.Equal(1, 2)
-}
-
-type panickingSuite struct {
- Suite
- panicInSetupSuite bool
- panicInSetupTest bool
- panicInBeforeTest bool
- panicInTest bool
- panicInAfterTest bool
- panicInTearDownTest bool
- panicInTearDownSuite bool
-}
-
-func (s *panickingSuite) SetupSuite() {
- if s.panicInSetupSuite {
- panic("oops in setup suite")
- }
-}
-
-func (s *panickingSuite) SetupTest() {
- if s.panicInSetupTest {
- panic("oops in setup test")
- }
-}
-
-func (s *panickingSuite) BeforeTest(_, _ string) {
- if s.panicInBeforeTest {
- panic("oops in before test")
- }
-}
-
-func (s *panickingSuite) Test() {
- if s.panicInTest {
- panic("oops in test")
- }
-}
-
-func (s *panickingSuite) AfterTest(_, _ string) {
- if s.panicInAfterTest {
- panic("oops in after test")
- }
-}
-
-func (s *panickingSuite) TearDownTest() {
- if s.panicInTearDownTest {
- panic("oops in tear down test")
- }
-}
-
-func (s *panickingSuite) TearDownSuite() {
- if s.panicInTearDownSuite {
- panic("oops in tear down suite")
- }
-}
-
-func TestSuiteRecoverPanic(t *testing.T) {
- ok := true
- panickingTests := []testing.InternalTest{
- {
- Name: "TestPanicInSetupSuite",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInSetupSuite: true}) },
- },
- {
- Name: "TestPanicInSetupTest",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInSetupTest: true}) },
- },
- {
- Name: "TestPanicInBeforeTest",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInBeforeTest: true}) },
- },
- {
- Name: "TestPanicInTest",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInTest: true}) },
- },
- {
- Name: "TestPanicInAfterTest",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInAfterTest: true}) },
- },
- {
- Name: "TestPanicInTearDownTest",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownTest: true}) },
- },
- {
- Name: "TestPanicInTearDownSuite",
- F: func(t *testing.T) { Run(t, &panickingSuite{panicInTearDownSuite: true}) },
- },
- }
-
- require.NotPanics(t, func() {
- ok = testing.RunTests(allTestsFilter, panickingTests)
- })
-
- assert.False(t, ok)
-}
-
-// This suite is intended to store values to make sure that only
-// testing-suite-related methods are run. It's also a fully
-// functional example of a testing suite, using setup/teardown methods
-// and a helper method that is ignored by testify. To make this look
-// more like a real world example, all tests in the suite perform some
-// type of assertion.
-type SuiteTester struct {
- // Include our basic suite logic.
- Suite
-
- // Keep counts of how many times each method is run.
- SetupSuiteRunCount int
- TearDownSuiteRunCount int
- SetupTestRunCount int
- TearDownTestRunCount int
- TestOneRunCount int
- TestTwoRunCount int
- TestSubtestRunCount int
- NonTestMethodRunCount int
- SetupSubTestRunCount int
- TearDownSubTestRunCount int
-
- SuiteNameBefore []string
- TestNameBefore []string
-
- SuiteNameAfter []string
- TestNameAfter []string
-
- TimeBefore []time.Time
- TimeAfter []time.Time
-}
-
-// The SetupSuite method will be run by testify once, at the very
-// start of the testing suite, before any tests are run.
-func (suite *SuiteTester) SetupSuite() {
- suite.SetupSuiteRunCount++
-}
-
-func (suite *SuiteTester) BeforeTest(suiteName, testName string) {
- suite.SuiteNameBefore = append(suite.SuiteNameBefore, suiteName)
- suite.TestNameBefore = append(suite.TestNameBefore, testName)
- suite.TimeBefore = append(suite.TimeBefore, time.Now())
-}
-
-func (suite *SuiteTester) AfterTest(suiteName, testName string) {
- suite.SuiteNameAfter = append(suite.SuiteNameAfter, suiteName)
- suite.TestNameAfter = append(suite.TestNameAfter, testName)
- suite.TimeAfter = append(suite.TimeAfter, time.Now())
-}
-
-// The TearDownSuite method will be run by testify once, at the very
-// end of the testing suite, after all tests have been run.
-func (suite *SuiteTester) TearDownSuite() {
- suite.TearDownSuiteRunCount++
-}
-
-// The SetupTest method will be run before every test in the suite.
-func (suite *SuiteTester) SetupTest() {
- suite.SetupTestRunCount++
-}
-
-// The TearDownTest method will be run after every test in the suite.
-func (suite *SuiteTester) TearDownTest() {
- suite.TearDownTestRunCount++
-}
-
-// Every method in a testing suite that begins with "Test" will be run
-// as a test. TestOne is an example of a test. For the purposes of
-// this example, we've included assertions in the tests, since most
-// tests will issue assertions.
-func (suite *SuiteTester) TestOne() {
- beforeCount := suite.TestOneRunCount
- suite.TestOneRunCount++
- assert.Equal(suite.T(), suite.TestOneRunCount, beforeCount+1)
- suite.Equal(suite.TestOneRunCount, beforeCount+1)
-}
-
-// TestTwo is another example of a test.
-func (suite *SuiteTester) TestTwo() {
- beforeCount := suite.TestTwoRunCount
- suite.TestTwoRunCount++
- assert.NotEqual(suite.T(), suite.TestTwoRunCount, beforeCount)
- suite.NotEqual(suite.TestTwoRunCount, beforeCount)
-}
-
-func (suite *SuiteTester) TestSkip() {
- suite.T().Skip()
-}
-
-// NonTestMethod does not begin with "Test", so it will not be run by
-// testify as a test in the suite. This is useful for creating helper
-// methods for your tests.
-func (suite *SuiteTester) NonTestMethod() {
- suite.NonTestMethodRunCount++
-}
-
-func (suite *SuiteTester) TestSubtest() {
- suite.TestSubtestRunCount++
-
- for _, t := range []struct {
- testName string
- }{
- {"first"},
- {"second"},
- } {
- suiteT := suite.T()
- suite.Run(t.testName, func() {
- // We should get a different *testing.T for subtests, so that
- // go test recognizes them as proper subtests for output formatting
- // and running individual subtests
- subTestT := suite.T()
- suite.NotEqual(subTestT, suiteT)
- })
- suite.Equal(suiteT, suite.T())
- }
-}
-
-func (suite *SuiteTester) TearDownSubTest() {
- suite.TearDownSubTestRunCount++
-}
-
-func (suite *SuiteTester) SetupSubTest() {
- suite.SetupSubTestRunCount++
-}
-
-type SuiteSkipTester struct {
- // Include our basic suite logic.
- Suite
-
- // Keep counts of how many times each method is run.
- SetupSuiteRunCount int
- TearDownSuiteRunCount int
-}
-
-func (suite *SuiteSkipTester) SetupSuite() {
- suite.SetupSuiteRunCount++
- suite.T().Skip()
-}
-
-func (suite *SuiteSkipTester) TestNothing() {
- // SetupSuite is only called when at least one test satisfies
- // test filter. For this suite to be set up (and then tore down)
- // it is necessary to add at least one test method.
-}
-
-func (suite *SuiteSkipTester) TearDownSuite() {
- suite.TearDownSuiteRunCount++
-}
-
-// TestRunSuite will be run by the 'go test' command, so within it, we
-// can run our suite using the Run(*testing.T, TestingSuite) function.
-func TestRunSuite(t *testing.T) {
- suiteTester := new(SuiteTester)
- Run(t, suiteTester)
-
- // Normally, the test would end here. The following are simply
- // some assertions to ensure that the Run function is working as
- // intended - they are not part of the example.
-
- // The suite was only run once, so the SetupSuite and TearDownSuite
- // methods should have each been run only once.
- assert.Equal(t, suiteTester.SetupSuiteRunCount, 1)
- assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1)
-
- assert.Equal(t, len(suiteTester.SuiteNameAfter), 4)
- assert.Equal(t, len(suiteTester.SuiteNameBefore), 4)
- assert.Equal(t, len(suiteTester.TestNameAfter), 4)
- assert.Equal(t, len(suiteTester.TestNameBefore), 4)
-
- assert.Contains(t, suiteTester.TestNameAfter, "TestOne")
- assert.Contains(t, suiteTester.TestNameAfter, "TestTwo")
- assert.Contains(t, suiteTester.TestNameAfter, "TestSkip")
- assert.Contains(t, suiteTester.TestNameAfter, "TestSubtest")
-
- assert.Contains(t, suiteTester.TestNameBefore, "TestOne")
- assert.Contains(t, suiteTester.TestNameBefore, "TestTwo")
- assert.Contains(t, suiteTester.TestNameBefore, "TestSkip")
- assert.Contains(t, suiteTester.TestNameBefore, "TestSubtest")
-
- for _, suiteName := range suiteTester.SuiteNameAfter {
- assert.Equal(t, "SuiteTester", suiteName)
- }
-
- for _, suiteName := range suiteTester.SuiteNameBefore {
- assert.Equal(t, "SuiteTester", suiteName)
- }
-
- for _, when := range suiteTester.TimeAfter {
- assert.False(t, when.IsZero())
- }
-
- for _, when := range suiteTester.TimeBefore {
- assert.False(t, when.IsZero())
- }
-
- // There are four test methods (TestOne, TestTwo, TestSkip, and TestSubtest), so
- // the SetupTest and TearDownTest methods (which should be run once for
- // each test) should have been run four times.
- assert.Equal(t, suiteTester.SetupTestRunCount, 4)
- assert.Equal(t, suiteTester.TearDownTestRunCount, 4)
-
- // Each test should have been run once.
- assert.Equal(t, suiteTester.TestOneRunCount, 1)
- assert.Equal(t, suiteTester.TestTwoRunCount, 1)
- assert.Equal(t, suiteTester.TestSubtestRunCount, 1)
-
- assert.Equal(t, suiteTester.TearDownSubTestRunCount, 2)
- assert.Equal(t, suiteTester.SetupSubTestRunCount, 2)
-
- // Methods that don't match the test method identifier shouldn't
- // have been run at all.
- assert.Equal(t, suiteTester.NonTestMethodRunCount, 0)
-
- suiteSkipTester := new(SuiteSkipTester)
- Run(t, suiteSkipTester)
-
- // The suite was only run once, so the SetupSuite and TearDownSuite
- // methods should have each been run only once, even though SetupSuite
- // called Skip()
- assert.Equal(t, suiteSkipTester.SetupSuiteRunCount, 1)
- assert.Equal(t, suiteSkipTester.TearDownSuiteRunCount, 1)
-
-}
-
-// This suite has no Test... methods. It's setup and teardown must be skipped.
-type SuiteSetupSkipTester struct {
- Suite
-
- setUp bool
- toreDown bool
-}
-
-func (s *SuiteSetupSkipTester) SetupSuite() {
- s.setUp = true
-}
-
-func (s *SuiteSetupSkipTester) NonTestMethod() {
-
-}
-
-func (s *SuiteSetupSkipTester) TearDownSuite() {
- s.toreDown = true
-}
-
-func TestSkippingSuiteSetup(t *testing.T) {
- suiteTester := new(SuiteSetupSkipTester)
- Run(t, suiteTester)
- assert.False(t, suiteTester.setUp)
- assert.False(t, suiteTester.toreDown)
-}
-
-func TestSuiteGetters(t *testing.T) {
- suite := new(SuiteTester)
- suite.SetT(t)
- assert.NotNil(t, suite.Assert())
- assert.Equal(t, suite.Assertions, suite.Assert())
- assert.NotNil(t, suite.Require())
- assert.Equal(t, suite.require, suite.Require())
-}
-
-type SuiteLoggingTester struct {
- Suite
-}
-
-func (s *SuiteLoggingTester) TestLoggingPass() {
- s.T().Log("TESTLOGPASS")
-}
-
-func (s *SuiteLoggingTester) TestLoggingFail() {
- s.T().Log("TESTLOGFAIL")
- assert.NotNil(s.T(), nil) // expected to fail
-}
-
-type StdoutCapture struct {
- oldStdout *os.File
- readPipe *os.File
-}
-
-func (sc *StdoutCapture) StartCapture() {
- sc.oldStdout = os.Stdout
- sc.readPipe, os.Stdout, _ = os.Pipe()
-}
-
-func (sc *StdoutCapture) StopCapture() (string, error) {
- if sc.oldStdout == nil || sc.readPipe == nil {
- return "", errors.New("StartCapture not called before StopCapture")
- }
- os.Stdout.Close()
- os.Stdout = sc.oldStdout
- bytes, err := ioutil.ReadAll(sc.readPipe)
- if err != nil {
- return "", err
- }
- return string(bytes), nil
-}
-
-func TestSuiteLogging(t *testing.T) {
- suiteLoggingTester := new(SuiteLoggingTester)
- capture := StdoutCapture{}
- internalTest := testing.InternalTest{
- Name: "SomeTest",
- F: func(subT *testing.T) {
- Run(subT, suiteLoggingTester)
- },
- }
- capture.StartCapture()
- testing.RunTests(allTestsFilter, []testing.InternalTest{internalTest})
- output, err := capture.StopCapture()
- require.NoError(t, err, "Got an error trying to capture stdout and stderr!")
- require.NotEmpty(t, output, "output content must not be empty")
-
- // Failed tests' output is always printed
- assert.Contains(t, output, "TESTLOGFAIL")
-
- if testing.Verbose() {
- // In verbose mode, output from successful tests is also printed
- assert.Contains(t, output, "TESTLOGPASS")
- } else {
- assert.NotContains(t, output, "TESTLOGPASS")
- }
-}
-
-type CallOrderSuite struct {
- Suite
- callOrder []string
-}
-
-func (s *CallOrderSuite) call(method string) {
- time.Sleep(time.Duration(rand.Intn(300)) * time.Millisecond)
- s.callOrder = append(s.callOrder, method)
-}
-
-func TestSuiteCallOrder(t *testing.T) {
- Run(t, new(CallOrderSuite))
-}
-func (s *CallOrderSuite) SetupSuite() {
- s.call("SetupSuite")
-}
-
-func (s *CallOrderSuite) TearDownSuite() {
- s.call("TearDownSuite")
- assert.Equal(s.T(), "SetupSuite;SetupTest;Test A;TearDownTest;SetupTest;Test B;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
-}
-func (s *CallOrderSuite) SetupTest() {
- s.call("SetupTest")
-}
-
-func (s *CallOrderSuite) TearDownTest() {
- s.call("TearDownTest")
-}
-
-func (s *CallOrderSuite) Test_A() {
- s.call("Test A")
-}
-
-func (s *CallOrderSuite) Test_B() {
- s.call("Test B")
-}
-
-type suiteWithStats struct {
- Suite
- wasCalled bool
- stats *SuiteInformation
-}
-
-func (s *suiteWithStats) HandleStats(suiteName string, stats *SuiteInformation) {
- s.wasCalled = true
- s.stats = stats
-}
-
-func (s *suiteWithStats) TestSomething() {
- s.Equal(1, 1)
-}
-
-func (s *suiteWithStats) TestPanic() {
- panic("oops")
-}
-
-func TestSuiteWithStats(t *testing.T) {
- suiteWithStats := new(suiteWithStats)
-
- testing.RunTests(allTestsFilter, []testing.InternalTest{
- {
- Name: "WithStats",
- F: func(t *testing.T) {
- Run(t, suiteWithStats)
- },
- },
- })
-
- assert.True(t, suiteWithStats.wasCalled)
- assert.NotZero(t, suiteWithStats.stats.Start)
- assert.NotZero(t, suiteWithStats.stats.End)
- assert.False(t, suiteWithStats.stats.Passed())
-
- testStats := suiteWithStats.stats.TestStats
-
- assert.NotZero(t, testStats["TestSomething"].Start)
- assert.NotZero(t, testStats["TestSomething"].End)
- assert.True(t, testStats["TestSomething"].Passed)
-
- assert.NotZero(t, testStats["TestPanic"].Start)
- assert.NotZero(t, testStats["TestPanic"].End)
- assert.False(t, testStats["TestPanic"].Passed)
-}
-
-// FailfastSuite will test the behavior when running with the failfast flag
-// It logs calls in the callOrder slice which we then use to assert the correct calls were made
-type FailfastSuite struct {
- Suite
- callOrder []string
-}
-
-func (s *FailfastSuite) call(method string) {
- s.callOrder = append(s.callOrder, method)
-}
-
-func TestFailfastSuite(t *testing.T) {
- // This test suite is run twice. Once normally and once with the -failfast flag by TestFailfastSuiteFailFastOn
- // If you need to debug it run this test directly with the failfast flag set on/off as you need
- failFast := flag.Lookup("test.failfast").Value.(flag.Getter).Get().(bool)
- s := new(FailfastSuite)
- ok := testing.RunTests(
- allTestsFilter,
- []testing.InternalTest{{
- Name: "TestFailfastSuite",
- F: func(t *testing.T) {
- Run(t, s)
- },
- }},
- )
- assert.Equal(t, false, ok)
- if failFast {
- // Test A Fails and because we are running with failfast Test B never runs and we proceed straight to TearDownSuite
- assert.Equal(t, "SetupSuite;SetupTest;Test A Fails;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
- } else {
- // Test A Fails and because we are running without failfast we continue and run Test B and then proceed to TearDownSuite
- assert.Equal(t, "SetupSuite;SetupTest;Test A Fails;TearDownTest;SetupTest;Test B Passes;TearDownTest;TearDownSuite", strings.Join(s.callOrder, ";"))
- }
-}
-func TestFailfastSuiteFailFastOn(t *testing.T) {
- // To test this with failfast on (and isolated from other intended test failures in our test suite) we launch it in its own process
- cmd := exec.Command("go", "test", "-v", "-race", "-run", "TestFailfastSuite", "-failfast")
- var out bytes.Buffer
- cmd.Stdout = &out
- t.Log("Running go test -v -race -run TestFailfastSuite -failfast")
- err := cmd.Run()
- t.Log(out.String())
- if err != nil {
- t.Log(err)
- t.Fail()
- }
-}
-func (s *FailfastSuite) SetupSuite() {
- s.call("SetupSuite")
-}
-
-func (s *FailfastSuite) TearDownSuite() {
- s.call("TearDownSuite")
-}
-func (s *FailfastSuite) SetupTest() {
- s.call("SetupTest")
-}
-
-func (s *FailfastSuite) TearDownTest() {
- s.call("TearDownTest")
-}
-
-func (s *FailfastSuite) Test_A_Fails() {
- s.call("Test A Fails")
- s.T().Error("Test A meant to fail")
-}
-
-func (s *FailfastSuite) Test_B_Passes() {
- s.call("Test B Passes")
- s.Require().True(true)
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/CHANGELOG.tpl.md b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/CHANGELOG.tpl.md
deleted file mode 100644
index 8e98c0bf98c7470201b177f755da8cd7bb424663..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/CHANGELOG.tpl.md
+++ /dev/null
@@ -1,27 +0,0 @@
-{{ range .Versions }}
-<a name="{{ .Tag.Name }}"></a>
-## {{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }} - {{ datetime "2006-01-02" .Tag.Date }}
-{{ range .CommitGroups -}}
-### {{ .Title }}
-{{ range .Commits -}}
-- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
-{{ end }}
-{{ end -}}
-
-{{- if .NoteGroups -}}
-{{ range .NoteGroups -}}
-### {{ .Title }}
-{{ range .Notes }}
-{{ .Body }}
-{{ end }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
-
-{{- if .Versions }}
-{{ range .Versions -}}
-{{ if .Tag.Previous -}}
-[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/config.yml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/config.yml
deleted file mode 100644
index 237f6bc7aabf8d8a0043683194892d61df03668c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.chglog/config.yml
+++ /dev/null
@@ -1,57 +0,0 @@
-style: gitlab
-template: CHANGELOG.tpl.md
-info:
- title: CHANGELOG
- repository_url: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-options:
- commits:
- filters:
- Type:
- - feat
- - fix
- - doc
- - refactor
- - perf
- - test
- - chore
- ## deprecated types and typos
- - docs
- - documentation
- - feat
- - added
- - add
- - bugfix
- - revert
- - update
- - updates
- - change
- - changed
- commit_groups:
- title_maps:
- feat: Add Features
- fix: Bug Fixes
- doc: Documentation
- refactor: Code Refactoring
- perf: Performance Improvements
- test: Tests
- ## Chore is used for all other changes that don't fit in the other categories
- chore: Changes
- ## deprecated types and typos
- docs: Documentation
- documentation: Documentation
- added: Add Features
- add: Add Features
- bugfix: Bug Fixes
- revert: Reverts
- update: Changes
- updates: Changes
- change: Changes
- changed: Changes
- header:
- pattern: "^((\\w+)\\s.*)$"
- pattern_maps:
- - Subject
- - Type
- notes:
- keywords:
- - BREAKING CHANGE
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.gitignore b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.gitignore
deleted file mode 100644
index c55f7d029ba6d56ff0080797e6bfd7a4f7b7867b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/.gitignore
+++ /dev/null
@@ -1,149 +0,0 @@
-# Created by https://www.toptal.com/developers/gitignore/api/intellij,go
-# Edit at https://www.toptal.com/developers/gitignore?templates=intellij,go
-
-### Go ###
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-testdata/
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-
-# Go Fuzz build
-testdata/
-
-### Go Patch ###
-/vendor/
-/Godeps/
-
-### Intellij ###
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# AWS User-specific
-.idea/**/aws.xml
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn. Uncomment if using
-# auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# SonarLint plugin
-.idea/sonarlint/
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-### Intellij Patch ###
-# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
-
-# *.iml
-# modules.xml
-# .idea/misc.xml
-# *.ipr
-
-# Sonarlint plugin
-# https://plugins.jetbrains.com/plugin/7973-sonarlint
-.idea/**/sonarlint/
-
-# SonarQube Plugin
-# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
-.idea/**/sonarIssues.xml
-
-# Markdown Navigator plugin
-# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
-.idea/**/markdown-navigator.xml
-.idea/**/markdown-navigator-enh.xml
-.idea/**/markdown-navigator/
-
-# Cache file creation bug
-# See https://youtrack.jetbrains.com/issue/JBR-2257
-.idea/$CACHE_FILE$
-
-# CodeStream plugin
-# https://plugins.jetbrains.com/plugin/12206-codestream
-.idea/codestream.xml
-
-# Azure Toolkit for IntelliJ plugin
-# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
-.idea/**/azureSettings.xml
-
-# End of https://www.toptal.com/developers/gitignore/api/intellij,go
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/CHANGELOG.md b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/CHANGELOG.md
deleted file mode 100644
index 859750c6e1aef2a330d820f26d18d1c09533718f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/CHANGELOG.md
+++ /dev/null
@@ -1,37 +0,0 @@
-
-<a name="v0.5.2"></a>
-## [v0.5.2] - 2022-12-23
-
-<a name="v0.5.1"></a>
-## [v0.5.1] - 2022-12-23
-
-<a name="v0.5.0"></a>
-## [v0.5.0] - 2022-12-18
-
-<a name="v0.4.0"></a>
-## [v0.4.0] - 2022-12-17
-
-<a name="v0.3.1"></a>
-## [v0.3.1] - 2022-10-16
-### Bug Fixes
-- fix secure access to structure with a constraint
-
-
-<a name="v0.3.0"></a>
-## [v0.3.0] - 2022-10-15
-### Code Refactoring
-- refactor change function signatur
-
-
-<a name="v0.2.0"></a>
-## v0.2.0 - 2022-10-15
-### Add Features
-- feat takeover from other project
-
-
-[v0.5.2]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.5.1...v0.5.2
-[v0.5.1]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.5.0...v0.5.1
-[v0.5.0]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.4.0...v0.5.0
-[v0.4.0]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.3.1...v0.4.0
-[v0.3.1]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.3.0...v0.3.1
-[v0.3.0]: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder/compare/v0.2.0...v0.3.0
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/LICENSE b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/LICENSE
deleted file mode 100644
index 22686f9fe879acaa7d1db639310a955de05b0d2a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/LICENSE
+++ /dev/null
@@ -1,662 +0,0 @@
- GNU AFFERO GENERAL PUBLIC LICENSE
- Version 3, 19 November 2007
- AGPL-3.0
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
- The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
- Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
- A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate. Many developers of free software are heartened and
-encouraged by the resulting cooperation. However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
- The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community. It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server. Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
- An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals. This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- TERMS AND CONDITIONS
-
- 0. Definitions.
-
- "This License" refers to version 3 of the GNU Affero General Public License.
-
- "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
- "The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
- To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy. The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
- A "covered work" means either the unmodified Program or a work based
-on the Program.
-
- To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
- To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
- An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
- 1. Source Code.
-
- The "source code" for a work means the preferred form of the work
-for making modifications to it. "Object code" means any non-source
-form of a work.
-
- A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
- The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
- The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
- The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
- The Corresponding Source for a work in source code form is that
-same work.
-
- 2. Basic Permissions.
-
- All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
- You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force. You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright. Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
- Conveying under any other circumstances is permitted solely under
-the conditions stated below. Sublicensing is not allowed; section 10
-makes it unnecessary.
-
- 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
- No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
- When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
- 4. Conveying Verbatim Copies.
-
- You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
- You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
- 5. Conveying Modified Source Versions.
-
- You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
- a) The work must carry prominent notices stating that you modified
- it, and giving a relevant date.
-
- b) The work must carry prominent notices stating that it is
- released under this License and any conditions added under section
- 7. This requirement modifies the requirement in section 4 to
- "keep intact all notices".
-
- c) You must license the entire work, as a whole, under this
- License to anyone who comes into possession of a copy. This
- License will therefore apply, along with any applicable section 7
- additional terms, to the whole of the work, and all its parts,
- regardless of how they are packaged. This License gives no
- permission to license the work in any other way, but it does not
- invalidate such permission if you have separately received it.
-
- d) If the work has interactive user interfaces, each must display
- Appropriate Legal Notices; however, if the Program has interactive
- interfaces that do not display Appropriate Legal Notices, your
- work need not make them do so.
-
- A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
- 6. Conveying Non-Source Forms.
-
- You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
- a) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by the
- Corresponding Source fixed on a durable physical medium
- customarily used for software interchange.
-
- b) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by a
- written offer, valid for at least three years and valid for as
- long as you offer spare parts or customer support for that product
- model, to give anyone who possesses the object code either (1) a
- copy of the Corresponding Source for all the software in the
- product that is covered by this License, on a durable physical
- medium customarily used for software interchange, for a price no
- more than your reasonable cost of physically performing this
- conveying of source, or (2) access to copy the
- Corresponding Source from a network server at no charge.
-
- c) Convey individual copies of the object code with a copy of the
- written offer to provide the Corresponding Source. This
- alternative is allowed only occasionally and noncommercially, and
- only if you received the object code with such an offer, in accord
- with subsection 6b.
-
- d) Convey the object code by offering access from a designated
- place (gratis or for a charge), and offer equivalent access to the
- Corresponding Source in the same way through the same place at no
- further charge. You need not require recipients to copy the
- Corresponding Source along with the object code. If the place to
- copy the object code is a network server, the Corresponding Source
- may be on a different server (operated by you or a third party)
- that supports equivalent copying facilities, provided you maintain
- clear directions next to the object code saying where to find the
- Corresponding Source. Regardless of what server hosts the
- Corresponding Source, you remain obligated to ensure that it is
- available for as long as needed to satisfy these requirements.
-
- e) Convey the object code using peer-to-peer transmission, provided
- you inform other peers where the object code and Corresponding
- Source of the work are being offered to the general public at no
- charge under subsection 6d.
-
- A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
- A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling. In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage. For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product. A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
- "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source. The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
- If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
- The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed. Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
- Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
- 7. Additional Terms.
-
- "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
- When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
- Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
- a) Disclaiming warranty or limiting liability differently from the
- terms of sections 15 and 16 of this License; or
-
- b) Requiring preservation of specified reasonable legal notices or
- author attributions in that material or in the Appropriate Legal
- Notices displayed by works containing it; or
-
- c) Prohibiting misrepresentation of the origin of that material, or
- requiring that modified versions of such material be marked in
- reasonable ways as different from the original version; or
-
- d) Limiting the use for publicity purposes of names of licensors or
- authors of the material; or
-
- e) Declining to grant rights under trademark law for use of some
- trade names, trademarks, or service marks; or
-
- f) Requiring indemnification of licensors and authors of that
- material by anyone who conveys the material (or modified versions of
- it) with contractual assumptions of liability to the recipient, for
- any liability that these contractual assumptions directly impose on
- those licensors and authors.
-
- All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
- If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
- Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
- 8. Termination.
-
- You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
- However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
- Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
- Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
- 9. Acceptance Not Required for Having Copies.
-
- You are not required to accept this License in order to receive or
-run a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
- 10. Automatic Licensing of Downstream Recipients.
-
- Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
- An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
- You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
- 11. Patents.
-
- A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
- A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
- Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
- In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
- If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
- If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
- A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License. You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
- Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
- 12. No Surrender of Others' Freedom.
-
- If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all. For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
- 13. Remote Network Interaction; Use with the GNU General Public License.
-
- Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software. This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
- Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
- 14. Revised Versions of this License.
-
- The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time. Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation. If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
- If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
- Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
- 15. Disclaimer of Warranty.
-
- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. Limitation of Liability.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
- 17. Interpretation of Sections 15 and 16.
-
- If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- <one line to give the program's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
- If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source. For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code. There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
- You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/Makefile b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/Makefile
deleted file mode 100644
index c149982aa9f602b5dfb1aba0ced25241a1a8b472..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/Makefile
+++ /dev/null
@@ -1,157 +0,0 @@
-## Copyright 2022 schukai GmbH. All rights reserved.
-## Use of this source code is governed by a AGPL-3.0
-## license that can be found in the LICENSE file.
-
-PROJECT_ROOT:=$(dir $(realpath $(lastword $(MAKEFILE_LIST))))
-THIS_MAKEFILE:=$(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
-THIS_MAKEFILE_PATH:=$(PROJECT_ROOT)$(THIS_MAKEFILE)
-
-# @see .PHONY https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html#Phony-Targets
-.DEFAULT_GOAL := help
-
-.PHONY: print
-## Print Path
-print:
- @echo "THIS_MAKEFILE: $(THIS_MAKEFILE)"
- @echo "THIS_MAKEFILE_PATH: $(THIS_MAKEFILE_PATH)"
- @echo "PROJECT_ROOT: $(PROJECT_ROOT)"
-
-# Add a comment to the public targets so that it appears
-# in this help Use two # characters for a help comment
-.PHONY: help
-help:
- @printf "${COMMENT}Usage:${RESET}\n"
- @printf " make [target] [arg=\"val\"...]\n\n"
- @printf "${COMMENT}Available targets:${RESET}\n"
- @awk '/^[a-zA-Z\-\\_0-9\.@]+:/ { \
- helpMessage = match(lastLine, /^## (.*)/); \
- if (helpMessage) { \
- helpCommand = substr($$1, 0, index($$1, ":")); \
- helpMessage = substr(lastLine, RSTART + 3, RLENGTH); \
- printf " ${INFO}%-22s${RESET} %s\n", helpCommand, helpMessage; \
- } \
- } \
- { lastLine = $$0 }' $(MAKEFILE_LIST)
- @printf "\n${COMMENT}Available arguments:${RESET}\n\n"
- @awk '/^(([a-zA-Z\-\\_0-9\.@]+)\s[?:]?=)/ { \
- helpMessage = match(lastLine, /^## (.*)/); \
- if (helpMessage) { \
- helpMessage = substr(lastLine, RSTART + 3, RLENGTH); \
- printf " ${INFO}%-22s${RESET} %s (Default: %s)\n", $$1, helpMessage, $$3; \
- } \
- } \
- { lastLine = $$0 }' $(MAKEFILE_LIST)
-
-
-## run tests
-test:
- echo "Running tests"
- go test -cover -v ./...
-
-## run tests with fuzzing
-test-fuzz:
- echo "Running fuzz tests"
- go test -v -fuzztime=30s -fuzz=Fuzz ./...
-
-#### VERSION
-BIN_DIR ?= $(shell echo $$HOME)/.local/bin/
-VERSION_NAME := version
-EXECUTABLES = $(EXECUTABLES:-) $(VERSION_NAME)
-VERSION_BIN_PATH := $(BIN_DIR)$(VERSION_NAME)
-
-VERSION_BIN := $(shell command -v $(VERSION_NAME) 2> /dev/null)
-
-ifndef VERSION_BIN
- $(shell curl -o $(VERSION_BIN_PATH) http://download.schukai.com/tools/version/version-$(shell uname -s | tr [:upper:] [:lower:])-$(shell echo `uname -m | sed s/aarch64/arm64/ | sed s/x86_64/amd64/`))
- $(shell chmod +x $(VERSION_BIN_PATH))
-endif
-
-GIT_CHGLOG_BIN := $(shell command -v git-chglog 2> /dev/null)
-
-ifeq ($(GIT_CHGLOG_BIN),)
- $(shell go install github.com/git-chglog/git-chglog/cmd/git-chglog@latest)
-endif
-
-RELEASE_FILE ?= $(PROJECT_ROOT)release.json
-CHANGELOG_FILE ?= $(PROJECT_ROOT)CHANGELOG.md
-
-ifeq ("$(wildcard $(RELEASE_FILE))","")
- $(shell echo '{"version":"0.1.0"}' > $(RELEASE_FILE))
-endif
-
-PROJECT_VERSION ?= $(shell cat $(RELEASE_FILE) | jq -r .version)
-PROJECT_BUILD_DATE ?= $(shell $(VERSION_BIN) date)
-
-.PHONY: next-patch-version
-next-patch-version: check-clean-repo
- echo "Creating next version"
- $(VERSION_BIN) patch --path $(RELEASE_FILE) --selector "version"
- git add $(RELEASE_FILE) && git commit -m "Bump version to $$(cat $(RELEASE_FILE) | jq -r .version)"
-
-.PHONY: next-minor-version
-next-minor-version: check-clean-repo
- echo "Creating next minor version"
- $(VERSION_BIN) minor --path $(RELEASE_FILE) --selector "version"
- git add $(RELEASE_FILE) && git commit -m "Bump version to $$( cat $(RELEASE_FILE) | jq -r .version)"
-
-.PHONY: next-major-version
-next-major-version: check-clean-repo
- echo "Creating next minor version"
- $(VERSION_BIN) major --path $(RELEASE_FILE) --selector "version"
- git add $(RELEASE_FILE) && git commit -m "Bump version to $$(cat $(RELEASE_FILE) | jq -r .version)"
-
-.PHONY: check-clean-repo
-check-clean-repo:
- git diff-index --quiet HEAD || (echo "There are uncommitted changes after running make. Please commit or stash them before running make."; exit 1)
-
-## tag repository with next patch version
-tag-patch-version: next-patch-version
- echo "Tagging patch version"
- $(eval PROJECT_VERSION := $(shell cat $(RELEASE_FILE) | jq -r .version))
- git-chglog --next-tag v$(PROJECT_VERSION) -o $(CHANGELOG_FILE)
- git add $(CHANGELOG_FILE) && git commit -m "Update changelog"
- git tag -a v$(PROJECT_VERSION) -m "Version $(PROJECT_VERSION)"
-
-## tag repository with next minor version
-tag-minor-version: next-minor-version
- echo "Tagging minor version"
- $(eval PROJECT_VERSION := $(shell cat $(RELEASE_FILE) | jq -r .version))
- git-chglog --next-tag v$(PROJECT_VERSION) -o $(CHANGELOG_FILE)
- git add $(CHANGELOG_FILE) && git commit -m "Update changelog"
- git tag -a v$(PROJECT_VERSION) -m "Version $(PROJECT_VERSION)"
-
-## tag repository with next major version
-tag-major-version: next-major-version
- echo "Tagging major version"
- $(eval PROJECT_VERSION := $(shell cat $(RELEASE_FILE) | jq -r .version))
- git-chglog --next-tag v$(PROJECT_VERSION) -o $(CHANGELOG_FILE)
- git add $(CHANGELOG_FILE) && git commit -m "Update changelog"
- git tag -a v$(PROJECT_VERSION) -m "Version $(PROJECT_VERSION)"
-
-GO_MOD_FILE := $(SOURCE_PATH)go.mod
-
-ifeq ($(shell test -e $(GO_MOD_FILE) && echo -n yes),yes)
- GO_CURRENT_MODULE := $(shell cat $(GO_MOD_FILE) | head -n1 | cut -d" " -f2)
- # go install github.com/google/go-licenses@latest
- EXECUTABLES = $(EXECUTABLES:-) go-licenses;
-endif
-
-.PHONY: fetch-licenses
-## Fetch licenses for all modules
-fetch-licenses:
- go-licenses save $(GO_CURRENT_MODULE) --ignore gitlab.schukai.com --force --save_path $(PROJECT_ROOT)licenses/
-
-# https://spdx.github.io/spdx-spec/v2.3/SPDX-license-list/
-ADDLICENSE_BIN ?= addlicense
-ifeq ($(shell command -v $(ADDLICENSE_BIN) 2> /dev/null),)
- $(shell go install github.com/google/addlicense@latest)
- EXECUTABLES = $(EXECUTABLES:-) $(ADDLICENSE_BIN);
-endif
-
-.PHONY: add-licenses
-## Add license headers to all go files
-add-licenses:
- addlicense -c "schukai GmbH" -s -l "AGPL-3.0" ./*.go
-
-
-
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/README.md b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/README.md
deleted file mode 100644
index 4d1522c15b54f8c311a7cedeb5c6bfad357b9053..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/README.md
+++ /dev/null
@@ -1,69 +0,0 @@
-## Pathfinder
-
-## What does this library?
-
-This library provides a simple way to get and set values in a nested structure.
-
-It supports:
-
-* [X] Set values in a nested structure
-* [X] Get values from a nested structure
-
-## Installation
-
-```shell
-go get gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-```
-
-**Note:** This library uses [Go Modules](https://github.com/golang/go/wiki/Modules) to manage dependencies.
-
-## Usage
-
-### Set values
-
-```go
-s := &StructA{}
-err := GetValue[*StructA](s, "my.key")
-```
-
-### Get values
-
-```go
-s := &StructA{}
-err := SetValue[*StructA](s, "my.key", "value")
-```
-
-## Contributing
-
-Merge requests are welcome. For major changes, please open an issue first to discuss what
-you would like to change. **Please make sure to update tests as appropriate.**
-
-Versioning is done with [SemVer](https://semver.org/).
-Changelog is generated with [git-chglog](https://github.com/git-chglog/git-chglog#git-chglog)
-
-Commit messages should follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
-Messages are started with a type, which is one of the following:
-
-- **feat**: A new feature
-- **fix**: A bug fix
-- **doc**: Documentation only changes
-- **refactor**: A code change that neither fixes a bug nor adds a feature
-- **perf**: A code change that improves performance
-- **test**: Adding missing or correcting existing tests
-- **chore**: Other changes that don't modify src or test files
-
-The footer would be used for a reference to an issue or a breaking change.
-
-A commit that has a footer `BREAKING CHANGE:`, or appends a ! after the type/scope,
-introduces a breaking API change (correlating with MAJOR in semantic versioning).
-A BREAKING CHANGE can be part of commits of any type.
-
-the following is an example of a commit message:
-
-```text
-feat: add 'extras' field
-```
-
-## License
-
-[AGPL-3.0](https://choosealicense.com/licenses/agpl-3.0/)
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error.go
deleted file mode 100644
index 614b13e8adaf28a9c606b9d0c847cbd80e7a4ca3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "errors"
- "reflect"
-)
-
-type InvalidPathError error
-
-func newInvalidPathError(path string) InvalidPathError {
- return InvalidPathError(errors.New("invalid path " + path))
-}
-
-type UnsupportedTypeAtTopOfPathError error
-
-func newUnsupportedTypeAtTopOfPathError(path string, t reflect.Type) UnsupportedTypeAtTopOfPathError {
- return UnsupportedTypeAtTopOfPathError(errors.New("unsupported type " + t.String() + " at top of path " + path))
-}
-
-type UnsupportedTypePathError error
-
-func newUnsupportedTypePathError(path string, t reflect.Type) UnsupportedTypePathError {
- return UnsupportedTypePathError(errors.New("unsupported type " + t.String() + " at path " + path))
-}
-
-type CannotSetError error
-
-func newCannotSetError(name string) CannotSetError {
- return CannotSetError(errors.New("cannot set " + name))
-}
-
-type InvalidTypeForPathError error
-
-func newInvalidTypeForPathError(path string, pt string, nt string) InvalidTypeForPathError {
- return InvalidTypeForPathError(errors.New("invalid type for path " + path + ": expected " + pt + ", got " + nt))
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error_test.go
deleted file mode 100644
index e2459466e1cfaf9f0c4725995203ee005cb2bf2d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/error_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "github.com/stretchr/testify/assert"
- "reflect"
- "testing"
-)
-
-func TestInvalidPathError(t *testing.T) {
- err := newInvalidPathError("test")
- _, ok := err.(InvalidPathError)
- assert.True(t, ok)
-}
-
-func TestUnsupportedTypeAtTopOfPathError(t *testing.T) {
- err := newUnsupportedTypeAtTopOfPathError("test", reflect.TypeOf(1))
- _, ok := err.(UnsupportedTypeAtTopOfPathError)
- assert.True(t, ok)
-}
-
-func TestUnsupportedTypePathError(t *testing.T) {
- err := newUnsupportedTypePathError("test", reflect.TypeOf(1))
- _, ok := err.(UnsupportedTypePathError)
- assert.True(t, ok)
-}
-
-func TestCannotSetError(t *testing.T) {
- err := newCannotSetError("test")
- _, ok := err.(CannotSetError)
- assert.True(t, ok)
-}
-
-func TestInvalidTypeForPathError(t *testing.T) {
- err := newInvalidTypeForPathError("test", "test", "test")
- _, ok := err.(InvalidTypeForPathError)
- assert.True(t, ok)
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get.go
deleted file mode 100644
index 79789c408c1562f857fc69d1000d702fa5e0246c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "reflect"
- "strconv"
- "strings"
-)
-
-// This function returns the value of a field in a struct, given a path to the field.
-func GetValue[D any](obj D, keyWithDots string) (any, error) {
- keySlice := strings.Split(keyWithDots, ".")
- v := reflect.ValueOf(obj)
-
- for _, key := range keySlice[0:len(keySlice)] {
-
- switch v.Kind() {
- case reflect.Ptr, reflect.Slice, reflect.Array, reflect.Interface:
- v = v.Elem()
- }
-
- switch v.Kind() {
- case reflect.Map:
- v = v.MapIndex(reflect.ValueOf(key))
- if !v.IsValid() {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- case reflect.Slice, reflect.Array:
- index, err := strconv.Atoi(key)
- if err != nil {
- return nil, newInvalidPathError(keyWithDots)
- }
- v = v.Index(index)
- case reflect.Struct:
- v = v.FieldByName(key)
- if !v.IsValid() {
- return nil, newInvalidPathError(keyWithDots)
- }
- default:
- return nil, newInvalidPathError(keyWithDots)
- }
-
- }
-
- if v.Kind() == reflect.Invalid {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- for v.Kind() == reflect.Ptr {
- v = v.Elem()
- }
-
- return v.Interface(), nil
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get_test.go
deleted file mode 100644
index 2340260af78af5ad1cae8231fafa199a48d92da6..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/get_test.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "github.com/stretchr/testify/assert"
- "testing"
-)
-
-func TestGetIndexFromArray(t *testing.T) {
- m := map[string]any{
- "A": "true",
- "B": []string{
- "1",
- "2",
- "3",
- },
- }
-
- v, err := GetValue[map[string]any](m, "B.1")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, "2", v)
-
-}
-
-func TestGetValueFrom(t *testing.T) {
-
- m := map[string]string{
- "KeyA": "true",
- "KeyB": "2",
- "KeyC": "3",
- "KeyD": "4.0",
- }
-
- v, err := GetValue[map[string]string](m, "KeyA")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, v, "true")
-
-}
-
-func TestPathGetValueFromX(t *testing.T) {
- m := map[string]any{
- "A": "true",
- "B": map[string]any{
- "C": 2,
- "D": map[string]any{
- "E": "3",
- },
- },
- "X": "3",
- "Y": "4.0",
- }
-
- v, err := GetValue[map[string]any](m, "B.D.E")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, "3", v)
-
- v, err = GetValue[map[string]any](m, "B.C")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, 2, v)
-
-}
-
-func TestPathGetValueFrom(t *testing.T) {
-
- type PathfindTestStruct1 struct {
- A bool
- Sub1 struct {
- B int
- Sub2 struct {
- C bool
- }
- D int
- }
- }
-
- var testData PathfindTestStruct1
- testData.A = true
- testData.Sub1.B = 2
- testData.Sub1.Sub2.C = true
- testData.Sub1.D = 4
-
- GetValue[PathfindTestStruct1](testData, "Sub1.B")
- GetValue[PathfindTestStruct1](testData, "Sub1.Sub2.C")
- GetValue[PathfindTestStruct1](testData, "Sub1.D")
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.mod b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.mod
deleted file mode 100644
index 2d2e207e6c216db5da1864b237829dd0213f4d48..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-
-go 1.19
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/stretchr/testify v1.8.0 // indirect
- gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.sum b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.sum
deleted file mode 100644
index b410979a43764db2bd7f77cc065eb839b7d20181..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/go.sum
+++ /dev/null
@@ -1,14 +0,0 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/pathfinder.iml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/pathfinder.iml
deleted file mode 100644
index 49df094a939bad91c791b0986d7e479bcc496640..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/pathfinder.iml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
- <component name="Go" enabled="true" />
- <component name="NewModuleRootManager" inherit-compiler-output="true">
- <exclude-output />
- <content url="file://$MODULE_DIR$" />
- <orderEntry type="inheritedJdk" />
- <orderEntry type="sourceFolder" forTests="false" />
- </component>
-</module>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/release.json b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/release.json
deleted file mode 100644
index ccd00c212fd33519ee25a4425025db1859dd1925..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/release.json
+++ /dev/null
@@ -1 +0,0 @@
-{"version":"0.5.2"}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set.go
deleted file mode 100644
index f5ca2f43314c861ad15eeb3abcf15d50c3463f31..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "fmt"
- "reflect"
- "strconv"
- "strings"
-)
-
-// This function sets the value of a field in a struct, given a path to the field.
-func SetValue[D any](obj D, keyWithDots string, newValue any) error {
-
- keySlice := strings.Split(keyWithDots, ".")
- v := reflect.ValueOf(obj)
-
- for _, key := range keySlice[0 : len(keySlice)-1] {
- for v.Kind() != reflect.Ptr {
- if v.Kind() == reflect.Invalid {
- return newInvalidPathError(keyWithDots)
- }
- v = v.Addr()
- }
-
- if v.Kind() != reflect.Ptr {
- return newUnsupportedTypePathError(keyWithDots, v.Type())
- }
-
- elem := v.Elem()
- if elem.Kind() != reflect.Struct {
- return newUnsupportedTypePathError(keyWithDots, v.Type())
- }
-
- v = elem.FieldByName(key)
-
- }
-
- if v.Kind() == reflect.Invalid {
- return newInvalidPathError(keyWithDots)
- }
-
- for v.Kind() == reflect.Ptr {
- v = v.Elem()
- }
-
- // non-supporter type at the top of the path
- if v.Kind() != reflect.Struct {
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, v.Type())
- }
-
- v = v.FieldByName(keySlice[len(keySlice)-1])
- if !v.IsValid() {
- return newInvalidPathError(keyWithDots)
- }
-
- if !v.CanSet() {
- return newCannotSetError(keyWithDots)
- }
-
- switch v.Kind() {
- case reflect.Ptr:
- if newValue == nil {
- v.Set(reflect.Zero(v.Type()))
- } else {
- v.Set(reflect.ValueOf(&newValue))
- }
- return nil
- }
-
- newValueType := reflect.TypeOf(newValue)
- if newValueType == nil {
- return newUnsupportedTypePathError(keyWithDots, v.Type())
- }
-
- newValueKind := reflect.TypeOf(newValue).Kind()
-
- switch v.Kind() {
- case reflect.String:
- if newValueKind == reflect.String {
- v.SetString(newValue.(string))
- } else {
- v.SetString(fmt.Sprintf("%v", newValue))
- }
-
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-
- if newValueKind == reflect.Int {
- v.SetInt(int64(newValue.(int)))
- } else {
- s, err := strconv.ParseInt(fmt.Sprintf("%v", newValue), 10, 64)
- if err != nil {
- return err
- }
- v.SetInt(s)
- }
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-
- if newValueKind == reflect.Int {
- v.SetUint(uint64(newValue.(int)))
- } else {
- s, err := strconv.ParseInt(fmt.Sprintf("%v", newValue), 10, 64)
- if err != nil {
- return err
- }
- v.SetUint(uint64(s))
- }
-
- case reflect.Bool:
-
- if newValueKind == reflect.Bool {
- v.SetBool(newValue.(bool))
- } else {
- b, err := strconv.ParseBool(fmt.Sprintf("%v", newValue))
- if err != nil {
- return err
- }
-
- v.SetBool(b)
- }
-
- case reflect.Float64, reflect.Float32:
-
- if newValueKind == reflect.Float64 {
- v.SetFloat(newValue.(float64))
- } else {
- s, err := strconv.ParseFloat(fmt.Sprintf("%v", newValue), 64)
- if err != nil {
- return err
- }
-
- v.SetFloat(s)
- }
-
- case reflect.Slice, reflect.Array:
-
- if newValueKind == reflect.Ptr {
- newValue = reflect.ValueOf(newValue).Elem().Interface()
- v.Set(reflect.ValueOf(newValue))
- } else if newValueKind == reflect.Slice {
- v.Set(reflect.ValueOf(newValue))
- } else {
- return newUnsupportedTypePathError(keyWithDots, v.Type())
- }
-
- default:
- return newInvalidTypeForPathError(keyWithDots, v.Type().String(), newValueKind.String())
- }
-
- return nil
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set_test.go
deleted file mode 100644
index 37adcb7f17068bc574fcffecfb4973e35bb9139b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.5.2/set_test.go
+++ /dev/null
@@ -1,278 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import "testing"
-
-type PathfindTestStruct1 struct {
- A bool
- Sub1 struct {
- B bool
- Bi int
- Bs string
- Bf float64
- Sub2 struct {
- C bool
- Ci int
- Cs string
- Cf float64
-
- Sub3 struct {
- D bool
- Di int
- Ds string
- Df float64
- }
- }
- }
-}
-
-func TestPathFindError(t *testing.T) {
-
- s := PathfindTestStruct1{}
-
- _, err := GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.XX")
- if err == nil {
- t.Error("err == nil")
- }
-
-}
-
-func TestPathFindSetValueString(t *testing.T) {
-
- testData := map[string]string{
- "Sub1.B": "true",
- "Sub1.Bi": "2",
- "Sub1.Bs": "3",
- "Sub1.Bf": "4.0",
- "Sub1.Sub2.C": "true",
- "Sub1.Sub2.Ci": "2",
- "Sub1.Sub2.Cs": "3",
- "Sub1.Sub2.Cf": "4.0",
- "Sub1.Sub2.Sub3.D": "true",
- "Sub1.Sub2.Sub3.Di": "2",
- "Sub1.Sub2.Sub3.Ds": "3",
- "Sub1.Sub2.Sub3.Df": "4.0",
- }
-
- for k, v := range testData {
- s := &PathfindTestStruct1{}
- err := SetValue[*PathfindTestStruct1](s, k, v)
- if err != nil {
- t.Error(err)
- }
- }
-}
-
-func TestPathFindGetValueFrom(t *testing.T) {
-
- s := PathfindTestStruct1{}
-
- s.Sub1.B = true
- s.Sub1.Bi = 2
- s.Sub1.Bs = "3"
- s.Sub1.Bf = 4.0
-
- v, err := GetValue[PathfindTestStruct1](s, "Sub1.B")
- if err != nil {
- t.Error(err)
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bi")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bs")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bf")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
- s.Sub1.Sub2.C = true
- s.Sub1.Sub2.Ci = 2
- s.Sub1.Sub2.Cs = "3"
- s.Sub1.Sub2.Cf = 4.0
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.C")
- if err != nil {
- t.Error(err)
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Ci")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Cs")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Cf")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
- s.Sub1.Sub2.Sub3.D = true
- s.Sub1.Sub2.Sub3.Di = 2
- s.Sub1.Sub2.Sub3.Ds = "3"
- s.Sub1.Sub2.Sub3.Df = 4.0
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.D")
- if err != nil {
- t.Error(err)
-
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Di")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Ds")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Df")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
-}
-
-func TestPathFindSetValueFrom(t *testing.T) {
- s := &PathfindTestStruct1{}
-
- SetValue[*PathfindTestStruct1](s, "Sub1.B", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bi", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bs", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bf", "4.0")
-
- if s.Sub1.B != true {
- t.Error("s.Sub1.B != true")
- }
-
- if s.Sub1.Bi != 2 {
- t.Error("s.Sub1.Bi != 2")
-
- }
-
- if s.Sub1.Bs != "3" {
- t.Error("s.Sub1.Bs != 3")
- }
-
- if s.Sub1.Bf != 4.0 {
- t.Error("s.Sub1.Bf != 4.0")
- }
-
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.C", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Ci", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Cs", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Cf", "4.0")
-
- if s.Sub1.Sub2.C != true {
- t.Error("s.Sub1.Sub2.C != true")
-
- }
-
- if s.Sub1.Sub2.Ci != 2 {
- t.Error("s.Sub1.Sub2.Ci != 2")
-
- }
-
- if s.Sub1.Sub2.Cs != "3" {
- t.Error("s.Sub1.Sub2.Cs != 3")
-
- }
-
- if s.Sub1.Sub2.Cf != 4.0 {
- t.Error("s.Sub1.Sub2.Cf != 4.0")
-
- }
-
- if s.Sub1.Sub2.Sub3.D != false {
- t.Error("s.Sub1.Sub2.Sub3.D != false")
-
- }
-
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.D", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Di", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Ds", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Df", "4.0")
-
- if s.Sub1.Sub2.Sub3.D != true {
- t.Error("s.Sub1.Sub2.Sub3.D != true")
-
- }
-
- if s.Sub1.Sub2.Sub3.Di != 2 {
- t.Error("s.Sub1.Sub2.Sub3.Di != 2")
-
- }
-
- if s.Sub1.Sub2.Sub3.Ds != "3" {
- t.Error("s.Sub1.Sub2.Sub3.Ds != 3")
-
- }
-
- if s.Sub1.Sub2.Sub3.Df != 4.0 {
- t.Error("s.Sub1.Sub2.Sub3.Df != 4.0")
-
- }
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/CHANGELOG.tpl.md b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/CHANGELOG.tpl.md
deleted file mode 100644
index 8e98c0bf98c7470201b177f755da8cd7bb424663..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/CHANGELOG.tpl.md
+++ /dev/null
@@ -1,27 +0,0 @@
-{{ range .Versions }}
-<a name="{{ .Tag.Name }}"></a>
-## {{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }} - {{ datetime "2006-01-02" .Tag.Date }}
-{{ range .CommitGroups -}}
-### {{ .Title }}
-{{ range .Commits -}}
-- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
-{{ end }}
-{{ end -}}
-
-{{- if .NoteGroups -}}
-{{ range .NoteGroups -}}
-### {{ .Title }}
-{{ range .Notes }}
-{{ .Body }}
-{{ end }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
-
-{{- if .Versions }}
-{{ range .Versions -}}
-{{ if .Tag.Previous -}}
-[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}
-{{ end -}}
-{{ end -}}
-{{ end -}}
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/config.yml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/config.yml
deleted file mode 100644
index 237f6bc7aabf8d8a0043683194892d61df03668c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.chglog/config.yml
+++ /dev/null
@@ -1,57 +0,0 @@
-style: gitlab
-template: CHANGELOG.tpl.md
-info:
- title: CHANGELOG
- repository_url: https://gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-options:
- commits:
- filters:
- Type:
- - feat
- - fix
- - doc
- - refactor
- - perf
- - test
- - chore
- ## deprecated types and typos
- - docs
- - documentation
- - feat
- - added
- - add
- - bugfix
- - revert
- - update
- - updates
- - change
- - changed
- commit_groups:
- title_maps:
- feat: Add Features
- fix: Bug Fixes
- doc: Documentation
- refactor: Code Refactoring
- perf: Performance Improvements
- test: Tests
- ## Chore is used for all other changes that don't fit in the other categories
- chore: Changes
- ## deprecated types and typos
- docs: Documentation
- documentation: Documentation
- added: Add Features
- add: Add Features
- bugfix: Bug Fixes
- revert: Reverts
- update: Changes
- updates: Changes
- change: Changes
- changed: Changes
- header:
- pattern: "^((\\w+)\\s.*)$"
- pattern_maps:
- - Subject
- - Type
- notes:
- keywords:
- - BREAKING CHANGE
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.envrc b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.envrc
deleted file mode 100644
index 6de8a8acd7e0568480ae14eb70819c9036a8666a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.envrc
+++ /dev/null
@@ -1,3 +0,0 @@
-source_url "https://raw.githubusercontent.com/cachix/devenv/d1f7b48e35e6dee421cfd0f51481d17f77586997/direnvrc" "sha256-YBzqskFZxmNb3kYVoKD9ZixoPXJh1C9ZvTLGFRkauZ0="
-
-use devenv
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitignore b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitignore
deleted file mode 100644
index 13bb7b5923d234f0509c1b4c9d3c410210cc529f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitignore
+++ /dev/null
@@ -1,155 +0,0 @@
-# Created by https://www.toptal.com/developers/gitignore/api/intellij,go
-# Edit at https://www.toptal.com/developers/gitignore?templates=intellij,go
-
-### Go ###
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-
-### Go Patch ###
-/vendor/
-/Godeps/
-
-### Intellij ###
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# AWS User-specific
-.idea/**/aws.xml
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn. Uncomment if using
-# auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# SonarLint plugin
-.idea/sonarlint/
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-### Intellij Patch ###
-# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
-
-# *.iml
-# modules.xml
-# .idea/misc.xml
-# *.ipr
-
-# Sonarlint plugin
-# https://plugins.jetbrains.com/plugin/7973-sonarlint
-.idea/**/sonarlint/
-
-# SonarQube Plugin
-# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
-.idea/**/sonarIssues.xml
-
-# Markdown Navigator plugin
-# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
-.idea/**/markdown-navigator.xml
-.idea/**/markdown-navigator-enh.xml
-.idea/**/markdown-navigator/
-
-# Cache file creation bug
-# See https://youtrack.jetbrains.com/issue/JBR-2257
-.idea/$CACHE_FILE$
-
-# CodeStream plugin
-# https://plugins.jetbrains.com/plugin/12206-codestream
-.idea/codestream.xml
-
-# Azure Toolkit for IntelliJ plugin
-# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
-.idea/**/azureSettings.xml
-
-# End of https://www.toptal.com/developers/gitignore/api/intellij,go
-# Devenv
-.devenv*
-devenv.local.nix
-
-# direnv
-.direnv
-
-# pre-commit
-.pre-commit-config.yaml
-
-/Session.vim
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitlab-ci.yml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitlab-ci.yml
deleted file mode 100644
index 43392807c3d88aed530af1314dbec75879e5257c..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.gitlab-ci.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-
-# THIS FILE IS AUTOGENERATED BY THE DEVENVSHELL
-# DO NOT EDIT THIS FILE MANUALLY
-# INSTEAD EDIT THE DEVENVSHELL CONFIGURATION FILE devenv.nix
-# AND OPEN A SHELL WITH THE COMMAND devenv shell
-#
-
-image: docker-registry.schukai.com:443/nixos-ci-devenv:latest
-
-services:
- - docker:dind
-
-variables:
- # The repo name as used in
- # https://github.com/nix-community/NUR/blob/master/repos.json
- NIXOS_VERSION: "23.05"
- NIXPKGS_ALLOW_UNFREE: "1"
- NIXPKGS_ALLOW_INSECURE: "1"
- DOCKER_DRIVER: overlay2
- GIT_DEPTH: 10
-
-stages:
- - test
- - deploy
-
-before_script:
- - nix shell nixpkgs#coreutils-full -c mkdir -p /certs/client/
- - nix shell nixpkgs#coreutils-full -c ln -fs /etc/ssl/certs/ca-bundle.crt /certs/client/ca.pem
- - echo > .env-gitlab-ci
- - variables=("HOME=$HOME" "CI_COMMIT_REF_NAME=$CI_COMMIT_REF_NAME" "CI_REPOSITORY_URL=$CI_REPOSITORY_URL" "GITLAB_TOKEN=$GITLAB_TOKEN" "CI_JOB_TOKEN=$CI_JOB_TOKEN" "GITLAB_USER_EMAIL=$GITLAB_USER_EMAIL" "GITLAB_USER_NAME=\"$GITLAB_USER_NAME\"" "CI_REGISTRY_USER=$CI_REGISTRY_USER" "CI_PROJECT_ID=$CI_PROJECT_ID" "CI_PROJECT_DIR=$CI_PROJECT_DIR" "CI_API_V4_URL=$CI_API_V4_URL" "CI_PROJECT_NAME=$CI_PROJECT_NAME" "CI_COMMIT_SHORT_SHA=$CI_COMMIT_SHORT_SHA"); for var in "${variables[@]}"; do echo "$var" >> .env-gitlab-ci; done
- - cat .env-gitlab-ci
-
-after_script:
- - if [ -f .env-gitlab-ci ]; then rm .env-gitlab-ci; fi
-
-test:
- stage: test
- tags:
- - nixos
- script:
- - devenv shell test-lib
-
- cache:
- - key: nixos
- paths:
- - /nix/store
-
- artifacts:
- paths:
- - dist
-
-deploy:
- stage: deploy
- tags:
- - nixos
- script:
- - devenv shell -c deploy-lib
-
- when: on_success
-
- cache:
- - key: nixos
- paths:
- - /nix/store
-
-
- artifacts:
- paths:
- - dist
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/.gitignore b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/.gitignore
deleted file mode 100644
index 13566b81b018ad684f3a35fee301741b2734c8f4..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/markdown.xml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/markdown.xml
deleted file mode 100644
index ec0b30fa7ea2824af6923493653e32595b0907a8..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/markdown.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="MarkdownSettings">
- <enabledExtensions>
- <entry key="MermaidLanguageExtension" value="false" />
- <entry key="PlantUMLLanguageExtension" value="true" />
- </enabledExtensions>
- </component>
-</project>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/misc.xml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/misc.xml
deleted file mode 100644
index 639900d13c6182e452e33a3bd638e70a0146c785..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/misc.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="ProjectRootManager">
- <output url="file://$PROJECT_DIR$/out" />
- </component>
-</project>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/modules.xml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/modules.xml
deleted file mode 100644
index 921c18fcf853bd017944147bb2073b01d3561cdf..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/modules.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="ProjectModuleManager">
- <modules>
- <module fileurl="file://$PROJECT_DIR$/.idea/pathfinder.iml" filepath="$PROJECT_DIR$/.idea/pathfinder.iml" />
- </modules>
- </component>
-</project>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/pathfinder.iml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/pathfinder.iml
deleted file mode 100644
index 25ed3f6e7b6e344b6ca91ebcc5d005f35357f9cf..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/pathfinder.iml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
- <component name="Go" enabled="true" />
- <component name="NewModuleRootManager" inherit-compiler-output="true">
- <exclude-output />
- <content url="file://$MODULE_DIR$" />
- <orderEntry type="inheritedJdk" />
- <orderEntry type="sourceFolder" forTests="false" />
- </component>
-</module>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/vcs.xml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/vcs.xml
deleted file mode 100644
index 35eb1ddfbbc029bcab630581847471d7f238ec53..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/.idea/vcs.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="VcsDirectoryMappings">
- <mapping directory="" vcs="Git" />
- </component>
-</project>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/LICENSE b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/LICENSE
deleted file mode 100644
index 22686f9fe879acaa7d1db639310a955de05b0d2a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/LICENSE
+++ /dev/null
@@ -1,662 +0,0 @@
- GNU AFFERO GENERAL PUBLIC LICENSE
- Version 3, 19 November 2007
- AGPL-3.0
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
- The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
- Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
- A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate. Many developers of free software are heartened and
-encouraged by the resulting cooperation. However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
- The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community. It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server. Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
- An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals. This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- TERMS AND CONDITIONS
-
- 0. Definitions.
-
- "This License" refers to version 3 of the GNU Affero General Public License.
-
- "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
- "The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
- To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy. The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
- A "covered work" means either the unmodified Program or a work based
-on the Program.
-
- To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
- To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
- An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
- 1. Source Code.
-
- The "source code" for a work means the preferred form of the work
-for making modifications to it. "Object code" means any non-source
-form of a work.
-
- A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
- The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
- The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
- The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
- The Corresponding Source for a work in source code form is that
-same work.
-
- 2. Basic Permissions.
-
- All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
- You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force. You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright. Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
- Conveying under any other circumstances is permitted solely under
-the conditions stated below. Sublicensing is not allowed; section 10
-makes it unnecessary.
-
- 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
- No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
- When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
- 4. Conveying Verbatim Copies.
-
- You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
- You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
- 5. Conveying Modified Source Versions.
-
- You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
- a) The work must carry prominent notices stating that you modified
- it, and giving a relevant date.
-
- b) The work must carry prominent notices stating that it is
- released under this License and any conditions added under section
- 7. This requirement modifies the requirement in section 4 to
- "keep intact all notices".
-
- c) You must license the entire work, as a whole, under this
- License to anyone who comes into possession of a copy. This
- License will therefore apply, along with any applicable section 7
- additional terms, to the whole of the work, and all its parts,
- regardless of how they are packaged. This License gives no
- permission to license the work in any other way, but it does not
- invalidate such permission if you have separately received it.
-
- d) If the work has interactive user interfaces, each must display
- Appropriate Legal Notices; however, if the Program has interactive
- interfaces that do not display Appropriate Legal Notices, your
- work need not make them do so.
-
- A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
- 6. Conveying Non-Source Forms.
-
- You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
- a) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by the
- Corresponding Source fixed on a durable physical medium
- customarily used for software interchange.
-
- b) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by a
- written offer, valid for at least three years and valid for as
- long as you offer spare parts or customer support for that product
- model, to give anyone who possesses the object code either (1) a
- copy of the Corresponding Source for all the software in the
- product that is covered by this License, on a durable physical
- medium customarily used for software interchange, for a price no
- more than your reasonable cost of physically performing this
- conveying of source, or (2) access to copy the
- Corresponding Source from a network server at no charge.
-
- c) Convey individual copies of the object code with a copy of the
- written offer to provide the Corresponding Source. This
- alternative is allowed only occasionally and noncommercially, and
- only if you received the object code with such an offer, in accord
- with subsection 6b.
-
- d) Convey the object code by offering access from a designated
- place (gratis or for a charge), and offer equivalent access to the
- Corresponding Source in the same way through the same place at no
- further charge. You need not require recipients to copy the
- Corresponding Source along with the object code. If the place to
- copy the object code is a network server, the Corresponding Source
- may be on a different server (operated by you or a third party)
- that supports equivalent copying facilities, provided you maintain
- clear directions next to the object code saying where to find the
- Corresponding Source. Regardless of what server hosts the
- Corresponding Source, you remain obligated to ensure that it is
- available for as long as needed to satisfy these requirements.
-
- e) Convey the object code using peer-to-peer transmission, provided
- you inform other peers where the object code and Corresponding
- Source of the work are being offered to the general public at no
- charge under subsection 6d.
-
- A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
- A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling. In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage. For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product. A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
- "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source. The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
- If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
- The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed. Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
- Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
- 7. Additional Terms.
-
- "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
- When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
- Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
- a) Disclaiming warranty or limiting liability differently from the
- terms of sections 15 and 16 of this License; or
-
- b) Requiring preservation of specified reasonable legal notices or
- author attributions in that material or in the Appropriate Legal
- Notices displayed by works containing it; or
-
- c) Prohibiting misrepresentation of the origin of that material, or
- requiring that modified versions of such material be marked in
- reasonable ways as different from the original version; or
-
- d) Limiting the use for publicity purposes of names of licensors or
- authors of the material; or
-
- e) Declining to grant rights under trademark law for use of some
- trade names, trademarks, or service marks; or
-
- f) Requiring indemnification of licensors and authors of that
- material by anyone who conveys the material (or modified versions of
- it) with contractual assumptions of liability to the recipient, for
- any liability that these contractual assumptions directly impose on
- those licensors and authors.
-
- All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
- If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
- Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
- 8. Termination.
-
- You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
- However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
- Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
- Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
- 9. Acceptance Not Required for Having Copies.
-
- You are not required to accept this License in order to receive or
-run a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
- 10. Automatic Licensing of Downstream Recipients.
-
- Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
- An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
- You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
- 11. Patents.
-
- A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
- A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
- Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
- In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
- If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
- If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
- A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License. You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
- Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
- 12. No Surrender of Others' Freedom.
-
- If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all. For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
- 13. Remote Network Interaction; Use with the GNU General Public License.
-
- Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software. This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
- Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
- 14. Revised Versions of this License.
-
- The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time. Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation. If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
- If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
- Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
- 15. Disclaimer of Warranty.
-
- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. Limitation of Liability.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
- 17. Interpretation of Sections 15 and 16.
-
- If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- <one line to give the program's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published
- by the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
- If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source. For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code. There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
- You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/README.md b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/README.md
deleted file mode 100644
index 4d1522c15b54f8c311a7cedeb5c6bfad357b9053..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/README.md
+++ /dev/null
@@ -1,69 +0,0 @@
-## Pathfinder
-
-## What does this library?
-
-This library provides a simple way to get and set values in a nested structure.
-
-It supports:
-
-* [X] Set values in a nested structure
-* [X] Get values from a nested structure
-
-## Installation
-
-```shell
-go get gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-```
-
-**Note:** This library uses [Go Modules](https://github.com/golang/go/wiki/Modules) to manage dependencies.
-
-## Usage
-
-### Set values
-
-```go
-s := &StructA{}
-err := GetValue[*StructA](s, "my.key")
-```
-
-### Get values
-
-```go
-s := &StructA{}
-err := SetValue[*StructA](s, "my.key", "value")
-```
-
-## Contributing
-
-Merge requests are welcome. For major changes, please open an issue first to discuss what
-you would like to change. **Please make sure to update tests as appropriate.**
-
-Versioning is done with [SemVer](https://semver.org/).
-Changelog is generated with [git-chglog](https://github.com/git-chglog/git-chglog#git-chglog)
-
-Commit messages should follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
-Messages are started with a type, which is one of the following:
-
-- **feat**: A new feature
-- **fix**: A bug fix
-- **doc**: Documentation only changes
-- **refactor**: A code change that neither fixes a bug nor adds a feature
-- **perf**: A code change that improves performance
-- **test**: Adding missing or correcting existing tests
-- **chore**: Other changes that don't modify src or test files
-
-The footer would be used for a reference to an issue or a breaking change.
-
-A commit that has a footer `BREAKING CHANGE:`, or appends a ! after the type/scope,
-introduces a breaking API change (correlating with MAJOR in semantic versioning).
-A BREAKING CHANGE can be part of commits of any type.
-
-the following is an example of a commit message:
-
-```text
-feat: add 'extras' field
-```
-
-## License
-
-[AGPL-3.0](https://choosealicense.com/licenses/agpl-3.0/)
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/Taskfile.yml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/Taskfile.yml
deleted file mode 100644
index 7095ba5db46c0440d33aa340c87fc88048de6892..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/Taskfile.yml
+++ /dev/null
@@ -1,59 +0,0 @@
-
-# THIS FILE IS AUTOGENERATED BY THE DEVENVSHELL
-# DO NOT EDIT THIS FILE MANUALLY
-# INSTEAD EDIT THE DEVENVSHELL CONFIGURATION FILE devenv.nix
-# AND OPEN A SHELL WITH THE COMMAND devenv shell
-#
-# Information about the task runner can be found here:
-# https://taskfile.dev
-
-version: '3'
-
-tasks:
- default:
- cmds:
- - task --list
- silent: true
-
- test:
- desc: Execute unit tests in Go.
- cmds:
- - echo "Execute unit tests in Go."
- - go test -cover -v ./...
- - go test -bench .
- - go test -race .
-
- test-fuzz:
- desc: Conduct fuzzing tests.#
- cmds:
- - echo "Conduct fuzzing tests."
- - go test -v -fuzztime=30s -fuzz=Fuzz ./...
-
- add-licenses:
- desc: Attach license headers to Go files.
- cmds:
- - echo "Attach license headers to Go files."
- - go install github.com/google/addlicense@latest
- - addlicense -c "schukai GmbH" -s -l "AGPL-3.0" ./*.go
- silent: true
-
- check-licenses:
- desc: Check license headers of Go files.
- silent: true
- cmds:
- - go-licenses save "$(get-go-default-packages)" --ignore "gitlab.schukai.com" --force --save_path ${DEVENV_ROOT}/licenses/
-
- check:
- desc: Confirm repository status.
- cmds:
- - git diff-index --quiet HEAD || (echo "There are uncommitted changes after running make. Please commit or stash them before running make."; exit 1)
- silent: true
-
- commit:
- desc: Commit changes to the repository.
- aliases:
- - c
- - ci
- - git-commit
- cmds:
- - do-git-commit
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.lock b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.lock
deleted file mode 100644
index 8993ca89c49f0009e157e0fa07774b143c214b2d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.lock
+++ /dev/null
@@ -1,190 +0,0 @@
-{
- "nodes": {
- "devenv": {
- "locked": {
- "dir": "src/modules",
- "lastModified": 1692003204,
- "narHash": "sha256-gO2DXwXuArjpywgtRTDb3aKscWMbnI7YwFaqvV46yv0=",
- "owner": "cachix",
- "repo": "devenv",
- "rev": "ade3ae522baf366296598e232b7b063d81740bbb",
- "type": "github"
- },
- "original": {
- "dir": "src/modules",
- "owner": "cachix",
- "repo": "devenv",
- "type": "github"
- }
- },
- "flake-compat": {
- "flake": false,
- "locked": {
- "lastModified": 1673956053,
- "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
- "owner": "edolstra",
- "repo": "flake-compat",
- "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
- "type": "github"
- },
- "original": {
- "owner": "edolstra",
- "repo": "flake-compat",
- "type": "github"
- }
- },
- "flake-utils": {
- "inputs": {
- "systems": "systems"
- },
- "locked": {
- "lastModified": 1685518550,
- "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=",
- "owner": "numtide",
- "repo": "flake-utils",
- "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef",
- "type": "github"
- },
- "original": {
- "owner": "numtide",
- "repo": "flake-utils",
- "type": "github"
- }
- },
- "gitignore": {
- "inputs": {
- "nixpkgs": [
- "pre-commit-hooks",
- "nixpkgs"
- ]
- },
- "locked": {
- "lastModified": 1660459072,
- "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=",
- "owner": "hercules-ci",
- "repo": "gitignore.nix",
- "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73",
- "type": "github"
- },
- "original": {
- "owner": "hercules-ci",
- "repo": "gitignore.nix",
- "type": "github"
- }
- },
- "nixpkgs": {
- "locked": {
- "lastModified": 1691950488,
- "narHash": "sha256-iUNEeudc4dGjx+HsHccnGiuZUVE/nhjXuQ1DVCsHIUY=",
- "owner": "nixos",
- "repo": "nixpkgs",
- "rev": "720e61ed8de116eec48d6baea1d54469b536b985",
- "type": "github"
- },
- "original": {
- "owner": "nixos",
- "ref": "nixos-23.05",
- "repo": "nixpkgs",
- "type": "github"
- }
- },
- "nixpkgs-stable": {
- "locked": {
- "lastModified": 1685801374,
- "narHash": "sha256-otaSUoFEMM+LjBI1XL/xGB5ao6IwnZOXc47qhIgJe8U=",
- "owner": "NixOS",
- "repo": "nixpkgs",
- "rev": "c37ca420157f4abc31e26f436c1145f8951ff373",
- "type": "github"
- },
- "original": {
- "owner": "NixOS",
- "ref": "nixos-23.05",
- "repo": "nixpkgs",
- "type": "github"
- }
- },
- "nixpkgs_2": {
- "locked": {
- "lastModified": 1691950488,
- "narHash": "sha256-iUNEeudc4dGjx+HsHccnGiuZUVE/nhjXuQ1DVCsHIUY=",
- "owner": "NixOS",
- "repo": "nixpkgs",
- "rev": "720e61ed8de116eec48d6baea1d54469b536b985",
- "type": "github"
- },
- "original": {
- "id": "nixpkgs",
- "ref": "nixos-23.05",
- "type": "indirect"
- }
- },
- "pre-commit-hooks": {
- "inputs": {
- "flake-compat": "flake-compat",
- "flake-utils": "flake-utils",
- "gitignore": "gitignore",
- "nixpkgs": [
- "nixpkgs"
- ],
- "nixpkgs-stable": "nixpkgs-stable"
- },
- "locked": {
- "lastModified": 1691747570,
- "narHash": "sha256-J3fnIwJtHVQ0tK2JMBv4oAmII+1mCdXdpeCxtIsrL2A=",
- "owner": "cachix",
- "repo": "pre-commit-hooks.nix",
- "rev": "c5ac3aa3324bd8aebe8622a3fc92eeb3975d317a",
- "type": "github"
- },
- "original": {
- "owner": "cachix",
- "repo": "pre-commit-hooks.nix",
- "type": "github"
- }
- },
- "root": {
- "inputs": {
- "devenv": "devenv",
- "nixpkgs": "nixpkgs",
- "pre-commit-hooks": "pre-commit-hooks",
- "version": "version"
- }
- },
- "systems": {
- "locked": {
- "lastModified": 1681028828,
- "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
- "owner": "nix-systems",
- "repo": "default",
- "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
- "type": "github"
- },
- "original": {
- "owner": "nix-systems",
- "repo": "default",
- "type": "github"
- }
- },
- "version": {
- "inputs": {
- "nixpkgs": "nixpkgs_2"
- },
- "locked": {
- "lastModified": 1690668568,
- "narHash": "sha256-jzixQKFFW4oxO0S4GYqbkFCXzhBd6com6Z9+MtVKakU=",
- "ref": "refs/heads/master",
- "rev": "3838f03165b726e47d586c04a1821749375e1001",
- "revCount": 37,
- "type": "git",
- "url": "https://gitlab.schukai.com/oss/utilities/version.git"
- },
- "original": {
- "type": "git",
- "url": "https://gitlab.schukai.com/oss/utilities/version.git"
- }
- }
- },
- "root": "root",
- "version": 7
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.nix b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.nix
deleted file mode 100644
index 9a8bbe48aa0859ae8bbe5d74a4240224f39a7599..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.nix
+++ /dev/null
@@ -1,638 +0,0 @@
-{ pkgs, inputs, phps, lib, config, modulesPath,... }:
-
-{
- # https://devenv.sh/packages/
- packages = with pkgs; [
- inputs.version.defaultPackage."${builtins.currentSystem}"
- appimage-run
- blackbox
- blackbox-terminal
- coreutils-full
- dbeaver
- delve
- dialog
- drill
- exa
- fd
- fd
- gcc12
- gdlv
- git
- glab
- gnugrep
- gnumake
- gnused
- go-licenses
- go-task
- gum
- httpie
- hurl
- jq
- libffi
- logrotate
- meld
- memcached
- netcat
- nixfmt
- procps
- ranger
- unixtools.xxd
- unzip
- util-linux
- wget
- zlib
- ];
-
-
- # https://devenv.sh/languages/
- # languages.nix.enable = true;
- languages = {
- go = { enable = true; };
- };
-
- difftastic.enable = true;
-
- scripts.get-go-default-packages.exec = ''
-#!${pkgs.bash}/bin/bash
-echo $(awk -F ' ' '/^module / { print $2 }' go.mod)
-'';
-
- # This script is executed when the app is built
- # You can use it to build the app
- scripts.test-lib.exec = ''
-#!${pkgs.bash}/bin/bash
-#set -euo pipefail
-set -x
-
-PATH="''${PATH}":${pkgs.coreutils}/bin
-PATH="''${PATH}":${pkgs.findutils}/bin
-PATH="''${PATH}":${pkgs.jq}/bin/
-PATH="''${PATH}":${pkgs.rsync}/bin/
-PATH="''${PATH}":${pkgs.bash}/bin/
-PATH="''${PATH}":${pkgs.curl}/bin/
-PATH="''${PATH}":${pkgs.moreutils}/bin/
-PATH="''${PATH}":${pkgs.gnutar}/bin
-PATH="''${PATH}":${pkgs.gzip}/bin/
-PATH="''${PATH}":${pkgs.procps}/bin/
-PATH="''${PATH}":${pkgs.exa}/bin/
-PATH="''${PATH}":${pkgs.git}/bin/
-PATH="''${PATH}":${pkgs.gnugrep}/bin/
-PATH="''${PATH}":${inputs.version.defaultPackage."${builtins.currentSystem}"}/bin/
-
-export PATH
-
-task test
-
-'';
-
- # This scritp is used to deploy the app to the gitlab registry
- # It is used by the gitlab-ci.yml file
- # The environment variables are set in the gitlab project settings
- scripts.deploy-lib.exec = ''
-#!${pkgs.bash}/bin/bash
-
-PATH="''${PATH}":${pkgs.coreutils}/bin
-PATH="''${PATH}":${pkgs.jq}/bin/
-PATH="''${PATH}":${pkgs.curl}/bin/
-PATH="''${PATH}":${pkgs.moreutils}/bin/
-PATH="''${PATH}":${pkgs.gnutar}/bin
-PATH="''${PATH}":${pkgs.gzip}/bin/
-PATH="''${PATH}":${pkgs.exa}/bin/
-PATH="''${PATH}":${pkgs.git}/bin/
-PATH="''${PATH}":${inputs.version.defaultPackage."${builtins.currentSystem}"}/bin/
-
-export PATH
-
-if [[ -f .env-gitlab-ci ]]; then
- source .env-gitlab-ci
- rm .env-gitlab-ci
-fi
-
-set -x
-## if $HOME not set, set it to current directory
-if [[ -z "''${HOME}" ]]; then
- HOME=$(pwd)
-fi
-
-export HOME
-
-git config user.email "''${GITLAB_USER_EMAIL}"
-git config user.name "''${GITLAB_USER_NAME:-"Gitlab CI"}"
-git config pull.rebase true
-git config http.sslVerify "false"
-git remote set-url origin https://pad:''${GITLAB_TOKEN}@''${CI_REPOSITORY_URL#*@}
-
-git fetch --all --tags --unshallow
-git reset --hard origin/master
-git checkout $CI_COMMIT_REF_NAME
-git pull origin $CI_COMMIT_REF_NAME
-
-if [ ! -z "''${CI_PROJECT_DIR}" ]; then
- echo "CI_PROJECT_DIR is set, using it as project root."
- project_root=$(realpath "''${CI_PROJECT_DIR}")/
-elif [ ! -z "''${DEVENV_ROOT}" ]; then
- echo "DEVENV_ROOT is set, using it as project root."
- project_root=$(realpath "''${DEVENV_ROOT}")/
-else
- echo "Error: DEVENV_ROOT or CI_PROJECT_DIR environment variables are not set."
- exit 1
-fi
-
-if [ ! -d "''${project_root}" ]; then
- echo "Error: Project root directory does not seem to be valid."
- echo "Check the DEVENV_ROOT or CI_PROJECT_DIR environment variables."
- exit 1
-fi
-
-if [ -z "'CI_JOB_TOKEN" ]; then
- echo "Error: CI_JOB_TOKEN variable is not set."
- exit 1
-fi
-
-git --no-pager log --decorate=short --pretty=oneline
-gitVersion=v$(version predict)
-git tag -a $gitVersion -m"chore: bump version"
-git --no-pager log --decorate=short --pretty=oneline
-git push -o ci.skip origin ''${CI_COMMIT_REF_NAME} --tags
-
-echo "done"
-
-'';
-
- enterShell = ''
-
-cat <<'EOF' > Taskfile.yml
-
-# THIS FILE IS AUTOGENERATED BY THE DEVENVSHELL
-# DO NOT EDIT THIS FILE MANUALLY
-# INSTEAD EDIT THE DEVENVSHELL CONFIGURATION FILE devenv.nix
-# AND OPEN A SHELL WITH THE COMMAND devenv shell
-#
-# Information about the task runner can be found here:
-# https://taskfile.dev
-
-version: '3'
-
-tasks:
- default:
- cmds:
- - task --list
- silent: true
-
- test:
- desc: Execute unit tests in Go.
- cmds:
- - echo "Execute unit tests in Go."
- - go test -cover -v ./...
- - go test -bench .
- - go test -race .
-
- test-fuzz:
- desc: Conduct fuzzing tests.#
- cmds:
- - echo "Conduct fuzzing tests."
- - go test -v -fuzztime=30s -fuzz=Fuzz ./...
-
- add-licenses:
- desc: Attach license headers to Go files.
- cmds:
- - echo "Attach license headers to Go files."
- - go install github.com/google/addlicense@latest
- - addlicense -c "schukai GmbH" -s -l "AGPL-3.0" ./*.go
- silent: true
-
- check-licenses:
- desc: Check license headers of Go files.
- silent: true
- cmds:
- - go-licenses save "$(get-go-default-packages)" --ignore "gitlab.schukai.com" --force --save_path ''${DEVENV_ROOT}/licenses/
-
- check:
- desc: Confirm repository status.
- cmds:
- - git diff-index --quiet HEAD || (echo "There are uncommitted changes after running make. Please commit or stash them before running make."; exit 1)
- silent: true
-
- commit:
- desc: Commit changes to the repository.
- aliases:
- - c
- - ci
- - git-commit
- cmds:
- - do-git-commit
-EOF
-
-cat <<'EOF' > .gitlab-ci.yml
-
-# THIS FILE IS AUTOGENERATED BY THE DEVENVSHELL
-# DO NOT EDIT THIS FILE MANUALLY
-# INSTEAD EDIT THE DEVENVSHELL CONFIGURATION FILE devenv.nix
-# AND OPEN A SHELL WITH THE COMMAND devenv shell
-#
-
-image: docker-registry.schukai.com:443/nixos-ci-devenv:latest
-
-services:
- - docker:dind
-
-variables:
- # The repo name as used in
- # https://github.com/nix-community/NUR/blob/master/repos.json
- NIXOS_VERSION: "23.05"
- NIXPKGS_ALLOW_UNFREE: "1"
- NIXPKGS_ALLOW_INSECURE: "1"
- DOCKER_DRIVER: overlay2
- GIT_DEPTH: 10
-
-stages:
- - test
- - deploy
-
-before_script:
- - nix shell nixpkgs#coreutils-full -c mkdir -p /certs/client/
- - nix shell nixpkgs#coreutils-full -c ln -fs /etc/ssl/certs/ca-bundle.crt /certs/client/ca.pem
- - echo > .env-gitlab-ci
- - variables=("HOME=''$HOME" "CI_COMMIT_REF_NAME=''$CI_COMMIT_REF_NAME" "CI_REPOSITORY_URL=''$CI_REPOSITORY_URL" "GITLAB_TOKEN=''$GITLAB_TOKEN" "CI_JOB_TOKEN=''$CI_JOB_TOKEN" "GITLAB_USER_EMAIL=''$GITLAB_USER_EMAIL" "GITLAB_USER_NAME=\"''$GITLAB_USER_NAME\"" "CI_REGISTRY_USER=''$CI_REGISTRY_USER" "CI_PROJECT_ID=''$CI_PROJECT_ID" "CI_PROJECT_DIR=''$CI_PROJECT_DIR" "CI_API_V4_URL=''$CI_API_V4_URL" "CI_PROJECT_NAME=''$CI_PROJECT_NAME" "CI_COMMIT_SHORT_SHA=''$CI_COMMIT_SHORT_SHA"); for var in "''${variables[@]}"; do echo "''$var" >> .env-gitlab-ci; done
- - cat .env-gitlab-ci
-
-after_script:
- - if [ -f .env-gitlab-ci ]; then rm .env-gitlab-ci; fi
-
-test:
- stage: test
- tags:
- - nixos
- script:
- - devenv shell test-lib
-
- cache:
- - key: nixos
- paths:
- - /nix/store
-
- artifacts:
- paths:
- - dist
-
-deploy:
- stage: deploy
- tags:
- - nixos
- script:
- - devenv shell -c deploy-lib
-
- when: on_success
-
- cache:
- - key: nixos
- paths:
- - /nix/store
-
-
- artifacts:
- paths:
- - dist
-EOF
-
-
-
- '';
-
- scripts.do-git-commit.exec = ''
-#!/usr/bin/env bash
-
-# Define colors if the terminal supports it
-if [ -t 1 ]; then
- RED='\033[0;31m'
- GREEN='\033[0;32m'
- RESET='\033[0m'
- BOLD='\033[1m'
-else
- RED=""
- GREEN=""
- RESET=""
-fi
-
-step=1
-
-reset
-clear
-
-# create random log file
-LOGFILE="''$(mktemp)"
-if [ $? -ne 0 ]; then
- echo -e "''${RED}✖ Could not create temporary log file. Exiting.''${RESET}"
- exit 1
-fi
-
-log_and_display() {
- echo -e "''${GREEN}==> $step. $1''${RESET}" | tee -a $LOGFILE
- step=$((step + 1))
-}
-
-log_error_and_display() {
- echo -e "''${RED}==> $step. $1''${RESET}" | tee -a $LOGFILE
-}
-
-printLogfileAndExit() {
- exit_code=$1
- echo -e "\n\n========================================\n\n\n"
-
- echo -e "\n\n''${BOLD}Git and GitLab Automation Script''${RESET}\n\nI have performed the following actions:\n\n"
- cat "$LOGFILE"
-
- # Optional: Remove log file
- rm -f "$LOGFILE"
-
- if [ $exit_code -eq 0 ]; then
- echo -e "\n''${GREEN}✔''${RESET} All actions were successful" | tee -a $LOGFILE
- elif [ $exit_code -eq -1 ]; then
- echo -e "\n''${RED}✖''${RESET} The script was manually cancelled" | tee -a $LOGFILE
- exit_code=0
- else
- echo -e "\n''${RED}✖''${RESET} Some actions failed" | tee -a $LOGFILE
- fi
-
- exit $exit_code
-}
-
-print_headline() {
- local title=$1
- local underline=$(printf '─%.0s' $(seq 1 ''${#title}))
- echo -e "\n\n''${BOLD}''${title}\n''${underline}''${RESET}\n"
-}
-
-do_cancel() {
- echo -e "''${RED}==> ✖ Cancelled.''${RESET}" | tee -a $LOGFILE
- printLogfileAndExit -1
-}
-
-# Function for unified logging and display
-log_action() {
- if [ $? -eq 0 ]; then
- echo -e " ''${GREEN}✔''${RESET} $1: Successful" | tee -a $LOGFILE
- else
- echo -e " ''${RED}✖''${RESET} $1: Failed" | tee -a $LOGFILE
- printLogfileAndExit 1
- fi
-}
-
-print_what_to_do() {
- echo -e "\n\nWhat do you want to do?\n"
-}
-
-git_status=$(git status --porcelain)
-if [[ -z "$git_status" ]]; then
- log_error_and_display "No changes to commit. Exiting."
- printLogfileAndExit 0
-fi
-
-print_headline "Choose commit type"
-selection=$(gum choose "feat: (new feature for the user, not a new feature for build script)" "fix: (bug fix for the user, not a fix to a build script)" "chore: (updating grunt tasks etc.; no production code change)" "docs: (changes to the documentation)" "style: (formatting, missing semi colons, etc; no production code change)" "refactor: (refactoring production code, eg. renaming a variable)" "test: (adding missing tests, refactoring tests; no production code change)" "Cancel")
-
-commit_type=$(echo "$selection" | awk -F':' '{print $1}')
-
-if [[ "$commit_type" == "Cancel" ]]; then
- do_cancel
-fi
-
-log_and_display "You chose the commit type: $commit_type"
-
-# NEXT STEP ISSUE HANDLING ############################################################################################################
-#log_and_display "Issue handling"
-
-gitlabIssues=()
-while IFS= read -r line; do
- if [[ $line =~ ^# ]]; then
- id=$(echo "$line" | awk '{print substr($1, 2)}')
- title=$(echo "$line" | awk -F'about' '{print $1}' | awk '{$1=$2=""; print substr($0, 3)}')
- gitlabIssues+=("$id > $title")
- fi
-done < <(gum spin --spinner dot --show-output --title "Ask gitlab ..." -- glab issue list --output-format=details)
-
-## if issues are available, ask if user wants to use an existing issue or create a new one
-createOption="Create new issue"
-existingOption="Use existing issue"
-cancelOption="Cancel"
-
-print_headline "Choose issue handling"
-if [ ''${#gitlabIssues[@]} -eq 0 ]; then
- log_and_display "There are no issues available."
-
- print_what_to_do
- choice=$(gum choose "$createOption" "$cancelOption")
-
-else
- log_and_display "There are ''${#gitlabIssues[@]} issues available."
- print_what_to_do
- choice=$(gum choose "$createOption" "$existingOption" "$cancelOption")
-fi
-
-if [[ "$choice" == "$cancelOption" ]]; then
- do_cancel
-fi
-
-## array of issue ids
-work_on_issue_ids=()
-
-issue_text=""
-
-if [[ "$choice" == "$createOption" ]]; then
- print_headline "Create new issue"
- issue_text=$(gum input --placeholder "Enter issue title")
- echo -e "Enter issue description. ''${RED}End with Ctrl+D''${RESET}\n"
- issue_description=$(gum write --placeholder "Enter issue description. End with Ctrl+D")
-
- if [[ -z "$issue_text" ]]; then
- log_error_and_display "Issue title is empty. Exiting."
- printLogfileAndExit 1
- fi
-
- log_and_display "You entered the issue title: $issue_text"
- log_and_display "You entered the issue description: $issue_description"
- echo -e "\n"
-
- gum confirm "Do you want to create this issue?"
- # gum confirm exits with status 0 if confirmed and status 1 if cancelled.
- if [ $? -eq 1 ]; then
- do_cancel
- fi
-
- issue_output=$(glab issue create -t"$issue_text" --no-editor --description "$issue_description")
- issue_id=$(echo "$issue_output" | grep -oP '(?<=/issues/)\d+')
-
- work_on_issue_ids+=("$issue_id")
-
- log_action "glab issue with id $issue_id created"
-
-else
-
- print_headline "Use existing issue"
- echo -e "Select issue with arrow keys and press tab or space to select. Press enter to confirm.\n"
- issue_ids=$(gum choose --no-limit "''${gitlabIssues[@]}")
-
- # assign issue_ids to work_on_issue_ids. iterate over lines and take integer from beginning of line
- while IFS= read -r line; do
- work_on_issue_ids+=($(echo "$line" | grep -oP '^\d+'))
- done <<<"$issue_ids"
-
-fi
-
-if [ ''${#work_on_issue_ids[@]} -eq 0 ]; then
- log_and_display "No issue selected. Exiting."
- printLogfileAndExit 0
-fi
-
-# NEXT STEP COMMIT MESSAGE ############################################################################################################
-# print work_on_issue_ids
-work_on_issue_ids_string=""
-for i in "''${work_on_issue_ids[@]}"; do
- work_on_issue_ids_string+="#$i "
-done
-
-log_and_display "You chose to work on the following issues: ''${work_on_issue_ids_string}"
-
-
-print_headline "Check for changes to commit"
-
-# ' ' = unmodified
-# M = modified
-# T = file type changed (regular file, symbolic link or submodule)
-# A = added
-# D = deleted
-# R = renamed
-# C = copied (if config option status.renames is set to "copies")
-# U = updated but unmerged
-# https://man.freebsd.org/cgi/man.cgi?query=git-status&sektion=1&manpath=freebsd-release-ports
-
-count_all_changes=$(echo "$git_status" | wc -l)
-count_staged_changes=$(echo "$git_status" | grep -c '^M')
-count_new_staged_files=$(echo "$git_status" | grep -c '^A')
-count_staged_changes=$((count_staged_changes + count_new_staged_files))
-
-
-
-git_options_all="All $count_all_changes changes"
-git_options_staged="Only the $count_staged_changes staged changes"
-git_options_select_files="Select files"
-git_options_cancel="Cancel"
-
-git_options_array=()
-if [[ $count_all_changes -gt 0 ]]; then
- git_options_array+=("$git_options_all")
-fi
-
-if [[ $count_staged_changes -gt 0 ]]; then
- git_options_array+=("$git_options_staged")
-fi
-
-git_options_array+=( "$git_options_select_files" )
-git_options_array+=( "$git_options_cancel" )
-
-
-selection=$(gum choose "''${git_options_array[@]}")
-if [[ "$selection" == "$git_options_cancel" ]]; then
- do_cancel
-fi
-
-if [[ "$selection" == "$git_options_all" ]]; then
- git add -A
- echo "1"
-elif [[ "$selection" == "$git_options_select_files" ]]; then
-
- files=()
- while IFS= read -r line; do
- files+=("$line")
- done <<<"$git_status"
-
- selected_files=$(gum choose --no-limit "''${files[@]}")
-
- # no files selected
- if [[ -z "$selected_files" ]]; then
- log_and_display "No files selected. Exiting."
- printLogfileAndExit 0
- fi
-
- # add selected files
- while IFS= read -r line; do
- ## git proclimne could have letter, ? or ! at the beginning of the line
- file=$(echo "$line" | awk '{print $2}')
- if [[ -z "$file" || ! -f "$file" ]]; then
- log_and_display "No file found in line: $line"
- continue
- fi
-
- git add "$file"
- done <<<"$selected_files"
-
-fi
-
-## count staged changes again and print
-count_staged_changes=$(echo "$git_status" | grep -c '^M')
-count_new_staged_files=$(echo "$git_status" | grep -c '^A')
-count_staged_changes=$((count_staged_changes + count_new_staged_files))
-
-log_and_display "You have $count_staged_changes staged changes to commit."
-
-# NEXT STEP COMMIT MESSAGE ############################################################################################################
-
-print_headline "Enter commit message"
-commit_message=$(gum input --placeholder "Enter commit message" --value "$commit_type: $issue_text $work_on_issue_ids_string")
-
-if [[ -z "$commit_message" ]]; then
- log_error_and_display "Commit message is empty. Exiting."
- printLogfileAndExit 1
-fi
-
-log_and_display "You entered the commit message: $commit_message"
-
-gum confirm "Do you want to commit with this message?"
-if [ $? -eq 1 ]; then
- do_cancel
-fi
-
-# NEXT STEP COMMIT ####################################################################################################################
-print_headline "Committing changes"
-
-if ! git commit -m "$commit_message" ; then
- log_error_and_display "Commit failed. Exiting."
- printLogfileAndExit 1
-fi
-
-log_and_display "Commit successful."
-
-# NEXT STEP PUSH ######################################################################################################################
-
-print_headline "Pushing changes"
-
-if ! git push ; then
- log_error_and_display "Push failed. Exiting."
- printLogfileAndExit 1
-fi
-
-log_and_display "Push successful."
-
-# Close issue ######################################################################################################################
-
-print_headline "Closing issues"
-
-for issue_id in "''${work_on_issue_ids[@]}"; do
-
- gum confirm "Do you want to close issue #$issue_id?"
- if [ $? -eq 1 ]; then
- continue
- fi
-
- if ! glab issue close "$issue_id" ; then
- log_error_and_display "Closing issue $issue_id failed. Exiting."
- else
- log_and_display "Closing issue $issue_id successful."
- fi
-done
-
-printLogfileAndExit 0
-'';
-
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.yaml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.yaml
deleted file mode 100644
index 525a6f02f172bb9108a23c335a4ced3e80f78502..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/devenv.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-inputs:
- nixpkgs:
- url: github:nixos/nixpkgs/nixos-23.05
-
- version:
- url: git+https://gitlab.schukai.com/oss/utilities/version.git
- flake: true
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error.go
deleted file mode 100644
index 614b13e8adaf28a9c606b9d0c847cbd80e7a4ca3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "errors"
- "reflect"
-)
-
-type InvalidPathError error
-
-func newInvalidPathError(path string) InvalidPathError {
- return InvalidPathError(errors.New("invalid path " + path))
-}
-
-type UnsupportedTypeAtTopOfPathError error
-
-func newUnsupportedTypeAtTopOfPathError(path string, t reflect.Type) UnsupportedTypeAtTopOfPathError {
- return UnsupportedTypeAtTopOfPathError(errors.New("unsupported type " + t.String() + " at top of path " + path))
-}
-
-type UnsupportedTypePathError error
-
-func newUnsupportedTypePathError(path string, t reflect.Type) UnsupportedTypePathError {
- return UnsupportedTypePathError(errors.New("unsupported type " + t.String() + " at path " + path))
-}
-
-type CannotSetError error
-
-func newCannotSetError(name string) CannotSetError {
- return CannotSetError(errors.New("cannot set " + name))
-}
-
-type InvalidTypeForPathError error
-
-func newInvalidTypeForPathError(path string, pt string, nt string) InvalidTypeForPathError {
- return InvalidTypeForPathError(errors.New("invalid type for path " + path + ": expected " + pt + ", got " + nt))
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error_test.go
deleted file mode 100644
index e2459466e1cfaf9f0c4725995203ee005cb2bf2d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/error_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "github.com/stretchr/testify/assert"
- "reflect"
- "testing"
-)
-
-func TestInvalidPathError(t *testing.T) {
- err := newInvalidPathError("test")
- _, ok := err.(InvalidPathError)
- assert.True(t, ok)
-}
-
-func TestUnsupportedTypeAtTopOfPathError(t *testing.T) {
- err := newUnsupportedTypeAtTopOfPathError("test", reflect.TypeOf(1))
- _, ok := err.(UnsupportedTypeAtTopOfPathError)
- assert.True(t, ok)
-}
-
-func TestUnsupportedTypePathError(t *testing.T) {
- err := newUnsupportedTypePathError("test", reflect.TypeOf(1))
- _, ok := err.(UnsupportedTypePathError)
- assert.True(t, ok)
-}
-
-func TestCannotSetError(t *testing.T) {
- err := newCannotSetError("test")
- _, ok := err.(CannotSetError)
- assert.True(t, ok)
-}
-
-func TestInvalidTypeForPathError(t *testing.T) {
- err := newInvalidTypeForPathError("test", "test", "test")
- _, ok := err.(InvalidTypeForPathError)
- assert.True(t, ok)
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get.go
deleted file mode 100644
index 90c2b1cc25a621455263d8abd8e48844ecf1fcdd..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "reflect"
- "strconv"
- "strings"
-)
-
-// GetValue returns the value of a field in a struct, given a path to the field.
-// The path can contain dots to access nested fields.
-// The object must be a pointer to a struct, a struct, a map, a slice or an array,
-// otherwise an error is returned.
-func GetValue[D any](obj D, keyWithDots string) (any, error) {
- keySlice := strings.Split(keyWithDots, ".")
- v := reflect.ValueOf(obj)
-
- for _, key := range keySlice[0:len(keySlice)] {
-
- if !v.IsValid() {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- switch v.Kind() {
- case reflect.Ptr, reflect.Interface:
- v = v.Elem()
- }
-
- switch v.Kind() {
- case reflect.Map:
- v = v.MapIndex(reflect.ValueOf(key))
- if !v.IsValid() {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- case reflect.Slice, reflect.Array:
- index, err := strconv.Atoi(key)
- if err != nil {
- return nil, newInvalidPathError(keyWithDots)
- }
- // check if index is in range
- if index >= v.Len() {
- return nil, newInvalidPathError(keyWithDots)
- }
- v = v.Index(index)
- case reflect.Struct:
- v = v.FieldByName(key)
- if !v.IsValid() {
- return nil, newInvalidPathError(keyWithDots)
- }
- default:
- return nil, newInvalidPathError(keyWithDots)
- }
-
- }
-
- if v.Kind() == reflect.Invalid {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- for v.Kind() == reflect.Ptr {
- v = v.Elem()
- }
-
- // check if v can interface
- if !v.CanInterface() {
- return nil, newInvalidPathError(keyWithDots)
- }
-
- return v.Interface(), nil
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get_test.go
deleted file mode 100644
index 2340260af78af5ad1cae8231fafa199a48d92da6..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/get_test.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "github.com/stretchr/testify/assert"
- "testing"
-)
-
-func TestGetIndexFromArray(t *testing.T) {
- m := map[string]any{
- "A": "true",
- "B": []string{
- "1",
- "2",
- "3",
- },
- }
-
- v, err := GetValue[map[string]any](m, "B.1")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, "2", v)
-
-}
-
-func TestGetValueFrom(t *testing.T) {
-
- m := map[string]string{
- "KeyA": "true",
- "KeyB": "2",
- "KeyC": "3",
- "KeyD": "4.0",
- }
-
- v, err := GetValue[map[string]string](m, "KeyA")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, v, "true")
-
-}
-
-func TestPathGetValueFromX(t *testing.T) {
- m := map[string]any{
- "A": "true",
- "B": map[string]any{
- "C": 2,
- "D": map[string]any{
- "E": "3",
- },
- },
- "X": "3",
- "Y": "4.0",
- }
-
- v, err := GetValue[map[string]any](m, "B.D.E")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, "3", v)
-
- v, err = GetValue[map[string]any](m, "B.C")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, 2, v)
-
-}
-
-func TestPathGetValueFrom(t *testing.T) {
-
- type PathfindTestStruct1 struct {
- A bool
- Sub1 struct {
- B int
- Sub2 struct {
- C bool
- }
- D int
- }
- }
-
- var testData PathfindTestStruct1
- testData.A = true
- testData.Sub1.B = 2
- testData.Sub1.Sub2.C = true
- testData.Sub1.D = 4
-
- GetValue[PathfindTestStruct1](testData, "Sub1.B")
- GetValue[PathfindTestStruct1](testData, "Sub1.Sub2.C")
- GetValue[PathfindTestStruct1](testData, "Sub1.D")
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.mod b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.mod
deleted file mode 100644
index f1f0841c1e1bef35c1eea035cb525543cae38066..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.mod
+++ /dev/null
@@ -1,11 +0,0 @@
-module gitlab.schukai.com/oss/libraries/go/utilities/pathfinder
-
-go 1.20
-
-require (
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/google/gofuzz v1.2.0 // indirect
- github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/stretchr/testify v1.8.0 // indirect
- gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.sum b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.sum
deleted file mode 100644
index 0a45411e2f82b7c821a164bde55de7be4998bd2a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/go.sum
+++ /dev/null
@@ -1,16 +0,0 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
-github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_2_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_2_test.go
deleted file mode 100644
index f9d652ffd3caa5a937310b173eff297296715391..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_2_test.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2023 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "fmt"
- "github.com/google/gofuzz"
- "github.com/stretchr/testify/assert"
- "testing"
-)
-
-type Issue2SubSubStruct struct {
- Issue2SubSubField []string
-}
-
-type Issue2SubStruct struct {
- Issue2SubField Issue2SubSubStruct
-}
-
-type Issue2Struct struct {
- Issue1Sub1 Issue2SubStruct
-}
-
-func TestGetValueWithArray(t *testing.T) {
- testStructForGet := Issue2Struct{
- Issue1Sub1: Issue2SubStruct{
- Issue2SubField: Issue2SubSubStruct{
- Issue2SubSubField: []string{"test0", "test1", "test2"},
- },
- },
- }
-
- // iterate from 0 to 2
- for i := 0; i < 2; i++ {
- result, err := GetValue(testStructForGet, "Issue1Sub1.Issue2SubField.Issue2SubSubField."+fmt.Sprintf("%d", i))
-
- assert.Nil(t, err)
- assert.Equal(t, result, "test"+fmt.Sprintf("%d", i))
- }
-
- i := 3
- result, err := GetValue(testStructForGet, "Issue1Sub1.Issue2SubField.Issue2SubSubField."+fmt.Sprintf("%d", i))
-
- assert.NotNil(t, err)
- assert.Nil(t, result)
-
-}
-
-func TestGetValueWithArrayFuzz(t *testing.T) {
- f := fuzz.New()
-
- testStructForGet := Issue2Struct{
- Issue1Sub1: Issue2SubStruct{
- Issue2SubField: Issue2SubSubStruct{
- Issue2SubSubField: []string{"test0", "test1", "test2"},
- },
- },
- }
-
- for i := 0; i < 100; i++ {
- var randomIndex int
- f.Fuzz(&randomIndex)
- randomIndex = randomIndex % len(testStructForGet.Issue1Sub1.Issue2SubField.Issue2SubSubField)
- if randomIndex < 0 {
- randomIndex = -randomIndex
- }
-
- result, err := GetValue(testStructForGet, "Issue1Sub1.Issue2SubField.Issue2SubSubField."+fmt.Sprintf("%d", randomIndex))
-
- if randomIndex < 3 {
- assert.Nil(t, err)
- assert.Equal(t, result, "test"+fmt.Sprintf("%d", randomIndex))
- } else {
- assert.NotNil(t, err)
- assert.Nil(t, result)
- }
- }
-}
-
-func TestSetValueWithArray(t *testing.T) {
- testStructForSet := Issue2Struct{
- Issue1Sub1: Issue2SubStruct{
- Issue2SubField: Issue2SubSubStruct{
- Issue2SubSubField: []string{"test0", "test1", "test2"},
- },
- },
- }
-
- // iterate from 0 to 2
- for i := 0; i < 2; i++ {
-
- newValue := "test~~" + fmt.Sprintf("%d", i)
- k := "Issue1Sub1.Issue2SubField.Issue2SubSubField." + fmt.Sprintf("%d", i)
- err := SetValue(&testStructForSet, k, newValue)
-
- assert.Nil(t, err)
-
- result, err := GetValue(testStructForSet, k)
- assert.Equal(t, result, newValue)
- }
-
- i := 3
- k := "Issue1Sub1.Issue2SubField.Issue2SubSubField." + fmt.Sprintf("%d", i)
- err := SetValue(testStructForSet, k, "test3")
- assert.NotNil(t, err)
-
-}
-
-type PathValue string
-
-type SubTestSubPaths struct {
- Template PathValue
- Definitions []PathValue
-}
-
-type SubTest2Def struct {
- Paths SubTestSubPaths
-}
-
-type SubTestStruct1 map[string]SubTest2Def
-type MainTestStruct struct {
- Sub SubTestStruct1
-}
-
-func TestReplacePathForConfig(t *testing.T) {
- config := MainTestStruct{
- Sub: SubTestStruct1{
- "Default": SubTest2Def{
- Paths: SubTestSubPaths{
- Template: "../../../default.html",
- Definitions: []PathValue{"../../../legacy.yaml"},
- },
- },
- },
- }
-
- nn, err2 := GetValue[MainTestStruct](config, "Sub.Default.Paths.Template")
- assert.Nil(t, err2)
-
- assert.Equal(t, nn, PathValue("../../../default.html"))
-
- err := SetValue[*MainTestStruct](&config, "Sub.Default.Paths.Template", "test")
- assert.Nil(t, err)
-
- nn, err3 := GetValue[MainTestStruct](config, "Sub.Default.Paths.Template")
- assert.Nil(t, err3)
-
- assert.Equal(t, nn, PathValue("test"))
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_7_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_7_test.go
deleted file mode 100644
index 5033b289852cbad971d25b165c2e8dc20615e4b3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/issue_7_test.go
+++ /dev/null
@@ -1,126 +0,0 @@
-package pathfinder
-
-import (
- "github.com/stretchr/testify/assert"
- "testing"
-)
-
-// Test für SetValue
-func TestSetValue(t *testing.T) {
- type Inner struct {
- Field PathValue
- }
- type Outer struct {
- InnerField *Inner
- }
-
- obj := &Outer{
- InnerField: &Inner{
- Field: "oldValue",
- },
- }
-
- v, err := GetValue[Outer](*obj, "InnerField.Field")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, PathValue("oldValue"), v)
-
- nv := PathValue("newValue")
- err = SetValue[*Outer](obj, "InnerField.Field", nv)
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
-
- if obj.InnerField.Field != "newValue" {
- t.Fatalf("expected newValue, got: %s", obj.InnerField.Field)
- }
-
- v, err = GetValue[Outer](*obj, "InnerField.Field")
- if err != nil {
- t.Error(err)
- }
-
- assert.Equal(t, v, nv)
-
-}
-
-type Issue7Routing struct {
- P PathValue `json:"p" yaml:"p"`
- X string `json:"x" yaml:"x"`
-}
-
-type Issue7Server struct {
- Routing []Issue7Routing `json:"routing" yaml:"routing"`
-}
-
-type Issue7Config struct {
- Server Issue7Server `json:"server" yaml:"server"`
-}
-
-func TestPathRewrite(t *testing.T) {
-
- obj := Issue7Config{
- Server: Issue7Server{
- Routing: []Issue7Routing{
- {
- P: "./test",
- X: "testX",
- },
- },
- },
- }
-
- v, err := GetValue[*Issue7Config](&obj, "Server.Routing.0.P")
- assert.Nil(t, err)
-
- assert.Equal(t, PathValue("./test"), v)
-
- nv := PathValue("newValue")
- err = SetValue[*Issue7Config](&obj, "Server.Routing.0.P", nv)
- assert.Nil(t, err)
-
- if obj.Server.Routing[0].P != "newValue" {
- t.Fatalf("expected newValue, got: %s", obj.Server.Routing[0].P)
- }
-
- v, err = GetValue[*Issue7Config](&obj, "Server.Routing.0.P")
- assert.Nil(t, err)
- assert.Equal(t, v, nv)
-
-}
-
-// Test data structs
-type Issue7TestStruct2 struct {
- D map[string]PathValue
-}
-
-func TestPathRewrite2(t *testing.T) {
- // Test case 2
- ts2 := Issue7TestStruct2{
- D: map[string]PathValue{
- "key1": "yyy",
- "key2": "zzz",
- },
- }
-
- v, err := GetValue[Issue7TestStruct2](ts2, "D.key1")
- assert.Nil(t, err)
- assert.Equal(t, PathValue("yyy"), v)
-
- v, err = GetValue[Issue7TestStruct2](ts2, "D.key2")
- assert.Nil(t, err)
- assert.Equal(t, PathValue("zzz"), v)
-
- err = SetValue[*Issue7TestStruct2](&ts2, "D.key1", "xxx")
- assert.Nil(t, err)
-
- v, err = GetValue[Issue7TestStruct2](ts2, "D.key1")
- assert.Nil(t, err)
- assert.Equal(t, PathValue("xxx"), v)
-
- v, err = GetValue[Issue7TestStruct2](ts2, "D.key2")
- assert.Nil(t, err)
- assert.Equal(t, PathValue("zzz"), v)
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/pathfinder.iml b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/pathfinder.iml
deleted file mode 100644
index 49df094a939bad91c791b0986d7e479bcc496640..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/pathfinder.iml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
- <component name="Go" enabled="true" />
- <component name="NewModuleRootManager" inherit-compiler-output="true">
- <exclude-output />
- <content url="file://$MODULE_DIR$" />
- <orderEntry type="inheritedJdk" />
- <orderEntry type="sourceFolder" forTests="false" />
- </component>
-</module>
\ No newline at end of file
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/release.json b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/release.json
deleted file mode 100644
index ccd00c212fd33519ee25a4425025db1859dd1925..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/release.json
+++ /dev/null
@@ -1 +0,0 @@
-{"version":"0.5.2"}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set.go
deleted file mode 100644
index 92b650947c7d46f0ff6bd197ac59662db76dd130..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set.go
+++ /dev/null
@@ -1,332 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import (
- "bytes"
- "encoding/gob"
- "fmt"
- "reflect"
- "strconv"
- "strings"
-)
-
-func deepCopy(src, dst interface{}) error {
- var buf bytes.Buffer
- enc := gob.NewEncoder(&buf)
- dec := gob.NewDecoder(&buf)
-
- if err := enc.Encode(src); err != nil {
- return err
- }
-
- return dec.Decode(dst)
-}
-
-// SetValue sets the value of a field in a struct, given a path to the field.
-// The object must be a pointer to a struct, otherwise an error is returned.
-func SetValue[D any](obj D, keyWithDots string, newValue any) error {
-
- keySlice := strings.Split(keyWithDots, ".")
- reflectionOfObject := reflect.ValueOf(obj)
-
- for keyIndex, key := range keySlice[0 : len(keySlice)-1] {
-
- if reflectionOfObject.Kind() == reflect.Map {
-
- if reflectionOfObject.IsNil() {
- return newInvalidPathError(keyWithDots)
- }
-
- currentValue := reflectionOfObject.MapIndex(reflect.ValueOf(key)).Interface()
- newValueCopy := reflect.New(reflect.TypeOf(currentValue)).Interface()
- if err := deepCopy(currentValue, newValueCopy); err != nil {
- return err
- }
-
- newValueCopyPtr := &newValueCopy
- newValueCopyReflect := reflect.ValueOf(newValueCopyPtr).Elem()
- if !newValueCopyReflect.CanAddr() {
- return newCannotSetError("Wert ist nicht adressierbar")
- }
- newKey := strings.Join(keySlice[keyIndex+1:], ".")
- err := SetValue(newValueCopyPtr, newKey, newValue)
- if err != nil {
- return err
- }
-
- reflectionOfObject.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(newValueCopy).Elem())
- return nil
-
- }
-
- if reflectionOfObject.Kind() == reflect.Ptr && reflectionOfObject.Elem().Kind() == reflect.Interface {
- reflectionOfObject = reflectionOfObject.Elem().Elem()
- }
-
- for reflectionOfObject.Kind() != reflect.Ptr {
- if reflectionOfObject.Kind() == reflect.Invalid {
- return newInvalidPathError(keyWithDots)
- }
-
- if reflectionOfObject.CanAddr() {
- reflectionOfObject = reflectionOfObject.Addr()
- } else {
- return newCannotSetError(keyWithDots)
- }
-
- }
-
- if reflectionOfObject.Kind() != reflect.Ptr {
- return newUnsupportedTypePathError(keyWithDots, reflectionOfObject.Type())
- }
-
- switch reflectionOfObject.Elem().Kind() {
- case reflect.Struct:
- reflectionOfObject = reflectionOfObject.Elem().FieldByName(key)
-
- case reflect.Slice:
- // index is a number and get reflectionOfObject from slice with index
- index, err := strconv.Atoi(key)
- if err != nil {
- return newInvalidPathError(keyWithDots)
- }
-
- if index >= reflectionOfObject.Elem().Len() {
- return newInvalidPathError(keyWithDots)
- }
-
- reflectionOfObject = reflectionOfObject.Elem().Index(index)
- default:
- return newUnsupportedTypePathError(keyWithDots, reflectionOfObject.Type())
- }
-
- }
-
- if reflectionOfObject.Kind() == reflect.Invalid {
- return newInvalidPathError(keyWithDots)
- }
-
- for reflectionOfObject.Kind() == reflect.Ptr {
- reflectionOfObject = reflectionOfObject.Elem()
- }
-
- // non-supporter type at the top of the path
- switch reflectionOfObject.Kind() {
- case reflect.Struct:
-
- reflectionOfObject = reflectionOfObject.FieldByName(keySlice[len(keySlice)-1])
- if !reflectionOfObject.IsValid() {
- return newInvalidPathError(keyWithDots)
- }
-
- if !reflectionOfObject.CanSet() {
- return newCannotSetError(keyWithDots)
- }
-
- case reflect.Map:
-
- key := keySlice[len(keySlice)-1]
- m := reflectionOfObject
-
- keyVal := reflect.ValueOf(key)
- newVal := reflect.ValueOf(newValue)
-
- if !keyVal.Type().ConvertibleTo(m.Type().Key()) {
- return fmt.Errorf("key type mismatch")
- }
-
- if !newVal.Type().ConvertibleTo(m.Type().Elem()) {
- return fmt.Errorf("value type mismatch")
- }
-
- keyValConverted := keyVal.Convert(m.Type().Key())
- newValConverted := newVal.Convert(m.Type().Elem())
- m.SetMapIndex(keyValConverted, newValConverted)
- return nil
-
- //currentValue := reflectionOfObject.MapIndex(reflect.ValueOf(key)).Interface()
- //newValueCopy := reflect.New(reflect.TypeOf(currentValue)).Interface()
- //if err := deepCopy(currentValue, newValueCopy); err != nil {
- // return err
- //}
- //newValueCopyPtr := &newValueCopy
- //newValueCopyReflect := reflect.ValueOf(newValueCopyPtr).Elem()
- //if !newValueCopyReflect.CanAddr() {
- // return newCannotSetError("Wert ist nicht adressierbar")
- //}
- ////newKey := strings.Join(keySlice[keyIndex+1:], ".")
- ////err := SetValue(newValueCopyPtr, newKey, newValue)
- ////if err != nil {
- //// return err
- ////}
- //
- //reflectionOfObject.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(newValueCopy).Elem())
- //return nil
-
- //if reflectionOfObject.IsNil() {
- // return newInvalidPathError(keyWithDots)
- //}
- //
- //index := keySlice[len(keySlice)-1]
- //reflectedIndex := reflect.ValueOf(index)
- //
- //if !reflectedIndex.Type().AssignableTo(reflectionOfObject.Type().Key()) {
- // return newInvalidPathError(keyWithDots)
- //}
- //
- //currentValue := reflectionOfObject.MapIndex(reflectedIndex).Interface()
- //newValueCopy := reflect.New(reflect.TypeOf(currentValue)).Interface()
- //if err := deepCopy(currentValue, newValueCopy); err != nil {
- // return err
- //}
- //
- //if !reflect.ValueOf(newValueCopy).Elem().Type().AssignableTo(reflectionOfObject.Type().Elem()) {
- // return newInvalidPathError(keyWithDots)
- //}
- //
- //newValueCopyX := reflect.ValueOf(newValueCopy).Elem()
- //reflectionOfObject.SetMapIndex(reflectedIndex, newValueCopyX)
-
- case reflect.Slice:
-
- // index is a number and get reflectionOfObject from slice with index
- index, err := strconv.Atoi(keySlice[len(keySlice)-1])
- if err != nil {
- return newInvalidPathError(keyWithDots)
- }
-
- // index out of range
- if index >= reflectionOfObject.Len() {
- return newInvalidPathError(keyWithDots)
- }
-
- reflectionOfObject = reflectionOfObject.Index(index)
-
- case reflect.Array:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Ptr:
- if newValue == nil {
- reflectionOfObject.Set(reflect.Zero(reflectionOfObject.Type()))
- } else {
- reflectionOfObject.Set(reflect.ValueOf(&newValue))
- }
- return nil
- case reflect.Interface:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Chan:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Func:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.UnsafePointer:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Uintptr:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Complex64:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Complex128:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- case reflect.Invalid:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- default:
- return newUnsupportedTypeAtTopOfPathError(keyWithDots, reflectionOfObject.Type())
- }
-
- newValueType := reflect.TypeOf(newValue)
- if newValueType == nil {
- return newUnsupportedTypePathError(keyWithDots, reflectionOfObject.Type())
- }
-
- newValueKind := reflect.TypeOf(newValue).Kind()
-
- switch reflectionOfObject.Kind() {
- case reflect.String:
- if reflectionOfObject.Kind() == reflect.Ptr || reflectionOfObject.Kind() == reflect.Interface {
- if reflectionOfObject.Elem().CanSet() && reflectionOfObject.Elem().Kind() == reflect.String {
- if newValueKind == reflect.String {
- reflectionOfObject.Elem().SetString(newValue.(string))
- } else {
- reflectionOfObject.Elem().SetString(fmt.Sprintf("%v", newValue))
- }
- }
- } else if newValueKind == reflect.String {
-
- if reflect.TypeOf(newValue).ConvertibleTo(reflect.TypeOf("")) {
- newValueString := reflect.ValueOf(newValue).Convert(reflect.TypeOf("")).Interface().(string)
- reflectionOfObject.SetString(newValueString)
- } else {
- return newUnsupportedTypePathError(keyWithDots, reflectionOfObject.Type())
- }
- } else {
- reflectionOfObject.SetString(fmt.Sprintf("%v", newValue))
- }
-
- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-
- if newValueKind == reflect.Int {
- reflectionOfObject.SetInt(int64(newValue.(int)))
- } else {
- s, err := strconv.ParseInt(fmt.Sprintf("%v", newValue), 10, 64)
- if err != nil {
- return err
- }
- reflectionOfObject.SetInt(s)
- }
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-
- if newValueKind == reflect.Int {
- reflectionOfObject.SetUint(uint64(newValue.(int)))
- } else {
- s, err := strconv.ParseInt(fmt.Sprintf("%v", newValue), 10, 64)
- if err != nil {
- return err
- }
- reflectionOfObject.SetUint(uint64(s))
- }
-
- case reflect.Bool:
-
- if newValueKind == reflect.Bool {
- reflectionOfObject.SetBool(newValue.(bool))
- } else {
- b, err := strconv.ParseBool(fmt.Sprintf("%v", newValue))
- if err != nil {
- return err
- }
-
- reflectionOfObject.SetBool(b)
- }
-
- case reflect.Float64, reflect.Float32:
-
- if newValueKind == reflect.Float64 {
- reflectionOfObject.SetFloat(newValue.(float64))
- } else {
- s, err := strconv.ParseFloat(fmt.Sprintf("%v", newValue), 64)
- if err != nil {
- return err
- }
-
- reflectionOfObject.SetFloat(s)
- }
-
- case reflect.Slice, reflect.Array:
-
- if newValueKind == reflect.Ptr {
- newValue = reflect.ValueOf(newValue).Elem().Interface()
- reflectionOfObject.Set(reflect.ValueOf(newValue))
- } else if newValueKind == reflect.Slice {
- reflectionOfObject.Set(reflect.ValueOf(newValue))
- } else {
- return newUnsupportedTypePathError(keyWithDots, reflectionOfObject.Type())
- }
-
- default:
- return newInvalidTypeForPathError(keyWithDots, reflectionOfObject.Type().String(), newValueKind.String())
- }
-
- return nil
-
-}
diff --git a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set_test.go b/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set_test.go
deleted file mode 100644
index 37adcb7f17068bc574fcffecfb4973e35bb9139b..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gitlab.schukai.com/oss/libraries/go/utilities/pathfinder@v0.8.1/set_test.go
+++ /dev/null
@@ -1,278 +0,0 @@
-// Copyright 2022 schukai GmbH
-// SPDX-License-Identifier: AGPL-3.0
-
-package pathfinder
-
-import "testing"
-
-type PathfindTestStruct1 struct {
- A bool
- Sub1 struct {
- B bool
- Bi int
- Bs string
- Bf float64
- Sub2 struct {
- C bool
- Ci int
- Cs string
- Cf float64
-
- Sub3 struct {
- D bool
- Di int
- Ds string
- Df float64
- }
- }
- }
-}
-
-func TestPathFindError(t *testing.T) {
-
- s := PathfindTestStruct1{}
-
- _, err := GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.XX")
- if err == nil {
- t.Error("err == nil")
- }
-
-}
-
-func TestPathFindSetValueString(t *testing.T) {
-
- testData := map[string]string{
- "Sub1.B": "true",
- "Sub1.Bi": "2",
- "Sub1.Bs": "3",
- "Sub1.Bf": "4.0",
- "Sub1.Sub2.C": "true",
- "Sub1.Sub2.Ci": "2",
- "Sub1.Sub2.Cs": "3",
- "Sub1.Sub2.Cf": "4.0",
- "Sub1.Sub2.Sub3.D": "true",
- "Sub1.Sub2.Sub3.Di": "2",
- "Sub1.Sub2.Sub3.Ds": "3",
- "Sub1.Sub2.Sub3.Df": "4.0",
- }
-
- for k, v := range testData {
- s := &PathfindTestStruct1{}
- err := SetValue[*PathfindTestStruct1](s, k, v)
- if err != nil {
- t.Error(err)
- }
- }
-}
-
-func TestPathFindGetValueFrom(t *testing.T) {
-
- s := PathfindTestStruct1{}
-
- s.Sub1.B = true
- s.Sub1.Bi = 2
- s.Sub1.Bs = "3"
- s.Sub1.Bf = 4.0
-
- v, err := GetValue[PathfindTestStruct1](s, "Sub1.B")
- if err != nil {
- t.Error(err)
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bi")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bs")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Bf")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
- s.Sub1.Sub2.C = true
- s.Sub1.Sub2.Ci = 2
- s.Sub1.Sub2.Cs = "3"
- s.Sub1.Sub2.Cf = 4.0
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.C")
- if err != nil {
- t.Error(err)
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Ci")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Cs")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Cf")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
- s.Sub1.Sub2.Sub3.D = true
- s.Sub1.Sub2.Sub3.Di = 2
- s.Sub1.Sub2.Sub3.Ds = "3"
- s.Sub1.Sub2.Sub3.Df = 4.0
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.D")
- if err != nil {
- t.Error(err)
-
- }
-
- if v != true {
- t.Error("v != true")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Di")
- if err != nil {
- t.Error(err)
- }
-
- if v != 2 {
- t.Error("v != 2")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Ds")
- if err != nil {
- t.Error(err)
- }
-
- if v != "3" {
- t.Error("v != 3")
- }
-
- v, err = GetValue[PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Df")
- if err != nil {
- t.Error(err)
- }
-
- if v != 4.0 {
- t.Error("v != 4.0")
- }
-
-}
-
-func TestPathFindSetValueFrom(t *testing.T) {
- s := &PathfindTestStruct1{}
-
- SetValue[*PathfindTestStruct1](s, "Sub1.B", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bi", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bs", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Bf", "4.0")
-
- if s.Sub1.B != true {
- t.Error("s.Sub1.B != true")
- }
-
- if s.Sub1.Bi != 2 {
- t.Error("s.Sub1.Bi != 2")
-
- }
-
- if s.Sub1.Bs != "3" {
- t.Error("s.Sub1.Bs != 3")
- }
-
- if s.Sub1.Bf != 4.0 {
- t.Error("s.Sub1.Bf != 4.0")
- }
-
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.C", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Ci", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Cs", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Cf", "4.0")
-
- if s.Sub1.Sub2.C != true {
- t.Error("s.Sub1.Sub2.C != true")
-
- }
-
- if s.Sub1.Sub2.Ci != 2 {
- t.Error("s.Sub1.Sub2.Ci != 2")
-
- }
-
- if s.Sub1.Sub2.Cs != "3" {
- t.Error("s.Sub1.Sub2.Cs != 3")
-
- }
-
- if s.Sub1.Sub2.Cf != 4.0 {
- t.Error("s.Sub1.Sub2.Cf != 4.0")
-
- }
-
- if s.Sub1.Sub2.Sub3.D != false {
- t.Error("s.Sub1.Sub2.Sub3.D != false")
-
- }
-
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.D", "true")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Di", "2")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Ds", "3")
- SetValue[*PathfindTestStruct1](s, "Sub1.Sub2.Sub3.Df", "4.0")
-
- if s.Sub1.Sub2.Sub3.D != true {
- t.Error("s.Sub1.Sub2.Sub3.D != true")
-
- }
-
- if s.Sub1.Sub2.Sub3.Di != 2 {
- t.Error("s.Sub1.Sub2.Sub3.Di != 2")
-
- }
-
- if s.Sub1.Sub2.Sub3.Ds != "3" {
- t.Error("s.Sub1.Sub2.Sub3.Ds != 3")
-
- }
-
- if s.Sub1.Sub2.Sub3.Df != 4.0 {
- t.Error("s.Sub1.Sub2.Sub3.Df != 4.0")
-
- }
-
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/.github/workflows/go.yaml b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/.github/workflows/go.yaml
deleted file mode 100644
index d2bb00b0781f414f60c4deab874ae6bff9ef1c43..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/.github/workflows/go.yaml
+++ /dev/null
@@ -1,61 +0,0 @@
----
-name: Go
-on: [push, pull_request]
-jobs:
- test:
- name: Test
- runs-on: ubuntu-20.04
- strategy:
- fail-fast: false
- matrix:
- go:
- - "1.5"
- - "1.6"
- - "1.7"
- - "1.8"
- - "1.9"
- - "1.10"
- - "1.11"
- - "1.12"
- - "1.13"
- - "1.14"
- - "1.15"
- - "1.16.0-beta1"
- - "tip"
- env:
- GOPATH: ${{ github.workspace }}/go
- steps:
- - name: Check out code into the Go module directory
- uses: actions/checkout@v2
- with:
- path: ${{ github.workspace }}/go/src/gopkg.in/yaml.v3
- - name: Set up Go ${{ matrix.go }}
- if: matrix.go != 'tip'
- uses: actions/setup-go@v2
- with:
- go-version: ${{ matrix.go }}
- stable: false
- - name: Set up Go ${{ matrix.go }}
- if: matrix.go == 'tip'
- run: |
- export GOROOT_BOOTSTRAP=`go env GOROOT`
- export GOROOT=$HOME/gotip
- mkdir $HOME/gotip
- cd $HOME/gotip
-
- curl -s 'https://go.googlesource.com/go/+/refs/heads/master?format=JSON' | awk '/"commit"/{print substr($2,2,40);exit}' >HEAD
- awk '{printf("gotip-%s",substr($0,0,7))}' <HEAD >VERSION
-
- curl -s -o go.tar.gz https://go.googlesource.com/go/+archive/`cat HEAD`.tar.gz
- tar xfz go.tar.gz
-
- cd src
- bash make.bash
-
- echo "GOROOT=$GOROOT" >> $GITHUB_ENV
- echo "$GOROOT/bin" >> $GITHUB_PATH
- - run: go version
- - run: go get -t ./...
- working-directory: ${{ github.workspace }}/go/src/gopkg.in/yaml.v3
- - run: go test .
- working-directory: ${{ github.workspace }}/go/src/gopkg.in/yaml.v3
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/LICENSE b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/LICENSE
deleted file mode 100644
index 2683e4bb1f24c14aa2791e6d48ce0ecf3d8ab756..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/LICENSE
+++ /dev/null
@@ -1,50 +0,0 @@
-
-This project is covered by two different licenses: MIT and Apache.
-
-#### MIT License ####
-
-The following files were ported to Go from C files of libyaml, and thus
-are still covered by their original MIT license, with the additional
-copyright staring in 2011 when the project was ported over:
-
- apic.go emitterc.go parserc.go readerc.go scannerc.go
- writerc.go yamlh.go yamlprivateh.go
-
-Copyright (c) 2006-2010 Kirill Simonov
-Copyright (c) 2006-2011 Kirill Simonov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-### Apache License ###
-
-All the remaining project files are covered by the Apache license:
-
-Copyright (c) 2011-2019 Canonical Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/NOTICE b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/NOTICE
deleted file mode 100644
index 866d74a7ad79165312a2ce3904b4bdb53e6aedf7..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/NOTICE
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright 2011-2016 Canonical Ltd.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/README.md b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/README.md
deleted file mode 100644
index 08eb1babddfac3d8f4e006448496d0e0d1f8d720..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/README.md
+++ /dev/null
@@ -1,150 +0,0 @@
-# YAML support for the Go language
-
-Introduction
-------------
-
-The yaml package enables Go programs to comfortably encode and decode YAML
-values. It was developed within [Canonical](https://www.canonical.com) as
-part of the [juju](https://juju.ubuntu.com) project, and is based on a
-pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
-C library to parse and generate YAML data quickly and reliably.
-
-Compatibility
--------------
-
-The yaml package supports most of YAML 1.2, but preserves some behavior
-from 1.1 for backwards compatibility.
-
-Specifically, as of v3 of the yaml package:
-
- - YAML 1.1 bools (_yes/no, on/off_) are supported as long as they are being
- decoded into a typed bool value. Otherwise they behave as a string. Booleans
- in YAML 1.2 are _true/false_ only.
- - Octals encode and decode as _0777_ per YAML 1.1, rather than _0o777_
- as specified in YAML 1.2, because most parsers still use the old format.
- Octals in the _0o777_ format are supported though, so new files work.
- - Does not support base-60 floats. These are gone from YAML 1.2, and were
- actually never supported by this package as it's clearly a poor choice.
-
-and offers backwards
-compatibility with YAML 1.1 in some cases.
-1.2, including support for
-anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
-implemented, and base-60 floats from YAML 1.1 are purposefully not
-supported since they're a poor design and are gone in YAML 1.2.
-
-Installation and usage
-----------------------
-
-The import path for the package is *gopkg.in/yaml.v3*.
-
-To install it, run:
-
- go get gopkg.in/yaml.v3
-
-API documentation
------------------
-
-If opened in a browser, the import path itself leads to the API documentation:
-
- - [https://gopkg.in/yaml.v3](https://gopkg.in/yaml.v3)
-
-API stability
--------------
-
-The package API for yaml v3 will remain stable as described in [gopkg.in](https://gopkg.in).
-
-
-License
--------
-
-The yaml package is licensed under the MIT and Apache License 2.0 licenses.
-Please see the LICENSE file for details.
-
-
-Example
--------
-
-```Go
-package main
-
-import (
- "fmt"
- "log"
-
- "gopkg.in/yaml.v3"
-)
-
-var data = `
-a: Easy!
-b:
- c: 2
- d: [3, 4]
-`
-
-// Note: struct fields must be public in order for unmarshal to
-// correctly populate the data.
-type T struct {
- A string
- B struct {
- RenamedC int `yaml:"c"`
- D []int `yaml:",flow"`
- }
-}
-
-func main() {
- t := T{}
-
- err := yaml.Unmarshal([]byte(data), &t)
- if err != nil {
- log.Fatalf("error: %v", err)
- }
- fmt.Printf("--- t:\n%v\n\n", t)
-
- d, err := yaml.Marshal(&t)
- if err != nil {
- log.Fatalf("error: %v", err)
- }
- fmt.Printf("--- t dump:\n%s\n\n", string(d))
-
- m := make(map[interface{}]interface{})
-
- err = yaml.Unmarshal([]byte(data), &m)
- if err != nil {
- log.Fatalf("error: %v", err)
- }
- fmt.Printf("--- m:\n%v\n\n", m)
-
- d, err = yaml.Marshal(&m)
- if err != nil {
- log.Fatalf("error: %v", err)
- }
- fmt.Printf("--- m dump:\n%s\n\n", string(d))
-}
-```
-
-This example will generate the following output:
-
-```
---- t:
-{Easy! {2 [3 4]}}
-
---- t dump:
-a: Easy!
-b:
- c: 2
- d: [3, 4]
-
-
---- m:
-map[a:Easy! b:map[c:2 d:[3 4]]]
-
---- m dump:
-a: Easy!
-b:
- c: 2
- d:
- - 3
- - 4
-```
-
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/apic.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/apic.go
deleted file mode 100644
index ae7d049f182ae2419ded608e4c763487c99dff52..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/apic.go
+++ /dev/null
@@ -1,747 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "io"
-)
-
-func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
- //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
-
- // Check if we can move the queue at the beginning of the buffer.
- if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
- if parser.tokens_head != len(parser.tokens) {
- copy(parser.tokens, parser.tokens[parser.tokens_head:])
- }
- parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
- parser.tokens_head = 0
- }
- parser.tokens = append(parser.tokens, *token)
- if pos < 0 {
- return
- }
- copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
- parser.tokens[parser.tokens_head+pos] = *token
-}
-
-// Create a new parser object.
-func yaml_parser_initialize(parser *yaml_parser_t) bool {
- *parser = yaml_parser_t{
- raw_buffer: make([]byte, 0, input_raw_buffer_size),
- buffer: make([]byte, 0, input_buffer_size),
- }
- return true
-}
-
-// Destroy a parser object.
-func yaml_parser_delete(parser *yaml_parser_t) {
- *parser = yaml_parser_t{}
-}
-
-// String read handler.
-func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
- if parser.input_pos == len(parser.input) {
- return 0, io.EOF
- }
- n = copy(buffer, parser.input[parser.input_pos:])
- parser.input_pos += n
- return n, nil
-}
-
-// Reader read handler.
-func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
- return parser.input_reader.Read(buffer)
-}
-
-// Set a string input.
-func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
- if parser.read_handler != nil {
- panic("must set the input source only once")
- }
- parser.read_handler = yaml_string_read_handler
- parser.input = input
- parser.input_pos = 0
-}
-
-// Set a file input.
-func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
- if parser.read_handler != nil {
- panic("must set the input source only once")
- }
- parser.read_handler = yaml_reader_read_handler
- parser.input_reader = r
-}
-
-// Set the source encoding.
-func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
- if parser.encoding != yaml_ANY_ENCODING {
- panic("must set the encoding only once")
- }
- parser.encoding = encoding
-}
-
-// Create a new emitter object.
-func yaml_emitter_initialize(emitter *yaml_emitter_t) {
- *emitter = yaml_emitter_t{
- buffer: make([]byte, output_buffer_size),
- raw_buffer: make([]byte, 0, output_raw_buffer_size),
- states: make([]yaml_emitter_state_t, 0, initial_stack_size),
- events: make([]yaml_event_t, 0, initial_queue_size),
- best_width: -1,
- }
-}
-
-// Destroy an emitter object.
-func yaml_emitter_delete(emitter *yaml_emitter_t) {
- *emitter = yaml_emitter_t{}
-}
-
-// String write handler.
-func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
- *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
- return nil
-}
-
-// yaml_writer_write_handler uses emitter.output_writer to write the
-// emitted text.
-func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
- _, err := emitter.output_writer.Write(buffer)
- return err
-}
-
-// Set a string output.
-func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
- if emitter.write_handler != nil {
- panic("must set the output target only once")
- }
- emitter.write_handler = yaml_string_write_handler
- emitter.output_buffer = output_buffer
-}
-
-// Set a file output.
-func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
- if emitter.write_handler != nil {
- panic("must set the output target only once")
- }
- emitter.write_handler = yaml_writer_write_handler
- emitter.output_writer = w
-}
-
-// Set the output encoding.
-func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
- if emitter.encoding != yaml_ANY_ENCODING {
- panic("must set the output encoding only once")
- }
- emitter.encoding = encoding
-}
-
-// Set the canonical output style.
-func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
- emitter.canonical = canonical
-}
-
-// Set the indentation increment.
-func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
- if indent < 2 || indent > 9 {
- indent = 2
- }
- emitter.best_indent = indent
-}
-
-// Set the preferred line width.
-func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
- if width < 0 {
- width = -1
- }
- emitter.best_width = width
-}
-
-// Set if unescaped non-ASCII characters are allowed.
-func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
- emitter.unicode = unicode
-}
-
-// Set the preferred line break character.
-func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
- emitter.line_break = line_break
-}
-
-///*
-// * Destroy a token object.
-// */
-//
-//YAML_DECLARE(void)
-//yaml_token_delete(yaml_token_t *token)
-//{
-// assert(token); // Non-NULL token object expected.
-//
-// switch (token.type)
-// {
-// case YAML_TAG_DIRECTIVE_TOKEN:
-// yaml_free(token.data.tag_directive.handle);
-// yaml_free(token.data.tag_directive.prefix);
-// break;
-//
-// case YAML_ALIAS_TOKEN:
-// yaml_free(token.data.alias.value);
-// break;
-//
-// case YAML_ANCHOR_TOKEN:
-// yaml_free(token.data.anchor.value);
-// break;
-//
-// case YAML_TAG_TOKEN:
-// yaml_free(token.data.tag.handle);
-// yaml_free(token.data.tag.suffix);
-// break;
-//
-// case YAML_SCALAR_TOKEN:
-// yaml_free(token.data.scalar.value);
-// break;
-//
-// default:
-// break;
-// }
-//
-// memset(token, 0, sizeof(yaml_token_t));
-//}
-//
-///*
-// * Check if a string is a valid UTF-8 sequence.
-// *
-// * Check 'reader.c' for more details on UTF-8 encoding.
-// */
-//
-//static int
-//yaml_check_utf8(yaml_char_t *start, size_t length)
-//{
-// yaml_char_t *end = start+length;
-// yaml_char_t *pointer = start;
-//
-// while (pointer < end) {
-// unsigned char octet;
-// unsigned int width;
-// unsigned int value;
-// size_t k;
-//
-// octet = pointer[0];
-// width = (octet & 0x80) == 0x00 ? 1 :
-// (octet & 0xE0) == 0xC0 ? 2 :
-// (octet & 0xF0) == 0xE0 ? 3 :
-// (octet & 0xF8) == 0xF0 ? 4 : 0;
-// value = (octet & 0x80) == 0x00 ? octet & 0x7F :
-// (octet & 0xE0) == 0xC0 ? octet & 0x1F :
-// (octet & 0xF0) == 0xE0 ? octet & 0x0F :
-// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
-// if (!width) return 0;
-// if (pointer+width > end) return 0;
-// for (k = 1; k < width; k ++) {
-// octet = pointer[k];
-// if ((octet & 0xC0) != 0x80) return 0;
-// value = (value << 6) + (octet & 0x3F);
-// }
-// if (!((width == 1) ||
-// (width == 2 && value >= 0x80) ||
-// (width == 3 && value >= 0x800) ||
-// (width == 4 && value >= 0x10000))) return 0;
-//
-// pointer += width;
-// }
-//
-// return 1;
-//}
-//
-
-// Create STREAM-START.
-func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
- *event = yaml_event_t{
- typ: yaml_STREAM_START_EVENT,
- encoding: encoding,
- }
-}
-
-// Create STREAM-END.
-func yaml_stream_end_event_initialize(event *yaml_event_t) {
- *event = yaml_event_t{
- typ: yaml_STREAM_END_EVENT,
- }
-}
-
-// Create DOCUMENT-START.
-func yaml_document_start_event_initialize(
- event *yaml_event_t,
- version_directive *yaml_version_directive_t,
- tag_directives []yaml_tag_directive_t,
- implicit bool,
-) {
- *event = yaml_event_t{
- typ: yaml_DOCUMENT_START_EVENT,
- version_directive: version_directive,
- tag_directives: tag_directives,
- implicit: implicit,
- }
-}
-
-// Create DOCUMENT-END.
-func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
- *event = yaml_event_t{
- typ: yaml_DOCUMENT_END_EVENT,
- implicit: implicit,
- }
-}
-
-// Create ALIAS.
-func yaml_alias_event_initialize(event *yaml_event_t, anchor []byte) bool {
- *event = yaml_event_t{
- typ: yaml_ALIAS_EVENT,
- anchor: anchor,
- }
- return true
-}
-
-// Create SCALAR.
-func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
- *event = yaml_event_t{
- typ: yaml_SCALAR_EVENT,
- anchor: anchor,
- tag: tag,
- value: value,
- implicit: plain_implicit,
- quoted_implicit: quoted_implicit,
- style: yaml_style_t(style),
- }
- return true
-}
-
-// Create SEQUENCE-START.
-func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_START_EVENT,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(style),
- }
- return true
-}
-
-// Create SEQUENCE-END.
-func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_END_EVENT,
- }
- return true
-}
-
-// Create MAPPING-START.
-func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
- *event = yaml_event_t{
- typ: yaml_MAPPING_START_EVENT,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(style),
- }
-}
-
-// Create MAPPING-END.
-func yaml_mapping_end_event_initialize(event *yaml_event_t) {
- *event = yaml_event_t{
- typ: yaml_MAPPING_END_EVENT,
- }
-}
-
-// Destroy an event object.
-func yaml_event_delete(event *yaml_event_t) {
- *event = yaml_event_t{}
-}
-
-///*
-// * Create a document object.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_initialize(document *yaml_document_t,
-// version_directive *yaml_version_directive_t,
-// tag_directives_start *yaml_tag_directive_t,
-// tag_directives_end *yaml_tag_directive_t,
-// start_implicit int, end_implicit int)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-// struct {
-// start *yaml_node_t
-// end *yaml_node_t
-// top *yaml_node_t
-// } nodes = { NULL, NULL, NULL }
-// version_directive_copy *yaml_version_directive_t = NULL
-// struct {
-// start *yaml_tag_directive_t
-// end *yaml_tag_directive_t
-// top *yaml_tag_directive_t
-// } tag_directives_copy = { NULL, NULL, NULL }
-// value yaml_tag_directive_t = { NULL, NULL }
-// mark yaml_mark_t = { 0, 0, 0 }
-//
-// assert(document) // Non-NULL document object is expected.
-// assert((tag_directives_start && tag_directives_end) ||
-// (tag_directives_start == tag_directives_end))
-// // Valid tag directives are expected.
-//
-// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
-//
-// if (version_directive) {
-// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
-// if (!version_directive_copy) goto error
-// version_directive_copy.major = version_directive.major
-// version_directive_copy.minor = version_directive.minor
-// }
-//
-// if (tag_directives_start != tag_directives_end) {
-// tag_directive *yaml_tag_directive_t
-// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
-// goto error
-// for (tag_directive = tag_directives_start
-// tag_directive != tag_directives_end; tag_directive ++) {
-// assert(tag_directive.handle)
-// assert(tag_directive.prefix)
-// if (!yaml_check_utf8(tag_directive.handle,
-// strlen((char *)tag_directive.handle)))
-// goto error
-// if (!yaml_check_utf8(tag_directive.prefix,
-// strlen((char *)tag_directive.prefix)))
-// goto error
-// value.handle = yaml_strdup(tag_directive.handle)
-// value.prefix = yaml_strdup(tag_directive.prefix)
-// if (!value.handle || !value.prefix) goto error
-// if (!PUSH(&context, tag_directives_copy, value))
-// goto error
-// value.handle = NULL
-// value.prefix = NULL
-// }
-// }
-//
-// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
-// tag_directives_copy.start, tag_directives_copy.top,
-// start_implicit, end_implicit, mark, mark)
-//
-// return 1
-//
-//error:
-// STACK_DEL(&context, nodes)
-// yaml_free(version_directive_copy)
-// while (!STACK_EMPTY(&context, tag_directives_copy)) {
-// value yaml_tag_directive_t = POP(&context, tag_directives_copy)
-// yaml_free(value.handle)
-// yaml_free(value.prefix)
-// }
-// STACK_DEL(&context, tag_directives_copy)
-// yaml_free(value.handle)
-// yaml_free(value.prefix)
-//
-// return 0
-//}
-//
-///*
-// * Destroy a document object.
-// */
-//
-//YAML_DECLARE(void)
-//yaml_document_delete(document *yaml_document_t)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-// tag_directive *yaml_tag_directive_t
-//
-// context.error = YAML_NO_ERROR // Eliminate a compiler warning.
-//
-// assert(document) // Non-NULL document object is expected.
-//
-// while (!STACK_EMPTY(&context, document.nodes)) {
-// node yaml_node_t = POP(&context, document.nodes)
-// yaml_free(node.tag)
-// switch (node.type) {
-// case YAML_SCALAR_NODE:
-// yaml_free(node.data.scalar.value)
-// break
-// case YAML_SEQUENCE_NODE:
-// STACK_DEL(&context, node.data.sequence.items)
-// break
-// case YAML_MAPPING_NODE:
-// STACK_DEL(&context, node.data.mapping.pairs)
-// break
-// default:
-// assert(0) // Should not happen.
-// }
-// }
-// STACK_DEL(&context, document.nodes)
-//
-// yaml_free(document.version_directive)
-// for (tag_directive = document.tag_directives.start
-// tag_directive != document.tag_directives.end
-// tag_directive++) {
-// yaml_free(tag_directive.handle)
-// yaml_free(tag_directive.prefix)
-// }
-// yaml_free(document.tag_directives.start)
-//
-// memset(document, 0, sizeof(yaml_document_t))
-//}
-//
-///**
-// * Get a document node.
-// */
-//
-//YAML_DECLARE(yaml_node_t *)
-//yaml_document_get_node(document *yaml_document_t, index int)
-//{
-// assert(document) // Non-NULL document object is expected.
-//
-// if (index > 0 && document.nodes.start + index <= document.nodes.top) {
-// return document.nodes.start + index - 1
-// }
-// return NULL
-//}
-//
-///**
-// * Get the root object.
-// */
-//
-//YAML_DECLARE(yaml_node_t *)
-//yaml_document_get_root_node(document *yaml_document_t)
-//{
-// assert(document) // Non-NULL document object is expected.
-//
-// if (document.nodes.top != document.nodes.start) {
-// return document.nodes.start
-// }
-// return NULL
-//}
-//
-///*
-// * Add a scalar node to a document.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_add_scalar(document *yaml_document_t,
-// tag *yaml_char_t, value *yaml_char_t, length int,
-// style yaml_scalar_style_t)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-// mark yaml_mark_t = { 0, 0, 0 }
-// tag_copy *yaml_char_t = NULL
-// value_copy *yaml_char_t = NULL
-// node yaml_node_t
-//
-// assert(document) // Non-NULL document object is expected.
-// assert(value) // Non-NULL value is expected.
-//
-// if (!tag) {
-// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
-// }
-//
-// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
-// tag_copy = yaml_strdup(tag)
-// if (!tag_copy) goto error
-//
-// if (length < 0) {
-// length = strlen((char *)value)
-// }
-//
-// if (!yaml_check_utf8(value, length)) goto error
-// value_copy = yaml_malloc(length+1)
-// if (!value_copy) goto error
-// memcpy(value_copy, value, length)
-// value_copy[length] = '\0'
-//
-// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
-// if (!PUSH(&context, document.nodes, node)) goto error
-//
-// return document.nodes.top - document.nodes.start
-//
-//error:
-// yaml_free(tag_copy)
-// yaml_free(value_copy)
-//
-// return 0
-//}
-//
-///*
-// * Add a sequence node to a document.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_add_sequence(document *yaml_document_t,
-// tag *yaml_char_t, style yaml_sequence_style_t)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-// mark yaml_mark_t = { 0, 0, 0 }
-// tag_copy *yaml_char_t = NULL
-// struct {
-// start *yaml_node_item_t
-// end *yaml_node_item_t
-// top *yaml_node_item_t
-// } items = { NULL, NULL, NULL }
-// node yaml_node_t
-//
-// assert(document) // Non-NULL document object is expected.
-//
-// if (!tag) {
-// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
-// }
-//
-// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
-// tag_copy = yaml_strdup(tag)
-// if (!tag_copy) goto error
-//
-// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
-//
-// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
-// style, mark, mark)
-// if (!PUSH(&context, document.nodes, node)) goto error
-//
-// return document.nodes.top - document.nodes.start
-//
-//error:
-// STACK_DEL(&context, items)
-// yaml_free(tag_copy)
-//
-// return 0
-//}
-//
-///*
-// * Add a mapping node to a document.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_add_mapping(document *yaml_document_t,
-// tag *yaml_char_t, style yaml_mapping_style_t)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-// mark yaml_mark_t = { 0, 0, 0 }
-// tag_copy *yaml_char_t = NULL
-// struct {
-// start *yaml_node_pair_t
-// end *yaml_node_pair_t
-// top *yaml_node_pair_t
-// } pairs = { NULL, NULL, NULL }
-// node yaml_node_t
-//
-// assert(document) // Non-NULL document object is expected.
-//
-// if (!tag) {
-// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
-// }
-//
-// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
-// tag_copy = yaml_strdup(tag)
-// if (!tag_copy) goto error
-//
-// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
-//
-// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
-// style, mark, mark)
-// if (!PUSH(&context, document.nodes, node)) goto error
-//
-// return document.nodes.top - document.nodes.start
-//
-//error:
-// STACK_DEL(&context, pairs)
-// yaml_free(tag_copy)
-//
-// return 0
-//}
-//
-///*
-// * Append an item to a sequence node.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_append_sequence_item(document *yaml_document_t,
-// sequence int, item int)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-//
-// assert(document) // Non-NULL document is required.
-// assert(sequence > 0
-// && document.nodes.start + sequence <= document.nodes.top)
-// // Valid sequence id is required.
-// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
-// // A sequence node is required.
-// assert(item > 0 && document.nodes.start + item <= document.nodes.top)
-// // Valid item id is required.
-//
-// if (!PUSH(&context,
-// document.nodes.start[sequence-1].data.sequence.items, item))
-// return 0
-//
-// return 1
-//}
-//
-///*
-// * Append a pair of a key and a value to a mapping node.
-// */
-//
-//YAML_DECLARE(int)
-//yaml_document_append_mapping_pair(document *yaml_document_t,
-// mapping int, key int, value int)
-//{
-// struct {
-// error yaml_error_type_t
-// } context
-//
-// pair yaml_node_pair_t
-//
-// assert(document) // Non-NULL document is required.
-// assert(mapping > 0
-// && document.nodes.start + mapping <= document.nodes.top)
-// // Valid mapping id is required.
-// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
-// // A mapping node is required.
-// assert(key > 0 && document.nodes.start + key <= document.nodes.top)
-// // Valid key id is required.
-// assert(value > 0 && document.nodes.start + value <= document.nodes.top)
-// // Valid value id is required.
-//
-// pair.key = key
-// pair.value = value
-//
-// if (!PUSH(&context,
-// document.nodes.start[mapping-1].data.mapping.pairs, pair))
-// return 0
-//
-// return 1
-//}
-//
-//
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode.go
deleted file mode 100644
index 0173b6982e8437ee6b74c2708fc6c2f082ae650e..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode.go
+++ /dev/null
@@ -1,1000 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml
-
-import (
- "encoding"
- "encoding/base64"
- "fmt"
- "io"
- "math"
- "reflect"
- "strconv"
- "time"
-)
-
-// ----------------------------------------------------------------------------
-// Parser, produces a node tree out of a libyaml event stream.
-
-type parser struct {
- parser yaml_parser_t
- event yaml_event_t
- doc *Node
- anchors map[string]*Node
- doneInit bool
- textless bool
-}
-
-func newParser(b []byte) *parser {
- p := parser{}
- if !yaml_parser_initialize(&p.parser) {
- panic("failed to initialize YAML emitter")
- }
- if len(b) == 0 {
- b = []byte{'\n'}
- }
- yaml_parser_set_input_string(&p.parser, b)
- return &p
-}
-
-func newParserFromReader(r io.Reader) *parser {
- p := parser{}
- if !yaml_parser_initialize(&p.parser) {
- panic("failed to initialize YAML emitter")
- }
- yaml_parser_set_input_reader(&p.parser, r)
- return &p
-}
-
-func (p *parser) init() {
- if p.doneInit {
- return
- }
- p.anchors = make(map[string]*Node)
- p.expect(yaml_STREAM_START_EVENT)
- p.doneInit = true
-}
-
-func (p *parser) destroy() {
- if p.event.typ != yaml_NO_EVENT {
- yaml_event_delete(&p.event)
- }
- yaml_parser_delete(&p.parser)
-}
-
-// expect consumes an event from the event stream and
-// checks that it's of the expected type.
-func (p *parser) expect(e yaml_event_type_t) {
- if p.event.typ == yaml_NO_EVENT {
- if !yaml_parser_parse(&p.parser, &p.event) {
- p.fail()
- }
- }
- if p.event.typ == yaml_STREAM_END_EVENT {
- failf("attempted to go past the end of stream; corrupted value?")
- }
- if p.event.typ != e {
- p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)
- p.fail()
- }
- yaml_event_delete(&p.event)
- p.event.typ = yaml_NO_EVENT
-}
-
-// peek peeks at the next event in the event stream,
-// puts the results into p.event and returns the event type.
-func (p *parser) peek() yaml_event_type_t {
- if p.event.typ != yaml_NO_EVENT {
- return p.event.typ
- }
- // It's curious choice from the underlying API to generally return a
- // positive result on success, but on this case return true in an error
- // scenario. This was the source of bugs in the past (issue #666).
- if !yaml_parser_parse(&p.parser, &p.event) || p.parser.error != yaml_NO_ERROR {
- p.fail()
- }
- return p.event.typ
-}
-
-func (p *parser) fail() {
- var where string
- var line int
- if p.parser.context_mark.line != 0 {
- line = p.parser.context_mark.line
- // Scanner errors don't iterate line before returning error
- if p.parser.error == yaml_SCANNER_ERROR {
- line++
- }
- } else if p.parser.problem_mark.line != 0 {
- line = p.parser.problem_mark.line
- // Scanner errors don't iterate line before returning error
- if p.parser.error == yaml_SCANNER_ERROR {
- line++
- }
- }
- if line != 0 {
- where = "line " + strconv.Itoa(line) + ": "
- }
- var msg string
- if len(p.parser.problem) > 0 {
- msg = p.parser.problem
- } else {
- msg = "unknown problem parsing YAML content"
- }
- failf("%s%s", where, msg)
-}
-
-func (p *parser) anchor(n *Node, anchor []byte) {
- if anchor != nil {
- n.Anchor = string(anchor)
- p.anchors[n.Anchor] = n
- }
-}
-
-func (p *parser) parse() *Node {
- p.init()
- switch p.peek() {
- case yaml_SCALAR_EVENT:
- return p.scalar()
- case yaml_ALIAS_EVENT:
- return p.alias()
- case yaml_MAPPING_START_EVENT:
- return p.mapping()
- case yaml_SEQUENCE_START_EVENT:
- return p.sequence()
- case yaml_DOCUMENT_START_EVENT:
- return p.document()
- case yaml_STREAM_END_EVENT:
- // Happens when attempting to decode an empty buffer.
- return nil
- case yaml_TAIL_COMMENT_EVENT:
- panic("internal error: unexpected tail comment event (please report)")
- default:
- panic("internal error: attempted to parse unknown event (please report): " + p.event.typ.String())
- }
-}
-
-func (p *parser) node(kind Kind, defaultTag, tag, value string) *Node {
- var style Style
- if tag != "" && tag != "!" {
- tag = shortTag(tag)
- style = TaggedStyle
- } else if defaultTag != "" {
- tag = defaultTag
- } else if kind == ScalarNode {
- tag, _ = resolve("", value)
- }
- n := &Node{
- Kind: kind,
- Tag: tag,
- Value: value,
- Style: style,
- }
- if !p.textless {
- n.Line = p.event.start_mark.line + 1
- n.Column = p.event.start_mark.column + 1
- n.HeadComment = string(p.event.head_comment)
- n.LineComment = string(p.event.line_comment)
- n.FootComment = string(p.event.foot_comment)
- }
- return n
-}
-
-func (p *parser) parseChild(parent *Node) *Node {
- child := p.parse()
- parent.Content = append(parent.Content, child)
- return child
-}
-
-func (p *parser) document() *Node {
- n := p.node(DocumentNode, "", "", "")
- p.doc = n
- p.expect(yaml_DOCUMENT_START_EVENT)
- p.parseChild(n)
- if p.peek() == yaml_DOCUMENT_END_EVENT {
- n.FootComment = string(p.event.foot_comment)
- }
- p.expect(yaml_DOCUMENT_END_EVENT)
- return n
-}
-
-func (p *parser) alias() *Node {
- n := p.node(AliasNode, "", "", string(p.event.anchor))
- n.Alias = p.anchors[n.Value]
- if n.Alias == nil {
- failf("unknown anchor '%s' referenced", n.Value)
- }
- p.expect(yaml_ALIAS_EVENT)
- return n
-}
-
-func (p *parser) scalar() *Node {
- var parsedStyle = p.event.scalar_style()
- var nodeStyle Style
- switch {
- case parsedStyle&yaml_DOUBLE_QUOTED_SCALAR_STYLE != 0:
- nodeStyle = DoubleQuotedStyle
- case parsedStyle&yaml_SINGLE_QUOTED_SCALAR_STYLE != 0:
- nodeStyle = SingleQuotedStyle
- case parsedStyle&yaml_LITERAL_SCALAR_STYLE != 0:
- nodeStyle = LiteralStyle
- case parsedStyle&yaml_FOLDED_SCALAR_STYLE != 0:
- nodeStyle = FoldedStyle
- }
- var nodeValue = string(p.event.value)
- var nodeTag = string(p.event.tag)
- var defaultTag string
- if nodeStyle == 0 {
- if nodeValue == "<<" {
- defaultTag = mergeTag
- }
- } else {
- defaultTag = strTag
- }
- n := p.node(ScalarNode, defaultTag, nodeTag, nodeValue)
- n.Style |= nodeStyle
- p.anchor(n, p.event.anchor)
- p.expect(yaml_SCALAR_EVENT)
- return n
-}
-
-func (p *parser) sequence() *Node {
- n := p.node(SequenceNode, seqTag, string(p.event.tag), "")
- if p.event.sequence_style()&yaml_FLOW_SEQUENCE_STYLE != 0 {
- n.Style |= FlowStyle
- }
- p.anchor(n, p.event.anchor)
- p.expect(yaml_SEQUENCE_START_EVENT)
- for p.peek() != yaml_SEQUENCE_END_EVENT {
- p.parseChild(n)
- }
- n.LineComment = string(p.event.line_comment)
- n.FootComment = string(p.event.foot_comment)
- p.expect(yaml_SEQUENCE_END_EVENT)
- return n
-}
-
-func (p *parser) mapping() *Node {
- n := p.node(MappingNode, mapTag, string(p.event.tag), "")
- block := true
- if p.event.mapping_style()&yaml_FLOW_MAPPING_STYLE != 0 {
- block = false
- n.Style |= FlowStyle
- }
- p.anchor(n, p.event.anchor)
- p.expect(yaml_MAPPING_START_EVENT)
- for p.peek() != yaml_MAPPING_END_EVENT {
- k := p.parseChild(n)
- if block && k.FootComment != "" {
- // Must be a foot comment for the prior value when being dedented.
- if len(n.Content) > 2 {
- n.Content[len(n.Content)-3].FootComment = k.FootComment
- k.FootComment = ""
- }
- }
- v := p.parseChild(n)
- if k.FootComment == "" && v.FootComment != "" {
- k.FootComment = v.FootComment
- v.FootComment = ""
- }
- if p.peek() == yaml_TAIL_COMMENT_EVENT {
- if k.FootComment == "" {
- k.FootComment = string(p.event.foot_comment)
- }
- p.expect(yaml_TAIL_COMMENT_EVENT)
- }
- }
- n.LineComment = string(p.event.line_comment)
- n.FootComment = string(p.event.foot_comment)
- if n.Style&FlowStyle == 0 && n.FootComment != "" && len(n.Content) > 1 {
- n.Content[len(n.Content)-2].FootComment = n.FootComment
- n.FootComment = ""
- }
- p.expect(yaml_MAPPING_END_EVENT)
- return n
-}
-
-// ----------------------------------------------------------------------------
-// Decoder, unmarshals a node into a provided value.
-
-type decoder struct {
- doc *Node
- aliases map[*Node]bool
- terrors []string
-
- stringMapType reflect.Type
- generalMapType reflect.Type
-
- knownFields bool
- uniqueKeys bool
- decodeCount int
- aliasCount int
- aliasDepth int
-
- mergedFields map[interface{}]bool
-}
-
-var (
- nodeType = reflect.TypeOf(Node{})
- durationType = reflect.TypeOf(time.Duration(0))
- stringMapType = reflect.TypeOf(map[string]interface{}{})
- generalMapType = reflect.TypeOf(map[interface{}]interface{}{})
- ifaceType = generalMapType.Elem()
- timeType = reflect.TypeOf(time.Time{})
- ptrTimeType = reflect.TypeOf(&time.Time{})
-)
-
-func newDecoder() *decoder {
- d := &decoder{
- stringMapType: stringMapType,
- generalMapType: generalMapType,
- uniqueKeys: true,
- }
- d.aliases = make(map[*Node]bool)
- return d
-}
-
-func (d *decoder) terror(n *Node, tag string, out reflect.Value) {
- if n.Tag != "" {
- tag = n.Tag
- }
- value := n.Value
- if tag != seqTag && tag != mapTag {
- if len(value) > 10 {
- value = " `" + value[:7] + "...`"
- } else {
- value = " `" + value + "`"
- }
- }
- d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.Line, shortTag(tag), value, out.Type()))
-}
-
-func (d *decoder) callUnmarshaler(n *Node, u Unmarshaler) (good bool) {
- err := u.UnmarshalYAML(n)
- if e, ok := err.(*TypeError); ok {
- d.terrors = append(d.terrors, e.Errors...)
- return false
- }
- if err != nil {
- fail(err)
- }
- return true
-}
-
-func (d *decoder) callObsoleteUnmarshaler(n *Node, u obsoleteUnmarshaler) (good bool) {
- terrlen := len(d.terrors)
- err := u.UnmarshalYAML(func(v interface{}) (err error) {
- defer handleErr(&err)
- d.unmarshal(n, reflect.ValueOf(v))
- if len(d.terrors) > terrlen {
- issues := d.terrors[terrlen:]
- d.terrors = d.terrors[:terrlen]
- return &TypeError{issues}
- }
- return nil
- })
- if e, ok := err.(*TypeError); ok {
- d.terrors = append(d.terrors, e.Errors...)
- return false
- }
- if err != nil {
- fail(err)
- }
- return true
-}
-
-// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
-// if a value is found to implement it.
-// It returns the initialized and dereferenced out value, whether
-// unmarshalling was already done by UnmarshalYAML, and if so whether
-// its types unmarshalled appropriately.
-//
-// If n holds a null value, prepare returns before doing anything.
-func (d *decoder) prepare(n *Node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
- if n.ShortTag() == nullTag {
- return out, false, false
- }
- again := true
- for again {
- again = false
- if out.Kind() == reflect.Ptr {
- if out.IsNil() {
- out.Set(reflect.New(out.Type().Elem()))
- }
- out = out.Elem()
- again = true
- }
- if out.CanAddr() {
- outi := out.Addr().Interface()
- if u, ok := outi.(Unmarshaler); ok {
- good = d.callUnmarshaler(n, u)
- return out, true, good
- }
- if u, ok := outi.(obsoleteUnmarshaler); ok {
- good = d.callObsoleteUnmarshaler(n, u)
- return out, true, good
- }
- }
- }
- return out, false, false
-}
-
-func (d *decoder) fieldByIndex(n *Node, v reflect.Value, index []int) (field reflect.Value) {
- if n.ShortTag() == nullTag {
- return reflect.Value{}
- }
- for _, num := range index {
- for {
- if v.Kind() == reflect.Ptr {
- if v.IsNil() {
- v.Set(reflect.New(v.Type().Elem()))
- }
- v = v.Elem()
- continue
- }
- break
- }
- v = v.Field(num)
- }
- return v
-}
-
-const (
- // 400,000 decode operations is ~500kb of dense object declarations, or
- // ~5kb of dense object declarations with 10000% alias expansion
- alias_ratio_range_low = 400000
-
- // 4,000,000 decode operations is ~5MB of dense object declarations, or
- // ~4.5MB of dense object declarations with 10% alias expansion
- alias_ratio_range_high = 4000000
-
- // alias_ratio_range is the range over which we scale allowed alias ratios
- alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
-)
-
-func allowedAliasRatio(decodeCount int) float64 {
- switch {
- case decodeCount <= alias_ratio_range_low:
- // allow 99% to come from alias expansion for small-to-medium documents
- return 0.99
- case decodeCount >= alias_ratio_range_high:
- // allow 10% to come from alias expansion for very large documents
- return 0.10
- default:
- // scale smoothly from 99% down to 10% over the range.
- // this maps to 396,000 - 400,000 allowed alias-driven decodes over the range.
- // 400,000 decode operations is ~100MB of allocations in worst-case scenarios (single-item maps).
- return 0.99 - 0.89*(float64(decodeCount-alias_ratio_range_low)/alias_ratio_range)
- }
-}
-
-func (d *decoder) unmarshal(n *Node, out reflect.Value) (good bool) {
- d.decodeCount++
- if d.aliasDepth > 0 {
- d.aliasCount++
- }
- if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
- failf("document contains excessive aliasing")
- }
- if out.Type() == nodeType {
- out.Set(reflect.ValueOf(n).Elem())
- return true
- }
- switch n.Kind {
- case DocumentNode:
- return d.document(n, out)
- case AliasNode:
- return d.alias(n, out)
- }
- out, unmarshaled, good := d.prepare(n, out)
- if unmarshaled {
- return good
- }
- switch n.Kind {
- case ScalarNode:
- good = d.scalar(n, out)
- case MappingNode:
- good = d.mapping(n, out)
- case SequenceNode:
- good = d.sequence(n, out)
- case 0:
- if n.IsZero() {
- return d.null(out)
- }
- fallthrough
- default:
- failf("cannot decode node with unknown kind %d", n.Kind)
- }
- return good
-}
-
-func (d *decoder) document(n *Node, out reflect.Value) (good bool) {
- if len(n.Content) == 1 {
- d.doc = n
- d.unmarshal(n.Content[0], out)
- return true
- }
- return false
-}
-
-func (d *decoder) alias(n *Node, out reflect.Value) (good bool) {
- if d.aliases[n] {
- // TODO this could actually be allowed in some circumstances.
- failf("anchor '%s' value contains itself", n.Value)
- }
- d.aliases[n] = true
- d.aliasDepth++
- good = d.unmarshal(n.Alias, out)
- d.aliasDepth--
- delete(d.aliases, n)
- return good
-}
-
-var zeroValue reflect.Value
-
-func resetMap(out reflect.Value) {
- for _, k := range out.MapKeys() {
- out.SetMapIndex(k, zeroValue)
- }
-}
-
-func (d *decoder) null(out reflect.Value) bool {
- if out.CanAddr() {
- switch out.Kind() {
- case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
- out.Set(reflect.Zero(out.Type()))
- return true
- }
- }
- return false
-}
-
-func (d *decoder) scalar(n *Node, out reflect.Value) bool {
- var tag string
- var resolved interface{}
- if n.indicatedString() {
- tag = strTag
- resolved = n.Value
- } else {
- tag, resolved = resolve(n.Tag, n.Value)
- if tag == binaryTag {
- data, err := base64.StdEncoding.DecodeString(resolved.(string))
- if err != nil {
- failf("!!binary value contains invalid base64 data")
- }
- resolved = string(data)
- }
- }
- if resolved == nil {
- return d.null(out)
- }
- if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
- // We've resolved to exactly the type we want, so use that.
- out.Set(resolvedv)
- return true
- }
- // Perhaps we can use the value as a TextUnmarshaler to
- // set its value.
- if out.CanAddr() {
- u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
- if ok {
- var text []byte
- if tag == binaryTag {
- text = []byte(resolved.(string))
- } else {
- // We let any value be unmarshaled into TextUnmarshaler.
- // That might be more lax than we'd like, but the
- // TextUnmarshaler itself should bowl out any dubious values.
- text = []byte(n.Value)
- }
- err := u.UnmarshalText(text)
- if err != nil {
- fail(err)
- }
- return true
- }
- }
- switch out.Kind() {
- case reflect.String:
- if tag == binaryTag {
- out.SetString(resolved.(string))
- return true
- }
- out.SetString(n.Value)
- return true
- case reflect.Interface:
- out.Set(reflect.ValueOf(resolved))
- return true
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- // This used to work in v2, but it's very unfriendly.
- isDuration := out.Type() == durationType
-
- switch resolved := resolved.(type) {
- case int:
- if !isDuration && !out.OverflowInt(int64(resolved)) {
- out.SetInt(int64(resolved))
- return true
- }
- case int64:
- if !isDuration && !out.OverflowInt(resolved) {
- out.SetInt(resolved)
- return true
- }
- case uint64:
- if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
- out.SetInt(int64(resolved))
- return true
- }
- case float64:
- if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
- out.SetInt(int64(resolved))
- return true
- }
- case string:
- if out.Type() == durationType {
- d, err := time.ParseDuration(resolved)
- if err == nil {
- out.SetInt(int64(d))
- return true
- }
- }
- }
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- switch resolved := resolved.(type) {
- case int:
- if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- return true
- }
- case int64:
- if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- return true
- }
- case uint64:
- if !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- return true
- }
- case float64:
- if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- return true
- }
- }
- case reflect.Bool:
- switch resolved := resolved.(type) {
- case bool:
- out.SetBool(resolved)
- return true
- case string:
- // This offers some compatibility with the 1.1 spec (https://yaml.org/type/bool.html).
- // It only works if explicitly attempting to unmarshal into a typed bool value.
- switch resolved {
- case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":
- out.SetBool(true)
- return true
- case "n", "N", "no", "No", "NO", "off", "Off", "OFF":
- out.SetBool(false)
- return true
- }
- }
- case reflect.Float32, reflect.Float64:
- switch resolved := resolved.(type) {
- case int:
- out.SetFloat(float64(resolved))
- return true
- case int64:
- out.SetFloat(float64(resolved))
- return true
- case uint64:
- out.SetFloat(float64(resolved))
- return true
- case float64:
- out.SetFloat(resolved)
- return true
- }
- case reflect.Struct:
- if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
- out.Set(resolvedv)
- return true
- }
- case reflect.Ptr:
- panic("yaml internal error: please report the issue")
- }
- d.terror(n, tag, out)
- return false
-}
-
-func settableValueOf(i interface{}) reflect.Value {
- v := reflect.ValueOf(i)
- sv := reflect.New(v.Type()).Elem()
- sv.Set(v)
- return sv
-}
-
-func (d *decoder) sequence(n *Node, out reflect.Value) (good bool) {
- l := len(n.Content)
-
- var iface reflect.Value
- switch out.Kind() {
- case reflect.Slice:
- out.Set(reflect.MakeSlice(out.Type(), l, l))
- case reflect.Array:
- if l != out.Len() {
- failf("invalid array: want %d elements but got %d", out.Len(), l)
- }
- case reflect.Interface:
- // No type hints. Will have to use a generic sequence.
- iface = out
- out = settableValueOf(make([]interface{}, l))
- default:
- d.terror(n, seqTag, out)
- return false
- }
- et := out.Type().Elem()
-
- j := 0
- for i := 0; i < l; i++ {
- e := reflect.New(et).Elem()
- if ok := d.unmarshal(n.Content[i], e); ok {
- out.Index(j).Set(e)
- j++
- }
- }
- if out.Kind() != reflect.Array {
- out.Set(out.Slice(0, j))
- }
- if iface.IsValid() {
- iface.Set(out)
- }
- return true
-}
-
-func (d *decoder) mapping(n *Node, out reflect.Value) (good bool) {
- l := len(n.Content)
- if d.uniqueKeys {
- nerrs := len(d.terrors)
- for i := 0; i < l; i += 2 {
- ni := n.Content[i]
- for j := i + 2; j < l; j += 2 {
- nj := n.Content[j]
- if ni.Kind == nj.Kind && ni.Value == nj.Value {
- d.terrors = append(d.terrors, fmt.Sprintf("line %d: mapping key %#v already defined at line %d", nj.Line, nj.Value, ni.Line))
- }
- }
- }
- if len(d.terrors) > nerrs {
- return false
- }
- }
- switch out.Kind() {
- case reflect.Struct:
- return d.mappingStruct(n, out)
- case reflect.Map:
- // okay
- case reflect.Interface:
- iface := out
- if isStringMap(n) {
- out = reflect.MakeMap(d.stringMapType)
- } else {
- out = reflect.MakeMap(d.generalMapType)
- }
- iface.Set(out)
- default:
- d.terror(n, mapTag, out)
- return false
- }
-
- outt := out.Type()
- kt := outt.Key()
- et := outt.Elem()
-
- stringMapType := d.stringMapType
- generalMapType := d.generalMapType
- if outt.Elem() == ifaceType {
- if outt.Key().Kind() == reflect.String {
- d.stringMapType = outt
- } else if outt.Key() == ifaceType {
- d.generalMapType = outt
- }
- }
-
- mergedFields := d.mergedFields
- d.mergedFields = nil
-
- var mergeNode *Node
-
- mapIsNew := false
- if out.IsNil() {
- out.Set(reflect.MakeMap(outt))
- mapIsNew = true
- }
- for i := 0; i < l; i += 2 {
- if isMerge(n.Content[i]) {
- mergeNode = n.Content[i+1]
- continue
- }
- k := reflect.New(kt).Elem()
- if d.unmarshal(n.Content[i], k) {
- if mergedFields != nil {
- ki := k.Interface()
- if mergedFields[ki] {
- continue
- }
- mergedFields[ki] = true
- }
- kkind := k.Kind()
- if kkind == reflect.Interface {
- kkind = k.Elem().Kind()
- }
- if kkind == reflect.Map || kkind == reflect.Slice {
- failf("invalid map key: %#v", k.Interface())
- }
- e := reflect.New(et).Elem()
- if d.unmarshal(n.Content[i+1], e) || n.Content[i+1].ShortTag() == nullTag && (mapIsNew || !out.MapIndex(k).IsValid()) {
- out.SetMapIndex(k, e)
- }
- }
- }
-
- d.mergedFields = mergedFields
- if mergeNode != nil {
- d.merge(n, mergeNode, out)
- }
-
- d.stringMapType = stringMapType
- d.generalMapType = generalMapType
- return true
-}
-
-func isStringMap(n *Node) bool {
- if n.Kind != MappingNode {
- return false
- }
- l := len(n.Content)
- for i := 0; i < l; i += 2 {
- shortTag := n.Content[i].ShortTag()
- if shortTag != strTag && shortTag != mergeTag {
- return false
- }
- }
- return true
-}
-
-func (d *decoder) mappingStruct(n *Node, out reflect.Value) (good bool) {
- sinfo, err := getStructInfo(out.Type())
- if err != nil {
- panic(err)
- }
-
- var inlineMap reflect.Value
- var elemType reflect.Type
- if sinfo.InlineMap != -1 {
- inlineMap = out.Field(sinfo.InlineMap)
- elemType = inlineMap.Type().Elem()
- }
-
- for _, index := range sinfo.InlineUnmarshalers {
- field := d.fieldByIndex(n, out, index)
- d.prepare(n, field)
- }
-
- mergedFields := d.mergedFields
- d.mergedFields = nil
- var mergeNode *Node
- var doneFields []bool
- if d.uniqueKeys {
- doneFields = make([]bool, len(sinfo.FieldsList))
- }
- name := settableValueOf("")
- l := len(n.Content)
- for i := 0; i < l; i += 2 {
- ni := n.Content[i]
- if isMerge(ni) {
- mergeNode = n.Content[i+1]
- continue
- }
- if !d.unmarshal(ni, name) {
- continue
- }
- sname := name.String()
- if mergedFields != nil {
- if mergedFields[sname] {
- continue
- }
- mergedFields[sname] = true
- }
- if info, ok := sinfo.FieldsMap[sname]; ok {
- if d.uniqueKeys {
- if doneFields[info.Id] {
- d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.Line, name.String(), out.Type()))
- continue
- }
- doneFields[info.Id] = true
- }
- var field reflect.Value
- if info.Inline == nil {
- field = out.Field(info.Num)
- } else {
- field = d.fieldByIndex(n, out, info.Inline)
- }
- d.unmarshal(n.Content[i+1], field)
- } else if sinfo.InlineMap != -1 {
- if inlineMap.IsNil() {
- inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
- }
- value := reflect.New(elemType).Elem()
- d.unmarshal(n.Content[i+1], value)
- inlineMap.SetMapIndex(name, value)
- } else if d.knownFields {
- d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.Line, name.String(), out.Type()))
- }
- }
-
- d.mergedFields = mergedFields
- if mergeNode != nil {
- d.merge(n, mergeNode, out)
- }
- return true
-}
-
-func failWantMap() {
- failf("map merge requires map or sequence of maps as the value")
-}
-
-func (d *decoder) merge(parent *Node, merge *Node, out reflect.Value) {
- mergedFields := d.mergedFields
- if mergedFields == nil {
- d.mergedFields = make(map[interface{}]bool)
- for i := 0; i < len(parent.Content); i += 2 {
- k := reflect.New(ifaceType).Elem()
- if d.unmarshal(parent.Content[i], k) {
- d.mergedFields[k.Interface()] = true
- }
- }
- }
-
- switch merge.Kind {
- case MappingNode:
- d.unmarshal(merge, out)
- case AliasNode:
- if merge.Alias != nil && merge.Alias.Kind != MappingNode {
- failWantMap()
- }
- d.unmarshal(merge, out)
- case SequenceNode:
- for i := 0; i < len(merge.Content); i++ {
- ni := merge.Content[i]
- if ni.Kind == AliasNode {
- if ni.Alias != nil && ni.Alias.Kind != MappingNode {
- failWantMap()
- }
- } else if ni.Kind != MappingNode {
- failWantMap()
- }
- d.unmarshal(ni, out)
- }
- default:
- failWantMap()
- }
-
- d.mergedFields = mergedFields
-}
-
-func isMerge(n *Node) bool {
- return n.Kind == ScalarNode && n.Value == "<<" && (n.Tag == "" || n.Tag == "!" || shortTag(n.Tag) == mergeTag)
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode_test.go
deleted file mode 100644
index 0364b0bb0bc7969a7497418b0c9652cb9c4f2fde..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/decode_test.go
+++ /dev/null
@@ -1,1771 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml_test
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
- "math"
- "reflect"
- "strings"
- "time"
-
- . "gopkg.in/check.v1"
- "gopkg.in/yaml.v3"
-)
-
-var unmarshalIntTest = 123
-
-var unmarshalTests = []struct {
- data string
- value interface{}
-}{
- {
- "",
- (*struct{})(nil),
- },
- {
- "{}", &struct{}{},
- }, {
- "v: hi",
- map[string]string{"v": "hi"},
- }, {
- "v: hi", map[string]interface{}{"v": "hi"},
- }, {
- "v: true",
- map[string]string{"v": "true"},
- }, {
- "v: true",
- map[string]interface{}{"v": true},
- }, {
- "v: 10",
- map[string]interface{}{"v": 10},
- }, {
- "v: 0b10",
- map[string]interface{}{"v": 2},
- }, {
- "v: 0xA",
- map[string]interface{}{"v": 10},
- }, {
- "v: 4294967296",
- map[string]int64{"v": 4294967296},
- }, {
- "v: 0.1",
- map[string]interface{}{"v": 0.1},
- }, {
- "v: .1",
- map[string]interface{}{"v": 0.1},
- }, {
- "v: .Inf",
- map[string]interface{}{"v": math.Inf(+1)},
- }, {
- "v: -.Inf",
- map[string]interface{}{"v": math.Inf(-1)},
- }, {
- "v: -10",
- map[string]interface{}{"v": -10},
- }, {
- "v: -.1",
- map[string]interface{}{"v": -0.1},
- },
-
- // Simple values.
- {
- "123",
- &unmarshalIntTest,
- },
-
- // Floats from spec
- {
- "canonical: 6.8523e+5",
- map[string]interface{}{"canonical": 6.8523e+5},
- }, {
- "expo: 685.230_15e+03",
- map[string]interface{}{"expo": 685.23015e+03},
- }, {
- "fixed: 685_230.15",
- map[string]interface{}{"fixed": 685230.15},
- }, {
- "neginf: -.inf",
- map[string]interface{}{"neginf": math.Inf(-1)},
- }, {
- "fixed: 685_230.15",
- map[string]float64{"fixed": 685230.15},
- },
- //{"sexa: 190:20:30.15", map[string]interface{}{"sexa": 0}}, // Unsupported
- //{"notanum: .NaN", map[string]interface{}{"notanum": math.NaN()}}, // Equality of NaN fails.
-
- // Bools are per 1.2 spec.
- {
- "canonical: true",
- map[string]interface{}{"canonical": true},
- }, {
- "canonical: false",
- map[string]interface{}{"canonical": false},
- }, {
- "bool: True",
- map[string]interface{}{"bool": true},
- }, {
- "bool: False",
- map[string]interface{}{"bool": false},
- }, {
- "bool: TRUE",
- map[string]interface{}{"bool": true},
- }, {
- "bool: FALSE",
- map[string]interface{}{"bool": false},
- },
- // For backwards compatibility with 1.1, decoding old strings into typed values still works.
- {
- "option: on",
- map[string]bool{"option": true},
- }, {
- "option: y",
- map[string]bool{"option": true},
- }, {
- "option: Off",
- map[string]bool{"option": false},
- }, {
- "option: No",
- map[string]bool{"option": false},
- }, {
- "option: other",
- map[string]bool{},
- },
- // Ints from spec
- {
- "canonical: 685230",
- map[string]interface{}{"canonical": 685230},
- }, {
- "decimal: +685_230",
- map[string]interface{}{"decimal": 685230},
- }, {
- "octal: 02472256",
- map[string]interface{}{"octal": 685230},
- }, {
- "octal: -02472256",
- map[string]interface{}{"octal": -685230},
- }, {
- "octal: 0o2472256",
- map[string]interface{}{"octal": 685230},
- }, {
- "octal: -0o2472256",
- map[string]interface{}{"octal": -685230},
- }, {
- "hexa: 0x_0A_74_AE",
- map[string]interface{}{"hexa": 685230},
- }, {
- "bin: 0b1010_0111_0100_1010_1110",
- map[string]interface{}{"bin": 685230},
- }, {
- "bin: -0b101010",
- map[string]interface{}{"bin": -42},
- }, {
- "bin: -0b1000000000000000000000000000000000000000000000000000000000000000",
- map[string]interface{}{"bin": -9223372036854775808},
- }, {
- "decimal: +685_230",
- map[string]int{"decimal": 685230},
- },
-
- //{"sexa: 190:20:30", map[string]interface{}{"sexa": 0}}, // Unsupported
-
- // Nulls from spec
- {
- "empty:",
- map[string]interface{}{"empty": nil},
- }, {
- "canonical: ~",
- map[string]interface{}{"canonical": nil},
- }, {
- "english: null",
- map[string]interface{}{"english": nil},
- }, {
- "~: null key",
- map[interface{}]string{nil: "null key"},
- }, {
- "empty:",
- map[string]*bool{"empty": nil},
- },
-
- // Flow sequence
- {
- "seq: [A,B]",
- map[string]interface{}{"seq": []interface{}{"A", "B"}},
- }, {
- "seq: [A,B,C,]",
- map[string][]string{"seq": []string{"A", "B", "C"}},
- }, {
- "seq: [A,1,C]",
- map[string][]string{"seq": []string{"A", "1", "C"}},
- }, {
- "seq: [A,1,C]",
- map[string][]int{"seq": []int{1}},
- }, {
- "seq: [A,1,C]",
- map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
- },
- // Block sequence
- {
- "seq:\n - A\n - B",
- map[string]interface{}{"seq": []interface{}{"A", "B"}},
- }, {
- "seq:\n - A\n - B\n - C",
- map[string][]string{"seq": []string{"A", "B", "C"}},
- }, {
- "seq:\n - A\n - 1\n - C",
- map[string][]string{"seq": []string{"A", "1", "C"}},
- }, {
- "seq:\n - A\n - 1\n - C",
- map[string][]int{"seq": []int{1}},
- }, {
- "seq:\n - A\n - 1\n - C",
- map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
- },
-
- // Literal block scalar
- {
- "scalar: | # Comment\n\n literal\n\n \ttext\n\n",
- map[string]string{"scalar": "\nliteral\n\n\ttext\n"},
- },
-
- // Folded block scalar
- {
- "scalar: > # Comment\n\n folded\n line\n \n next\n line\n * one\n * two\n\n last\n line\n\n",
- map[string]string{"scalar": "\nfolded line\nnext line\n * one\n * two\n\nlast line\n"},
- },
-
- // Map inside interface with no type hints.
- {
- "a: {b: c}",
- map[interface{}]interface{}{"a": map[string]interface{}{"b": "c"}},
- },
- // Non-string map inside interface with no type hints.
- {
- "a: {b: c, 1: d}",
- map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c", 1: "d"}},
- },
-
- // Structs and type conversions.
- {
- "hello: world",
- &struct{ Hello string }{"world"},
- }, {
- "a: {b: c}",
- &struct{ A struct{ B string } }{struct{ B string }{"c"}},
- }, {
- "a: {b: c}",
- &struct{ A *struct{ B string } }{&struct{ B string }{"c"}},
- }, {
- "a: 'null'",
- &struct{ A *unmarshalerType }{&unmarshalerType{"null"}},
- }, {
- "a: {b: c}",
- &struct{ A map[string]string }{map[string]string{"b": "c"}},
- }, {
- "a: {b: c}",
- &struct{ A *map[string]string }{&map[string]string{"b": "c"}},
- }, {
- "a:",
- &struct{ A map[string]string }{},
- }, {
- "a: 1",
- &struct{ A int }{1},
- }, {
- "a: 1",
- &struct{ A float64 }{1},
- }, {
- "a: 1.0",
- &struct{ A int }{1},
- }, {
- "a: 1.0",
- &struct{ A uint }{1},
- }, {
- "a: [1, 2]",
- &struct{ A []int }{[]int{1, 2}},
- }, {
- "a: [1, 2]",
- &struct{ A [2]int }{[2]int{1, 2}},
- }, {
- "a: 1",
- &struct{ B int }{0},
- }, {
- "a: 1",
- &struct {
- B int "a"
- }{1},
- }, {
- // Some limited backwards compatibility with the 1.1 spec.
- "a: YES",
- &struct{ A bool }{true},
- },
-
- // Some cross type conversions
- {
- "v: 42",
- map[string]uint{"v": 42},
- }, {
- "v: -42",
- map[string]uint{},
- }, {
- "v: 4294967296",
- map[string]uint64{"v": 4294967296},
- }, {
- "v: -4294967296",
- map[string]uint64{},
- },
-
- // int
- {
- "int_max: 2147483647",
- map[string]int{"int_max": math.MaxInt32},
- },
- {
- "int_min: -2147483648",
- map[string]int{"int_min": math.MinInt32},
- },
- {
- "int_overflow: 9223372036854775808", // math.MaxInt64 + 1
- map[string]int{},
- },
-
- // int64
- {
- "int64_max: 9223372036854775807",
- map[string]int64{"int64_max": math.MaxInt64},
- },
- {
- "int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
- map[string]int64{"int64_max_base2": math.MaxInt64},
- },
- {
- "int64_min: -9223372036854775808",
- map[string]int64{"int64_min": math.MinInt64},
- },
- {
- "int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
- map[string]int64{"int64_neg_base2": -math.MaxInt64},
- },
- {
- "int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
- map[string]int64{},
- },
-
- // uint
- {
- "uint_min: 0",
- map[string]uint{"uint_min": 0},
- },
- {
- "uint_max: 4294967295",
- map[string]uint{"uint_max": math.MaxUint32},
- },
- {
- "uint_underflow: -1",
- map[string]uint{},
- },
-
- // uint64
- {
- "uint64_min: 0",
- map[string]uint{"uint64_min": 0},
- },
- {
- "uint64_max: 18446744073709551615",
- map[string]uint64{"uint64_max": math.MaxUint64},
- },
- {
- "uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
- map[string]uint64{"uint64_max_base2": math.MaxUint64},
- },
- {
- "uint64_maxint64: 9223372036854775807",
- map[string]uint64{"uint64_maxint64": math.MaxInt64},
- },
- {
- "uint64_underflow: -1",
- map[string]uint64{},
- },
-
- // float32
- {
- "float32_max: 3.40282346638528859811704183484516925440e+38",
- map[string]float32{"float32_max": math.MaxFloat32},
- },
- {
- "float32_nonzero: 1.401298464324817070923729583289916131280e-45",
- map[string]float32{"float32_nonzero": math.SmallestNonzeroFloat32},
- },
- {
- "float32_maxuint64: 18446744073709551615",
- map[string]float32{"float32_maxuint64": float32(math.MaxUint64)},
- },
- {
- "float32_maxuint64+1: 18446744073709551616",
- map[string]float32{"float32_maxuint64+1": float32(math.MaxUint64 + 1)},
- },
-
- // float64
- {
- "float64_max: 1.797693134862315708145274237317043567981e+308",
- map[string]float64{"float64_max": math.MaxFloat64},
- },
- {
- "float64_nonzero: 4.940656458412465441765687928682213723651e-324",
- map[string]float64{"float64_nonzero": math.SmallestNonzeroFloat64},
- },
- {
- "float64_maxuint64: 18446744073709551615",
- map[string]float64{"float64_maxuint64": float64(math.MaxUint64)},
- },
- {
- "float64_maxuint64+1: 18446744073709551616",
- map[string]float64{"float64_maxuint64+1": float64(math.MaxUint64 + 1)},
- },
-
- // Overflow cases.
- {
- "v: 4294967297",
- map[string]int32{},
- }, {
- "v: 128",
- map[string]int8{},
- },
-
- // Quoted values.
- {
- "'1': '\"2\"'",
- map[interface{}]interface{}{"1": "\"2\""},
- }, {
- "v:\n- A\n- 'B\n\n C'\n",
- map[string][]string{"v": []string{"A", "B\nC"}},
- },
-
- // Explicit tags.
- {
- "v: !!float '1.1'",
- map[string]interface{}{"v": 1.1},
- }, {
- "v: !!float 0",
- map[string]interface{}{"v": float64(0)},
- }, {
- "v: !!float -1",
- map[string]interface{}{"v": float64(-1)},
- }, {
- "v: !!null ''",
- map[string]interface{}{"v": nil},
- }, {
- "%TAG !y! tag:yaml.org,2002:\n---\nv: !y!int '1'",
- map[string]interface{}{"v": 1},
- },
-
- // Non-specific tag (Issue #75)
- {
- "v: ! test",
- map[string]interface{}{"v": "test"},
- },
-
- // Anchors and aliases.
- {
- "a: &x 1\nb: &y 2\nc: *x\nd: *y\n",
- &struct{ A, B, C, D int }{1, 2, 1, 2},
- }, {
- "a: &a {c: 1}\nb: *a",
- &struct {
- A, B struct {
- C int
- }
- }{struct{ C int }{1}, struct{ C int }{1}},
- }, {
- "a: &a [1, 2]\nb: *a",
- &struct{ B []int }{[]int{1, 2}},
- },
-
- // Bug #1133337
- {
- "foo: ''",
- map[string]*string{"foo": new(string)},
- }, {
- "foo: null",
- map[string]*string{"foo": nil},
- }, {
- "foo: null",
- map[string]string{"foo": ""},
- }, {
- "foo: null",
- map[string]interface{}{"foo": nil},
- },
-
- // Support for ~
- {
- "foo: ~",
- map[string]*string{"foo": nil},
- }, {
- "foo: ~",
- map[string]string{"foo": ""},
- }, {
- "foo: ~",
- map[string]interface{}{"foo": nil},
- },
-
- // Ignored field
- {
- "a: 1\nb: 2\n",
- &struct {
- A int
- B int "-"
- }{1, 0},
- },
-
- // Bug #1191981
- {
- "" +
- "%YAML 1.1\n" +
- "--- !!str\n" +
- `"Generic line break (no glyph)\n\` + "\n" +
- ` Generic line break (glyphed)\n\` + "\n" +
- ` Line separator\u2028\` + "\n" +
- ` Paragraph separator\u2029"` + "\n",
- "" +
- "Generic line break (no glyph)\n" +
- "Generic line break (glyphed)\n" +
- "Line separator\u2028Paragraph separator\u2029",
- },
-
- // Struct inlining
- {
- "a: 1\nb: 2\nc: 3\n",
- &struct {
- A int
- C inlineB `yaml:",inline"`
- }{1, inlineB{2, inlineC{3}}},
- },
-
- // Struct inlining as a pointer.
- {
- "a: 1\nb: 2\nc: 3\n",
- &struct {
- A int
- C *inlineB `yaml:",inline"`
- }{1, &inlineB{2, inlineC{3}}},
- }, {
- "a: 1\n",
- &struct {
- A int
- C *inlineB `yaml:",inline"`
- }{1, nil},
- }, {
- "a: 1\nc: 3\nd: 4\n",
- &struct {
- A int
- C *inlineD `yaml:",inline"`
- }{1, &inlineD{&inlineC{3}, 4}},
- },
-
- // Map inlining
- {
- "a: 1\nb: 2\nc: 3\n",
- &struct {
- A int
- C map[string]int `yaml:",inline"`
- }{1, map[string]int{"b": 2, "c": 3}},
- },
-
- // bug 1243827
- {
- "a: -b_c",
- map[string]interface{}{"a": "-b_c"},
- },
- {
- "a: +b_c",
- map[string]interface{}{"a": "+b_c"},
- },
- {
- "a: 50cent_of_dollar",
- map[string]interface{}{"a": "50cent_of_dollar"},
- },
-
- // issue #295 (allow scalars with colons in flow mappings and sequences)
- {
- "a: {b: https://github.com/go-yaml/yaml}",
- map[string]interface{}{"a": map[string]interface{}{
- "b": "https://github.com/go-yaml/yaml",
- }},
- },
- {
- "a: [https://github.com/go-yaml/yaml]",
- map[string]interface{}{"a": []interface{}{"https://github.com/go-yaml/yaml"}},
- },
-
- // Duration
- {
- "a: 3s",
- map[string]time.Duration{"a": 3 * time.Second},
- },
-
- // Issue #24.
- {
- "a: <foo>",
- map[string]string{"a": "<foo>"},
- },
-
- // Base 60 floats are obsolete and unsupported.
- {
- "a: 1:1\n",
- map[string]string{"a": "1:1"},
- },
-
- // Binary data.
- {
- "a: !!binary gIGC\n",
- map[string]string{"a": "\x80\x81\x82"},
- }, {
- "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
- map[string]string{"a": strings.Repeat("\x90", 54)},
- }, {
- "a: !!binary |\n " + strings.Repeat("A", 70) + "\n ==\n",
- map[string]string{"a": strings.Repeat("\x00", 52)},
- },
-
- // Issue #39.
- {
- "a:\n b:\n c: d\n",
- map[string]struct{ B interface{} }{"a": {map[string]interface{}{"c": "d"}}},
- },
-
- // Custom map type.
- {
- "a: {b: c}",
- M{"a": M{"b": "c"}},
- },
-
- // Support encoding.TextUnmarshaler.
- {
- "a: 1.2.3.4\n",
- map[string]textUnmarshaler{"a": textUnmarshaler{S: "1.2.3.4"}},
- },
- {
- "a: 2015-02-24T18:19:39Z\n",
- map[string]textUnmarshaler{"a": textUnmarshaler{"2015-02-24T18:19:39Z"}},
- },
-
- // Timestamps
- {
- // Date only.
- "a: 2015-01-01\n",
- map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
- },
- {
- // RFC3339
- "a: 2015-02-24T18:19:39.12Z\n",
- map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, .12e9, time.UTC)},
- },
- {
- // RFC3339 with short dates.
- "a: 2015-2-3T3:4:5Z",
- map[string]time.Time{"a": time.Date(2015, 2, 3, 3, 4, 5, 0, time.UTC)},
- },
- {
- // ISO8601 lower case t
- "a: 2015-02-24t18:19:39Z\n",
- map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
- },
- {
- // space separate, no time zone
- "a: 2015-02-24 18:19:39\n",
- map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
- },
- // Some cases not currently handled. Uncomment these when
- // the code is fixed.
- // {
- // // space separated with time zone
- // "a: 2001-12-14 21:59:43.10 -5",
- // map[string]interface{}{"a": time.Date(2001, 12, 14, 21, 59, 43, .1e9, time.UTC)},
- // },
- // {
- // // arbitrary whitespace between fields
- // "a: 2001-12-14 \t\t \t21:59:43.10 \t Z",
- // map[string]interface{}{"a": time.Date(2001, 12, 14, 21, 59, 43, .1e9, time.UTC)},
- // },
- {
- // explicit string tag
- "a: !!str 2015-01-01",
- map[string]interface{}{"a": "2015-01-01"},
- },
- {
- // explicit timestamp tag on quoted string
- "a: !!timestamp \"2015-01-01\"",
- map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
- },
- {
- // explicit timestamp tag on unquoted string
- "a: !!timestamp 2015-01-01",
- map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
- },
- {
- // quoted string that's a valid timestamp
- "a: \"2015-01-01\"",
- map[string]interface{}{"a": "2015-01-01"},
- },
- {
- // explicit timestamp tag into interface.
- "a: !!timestamp \"2015-01-01\"",
- map[string]interface{}{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
- },
- {
- // implicit timestamp tag into interface.
- "a: 2015-01-01",
- map[string]interface{}{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
- },
-
- // Encode empty lists as zero-length slices.
- {
- "a: []",
- &struct{ A []int }{[]int{}},
- },
-
- // UTF-16-LE
- {
- "\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n\x00",
- M{"ñoño": "very yes"},
- },
- // UTF-16-LE with surrogate.
- {
- "\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \x00=\xd8\xd4\xdf\n\x00",
- M{"ñoño": "very yes 🟔"},
- },
-
- // UTF-16-BE
- {
- "\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n",
- M{"ñoño": "very yes"},
- },
- // UTF-16-BE with surrogate.
- {
- "\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \xd8=\xdf\xd4\x00\n",
- M{"ñoño": "very yes 🟔"},
- },
-
- // This *is* in fact a float number, per the spec. #171 was a mistake.
- {
- "a: 123456e1\n",
- M{"a": 123456e1},
- }, {
- "a: 123456E1\n",
- M{"a": 123456e1},
- },
- // yaml-test-suite 3GZX: Spec Example 7.1. Alias Nodes
- {
- "First occurrence: &anchor Foo\nSecond occurrence: *anchor\nOverride anchor: &anchor Bar\nReuse anchor: *anchor\n",
- map[string]interface{}{
- "First occurrence": "Foo",
- "Second occurrence": "Foo",
- "Override anchor": "Bar",
- "Reuse anchor": "Bar",
- },
- },
- // Single document with garbage following it.
- {
- "---\nhello\n...\n}not yaml",
- "hello",
- },
-
- // Comment scan exhausting the input buffer (issue #469).
- {
- "true\n#" + strings.Repeat(" ", 512*3),
- "true",
- }, {
- "true #" + strings.Repeat(" ", 512*3),
- "true",
- },
-
- // CRLF
- {
- "a: b\r\nc:\r\n- d\r\n- e\r\n",
- map[string]interface{}{
- "a": "b",
- "c": []interface{}{"d", "e"},
- },
- },
-}
-
-type M map[string]interface{}
-
-type inlineB struct {
- B int
- inlineC `yaml:",inline"`
-}
-
-type inlineC struct {
- C int
-}
-
-type inlineD struct {
- C *inlineC `yaml:",inline"`
- D int
-}
-
-func (s *S) TestUnmarshal(c *C) {
- for i, item := range unmarshalTests {
- c.Logf("test %d: %q", i, item.data)
- t := reflect.ValueOf(item.value).Type()
- value := reflect.New(t)
- err := yaml.Unmarshal([]byte(item.data), value.Interface())
- if _, ok := err.(*yaml.TypeError); !ok {
- c.Assert(err, IsNil)
- }
- c.Assert(value.Elem().Interface(), DeepEquals, item.value, Commentf("error: %v", err))
- }
-}
-
-func (s *S) TestUnmarshalFullTimestamp(c *C) {
- // Full timestamp in same format as encoded. This is confirmed to be
- // properly decoded by Python as a timestamp as well.
- var str = "2015-02-24T18:19:39.123456789-03:00"
- var t interface{}
- err := yaml.Unmarshal([]byte(str), &t)
- c.Assert(err, IsNil)
- c.Assert(t, Equals, time.Date(2015, 2, 24, 18, 19, 39, 123456789, t.(time.Time).Location()))
- c.Assert(t.(time.Time).In(time.UTC), Equals, time.Date(2015, 2, 24, 21, 19, 39, 123456789, time.UTC))
-}
-
-func (s *S) TestDecoderSingleDocument(c *C) {
- // Test that Decoder.Decode works as expected on
- // all the unmarshal tests.
- for i, item := range unmarshalTests {
- c.Logf("test %d: %q", i, item.data)
- if item.data == "" {
- // Behaviour differs when there's no YAML.
- continue
- }
- t := reflect.ValueOf(item.value).Type()
- value := reflect.New(t)
- err := yaml.NewDecoder(strings.NewReader(item.data)).Decode(value.Interface())
- if _, ok := err.(*yaml.TypeError); !ok {
- c.Assert(err, IsNil)
- }
- c.Assert(value.Elem().Interface(), DeepEquals, item.value)
- }
-}
-
-var decoderTests = []struct {
- data string
- values []interface{}
-}{{
- "",
- nil,
-}, {
- "a: b",
- []interface{}{
- map[string]interface{}{"a": "b"},
- },
-}, {
- "---\na: b\n...\n",
- []interface{}{
- map[string]interface{}{"a": "b"},
- },
-}, {
- "---\n'hello'\n...\n---\ngoodbye\n...\n",
- []interface{}{
- "hello",
- "goodbye",
- },
-}}
-
-func (s *S) TestDecoder(c *C) {
- for i, item := range decoderTests {
- c.Logf("test %d: %q", i, item.data)
- var values []interface{}
- dec := yaml.NewDecoder(strings.NewReader(item.data))
- for {
- var value interface{}
- err := dec.Decode(&value)
- if err == io.EOF {
- break
- }
- c.Assert(err, IsNil)
- values = append(values, value)
- }
- c.Assert(values, DeepEquals, item.values)
- }
-}
-
-type errReader struct{}
-
-func (errReader) Read([]byte) (int, error) {
- return 0, errors.New("some read error")
-}
-
-func (s *S) TestDecoderReadError(c *C) {
- err := yaml.NewDecoder(errReader{}).Decode(&struct{}{})
- c.Assert(err, ErrorMatches, `yaml: input error: some read error`)
-}
-
-func (s *S) TestUnmarshalNaN(c *C) {
- value := map[string]interface{}{}
- err := yaml.Unmarshal([]byte("notanum: .NaN"), &value)
- c.Assert(err, IsNil)
- c.Assert(math.IsNaN(value["notanum"].(float64)), Equals, true)
-}
-
-func (s *S) TestUnmarshalDurationInt(c *C) {
- // Don't accept plain ints as durations as it's unclear (issue #200).
- var d time.Duration
- err := yaml.Unmarshal([]byte("123"), &d)
- c.Assert(err, ErrorMatches, "(?s).* line 1: cannot unmarshal !!int `123` into time.Duration")
-}
-
-var unmarshalErrorTests = []struct {
- data, error string
-}{
- {"v: !!float 'error'", "yaml: cannot decode !!str `error` as a !!float"},
- {"v: [A,", "yaml: line 1: did not find expected node content"},
- {"v:\n- [A,", "yaml: line 2: did not find expected node content"},
- {"a:\n- b: *,", "yaml: line 2: did not find expected alphabetic or numeric character"},
- {"a: *b\n", "yaml: unknown anchor 'b' referenced"},
- {"a: &a\n b: *a\n", "yaml: anchor 'a' value contains itself"},
- {"value: -", "yaml: block sequence entries are not allowed in this context"},
- {"a: !!binary ==", "yaml: !!binary value contains invalid base64 data"},
- {"{[.]}", `yaml: invalid map key: \[\]interface \{\}\{"\."\}`},
- {"{{.}}", `yaml: invalid map key: map\[string]interface \{\}\{".":interface \{\}\(nil\)\}`},
- {"b: *a\na: &a {c: 1}", `yaml: unknown anchor 'a' referenced`},
- {"%TAG !%79! tag:yaml.org,2002:\n---\nv: !%79!int '1'", "yaml: did not find expected whitespace"},
- {"a:\n 1:\nb\n 2:", ".*could not find expected ':'"},
- {"a: 1\nb: 2\nc 2\nd: 3\n", "^yaml: line 3: could not find expected ':'$"},
- {"#\n-\n{", "yaml: line 3: could not find expected ':'"}, // Issue #665
- {"0: [:!00 \xef", "yaml: incomplete UTF-8 octet sequence"}, // Issue #666
- {
- "a: &a [00,00,00,00,00,00,00,00,00]\n" +
- "b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]\n" +
- "c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]\n" +
- "d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]\n" +
- "e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]\n" +
- "f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]\n" +
- "g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]\n" +
- "h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]\n" +
- "i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]\n",
- "yaml: document contains excessive aliasing",
- },
-}
-
-func (s *S) TestUnmarshalErrors(c *C) {
- for i, item := range unmarshalErrorTests {
- c.Logf("test %d: %q", i, item.data)
- var value interface{}
- err := yaml.Unmarshal([]byte(item.data), &value)
- c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value))
- }
-}
-
-func (s *S) TestDecoderErrors(c *C) {
- for _, item := range unmarshalErrorTests {
- var value interface{}
- err := yaml.NewDecoder(strings.NewReader(item.data)).Decode(&value)
- c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value))
- }
-}
-
-var unmarshalerTests = []struct {
- data, tag string
- value interface{}
-}{
- {"_: {hi: there}", "!!map", map[string]interface{}{"hi": "there"}},
- {"_: [1,A]", "!!seq", []interface{}{1, "A"}},
- {"_: 10", "!!int", 10},
- {"_: null", "!!null", nil},
- {`_: BAR!`, "!!str", "BAR!"},
- {`_: "BAR!"`, "!!str", "BAR!"},
- {"_: !!foo 'BAR!'", "!!foo", "BAR!"},
- {`_: ""`, "!!str", ""},
-}
-
-var unmarshalerResult = map[int]error{}
-
-type unmarshalerType struct {
- value interface{}
-}
-
-func (o *unmarshalerType) UnmarshalYAML(value *yaml.Node) error {
- if err := value.Decode(&o.value); err != nil {
- return err
- }
- if i, ok := o.value.(int); ok {
- if result, ok := unmarshalerResult[i]; ok {
- return result
- }
- }
- return nil
-}
-
-type unmarshalerPointer struct {
- Field *unmarshalerType "_"
-}
-
-type unmarshalerValue struct {
- Field unmarshalerType "_"
-}
-
-type unmarshalerInlined struct {
- Field *unmarshalerType "_"
- Inlined unmarshalerType `yaml:",inline"`
-}
-
-type unmarshalerInlinedTwice struct {
- InlinedTwice unmarshalerInlined `yaml:",inline"`
-}
-
-type obsoleteUnmarshalerType struct {
- value interface{}
-}
-
-func (o *obsoleteUnmarshalerType) UnmarshalYAML(unmarshal func(v interface{}) error) error {
- if err := unmarshal(&o.value); err != nil {
- return err
- }
- if i, ok := o.value.(int); ok {
- if result, ok := unmarshalerResult[i]; ok {
- return result
- }
- }
- return nil
-}
-
-type obsoleteUnmarshalerPointer struct {
- Field *obsoleteUnmarshalerType "_"
-}
-
-type obsoleteUnmarshalerValue struct {
- Field obsoleteUnmarshalerType "_"
-}
-
-func (s *S) TestUnmarshalerPointerField(c *C) {
- for _, item := range unmarshalerTests {
- obj := &unmarshalerPointer{}
- err := yaml.Unmarshal([]byte(item.data), obj)
- c.Assert(err, IsNil)
- if item.value == nil {
- c.Assert(obj.Field, IsNil)
- } else {
- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
- c.Assert(obj.Field.value, DeepEquals, item.value)
- }
- }
- for _, item := range unmarshalerTests {
- obj := &obsoleteUnmarshalerPointer{}
- err := yaml.Unmarshal([]byte(item.data), obj)
- c.Assert(err, IsNil)
- if item.value == nil {
- c.Assert(obj.Field, IsNil)
- } else {
- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
- c.Assert(obj.Field.value, DeepEquals, item.value)
- }
- }
-}
-
-func (s *S) TestUnmarshalerValueField(c *C) {
- for _, item := range unmarshalerTests {
- obj := &obsoleteUnmarshalerValue{}
- err := yaml.Unmarshal([]byte(item.data), obj)
- c.Assert(err, IsNil)
- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
- c.Assert(obj.Field.value, DeepEquals, item.value)
- }
-}
-
-func (s *S) TestUnmarshalerInlinedField(c *C) {
- obj := &unmarshalerInlined{}
- err := yaml.Unmarshal([]byte("_: a\ninlined: b\n"), obj)
- c.Assert(err, IsNil)
- c.Assert(obj.Field, DeepEquals, &unmarshalerType{"a"})
- c.Assert(obj.Inlined, DeepEquals, unmarshalerType{map[string]interface{}{"_": "a", "inlined": "b"}})
-
- twc := &unmarshalerInlinedTwice{}
- err = yaml.Unmarshal([]byte("_: a\ninlined: b\n"), twc)
- c.Assert(err, IsNil)
- c.Assert(twc.InlinedTwice.Field, DeepEquals, &unmarshalerType{"a"})
- c.Assert(twc.InlinedTwice.Inlined, DeepEquals, unmarshalerType{map[string]interface{}{"_": "a", "inlined": "b"}})
-}
-
-func (s *S) TestUnmarshalerWholeDocument(c *C) {
- obj := &obsoleteUnmarshalerType{}
- err := yaml.Unmarshal([]byte(unmarshalerTests[0].data), obj)
- c.Assert(err, IsNil)
- value, ok := obj.value.(map[string]interface{})
- c.Assert(ok, Equals, true, Commentf("value: %#v", obj.value))
- c.Assert(value["_"], DeepEquals, unmarshalerTests[0].value)
-}
-
-func (s *S) TestUnmarshalerTypeError(c *C) {
- unmarshalerResult[2] = &yaml.TypeError{[]string{"foo"}}
- unmarshalerResult[4] = &yaml.TypeError{[]string{"bar"}}
- defer func() {
- delete(unmarshalerResult, 2)
- delete(unmarshalerResult, 4)
- }()
-
- type T struct {
- Before int
- After int
- M map[string]*unmarshalerType
- }
- var v T
- data := `{before: A, m: {abc: 1, def: 2, ghi: 3, jkl: 4}, after: B}`
- err := yaml.Unmarshal([]byte(data), &v)
- c.Assert(err, ErrorMatches, ""+
- "yaml: unmarshal errors:\n"+
- " line 1: cannot unmarshal !!str `A` into int\n"+
- " foo\n"+
- " bar\n"+
- " line 1: cannot unmarshal !!str `B` into int")
- c.Assert(v.M["abc"], NotNil)
- c.Assert(v.M["def"], IsNil)
- c.Assert(v.M["ghi"], NotNil)
- c.Assert(v.M["jkl"], IsNil)
-
- c.Assert(v.M["abc"].value, Equals, 1)
- c.Assert(v.M["ghi"].value, Equals, 3)
-}
-
-func (s *S) TestObsoleteUnmarshalerTypeError(c *C) {
- unmarshalerResult[2] = &yaml.TypeError{[]string{"foo"}}
- unmarshalerResult[4] = &yaml.TypeError{[]string{"bar"}}
- defer func() {
- delete(unmarshalerResult, 2)
- delete(unmarshalerResult, 4)
- }()
-
- type T struct {
- Before int
- After int
- M map[string]*obsoleteUnmarshalerType
- }
- var v T
- data := `{before: A, m: {abc: 1, def: 2, ghi: 3, jkl: 4}, after: B}`
- err := yaml.Unmarshal([]byte(data), &v)
- c.Assert(err, ErrorMatches, ""+
- "yaml: unmarshal errors:\n"+
- " line 1: cannot unmarshal !!str `A` into int\n"+
- " foo\n"+
- " bar\n"+
- " line 1: cannot unmarshal !!str `B` into int")
- c.Assert(v.M["abc"], NotNil)
- c.Assert(v.M["def"], IsNil)
- c.Assert(v.M["ghi"], NotNil)
- c.Assert(v.M["jkl"], IsNil)
-
- c.Assert(v.M["abc"].value, Equals, 1)
- c.Assert(v.M["ghi"].value, Equals, 3)
-}
-
-type proxyTypeError struct{}
-
-func (v *proxyTypeError) UnmarshalYAML(node *yaml.Node) error {
- var s string
- var a int32
- var b int64
- if err := node.Decode(&s); err != nil {
- panic(err)
- }
- if s == "a" {
- if err := node.Decode(&b); err == nil {
- panic("should have failed")
- }
- return node.Decode(&a)
- }
- if err := node.Decode(&a); err == nil {
- panic("should have failed")
- }
- return node.Decode(&b)
-}
-
-func (s *S) TestUnmarshalerTypeErrorProxying(c *C) {
- type T struct {
- Before int
- After int
- M map[string]*proxyTypeError
- }
- var v T
- data := `{before: A, m: {abc: a, def: b}, after: B}`
- err := yaml.Unmarshal([]byte(data), &v)
- c.Assert(err, ErrorMatches, ""+
- "yaml: unmarshal errors:\n"+
- " line 1: cannot unmarshal !!str `A` into int\n"+
- " line 1: cannot unmarshal !!str `a` into int32\n"+
- " line 1: cannot unmarshal !!str `b` into int64\n"+
- " line 1: cannot unmarshal !!str `B` into int")
-}
-
-type obsoleteProxyTypeError struct{}
-
-func (v *obsoleteProxyTypeError) UnmarshalYAML(unmarshal func(interface{}) error) error {
- var s string
- var a int32
- var b int64
- if err := unmarshal(&s); err != nil {
- panic(err)
- }
- if s == "a" {
- if err := unmarshal(&b); err == nil {
- panic("should have failed")
- }
- return unmarshal(&a)
- }
- if err := unmarshal(&a); err == nil {
- panic("should have failed")
- }
- return unmarshal(&b)
-}
-
-func (s *S) TestObsoleteUnmarshalerTypeErrorProxying(c *C) {
- type T struct {
- Before int
- After int
- M map[string]*obsoleteProxyTypeError
- }
- var v T
- data := `{before: A, m: {abc: a, def: b}, after: B}`
- err := yaml.Unmarshal([]byte(data), &v)
- c.Assert(err, ErrorMatches, ""+
- "yaml: unmarshal errors:\n"+
- " line 1: cannot unmarshal !!str `A` into int\n"+
- " line 1: cannot unmarshal !!str `a` into int32\n"+
- " line 1: cannot unmarshal !!str `b` into int64\n"+
- " line 1: cannot unmarshal !!str `B` into int")
-}
-
-var failingErr = errors.New("failingErr")
-
-type failingUnmarshaler struct{}
-
-func (ft *failingUnmarshaler) UnmarshalYAML(node *yaml.Node) error {
- return failingErr
-}
-
-func (s *S) TestUnmarshalerError(c *C) {
- err := yaml.Unmarshal([]byte("a: b"), &failingUnmarshaler{})
- c.Assert(err, Equals, failingErr)
-}
-
-type obsoleteFailingUnmarshaler struct{}
-
-func (ft *obsoleteFailingUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
- return failingErr
-}
-
-func (s *S) TestObsoleteUnmarshalerError(c *C) {
- err := yaml.Unmarshal([]byte("a: b"), &obsoleteFailingUnmarshaler{})
- c.Assert(err, Equals, failingErr)
-}
-
-type sliceUnmarshaler []int
-
-func (su *sliceUnmarshaler) UnmarshalYAML(node *yaml.Node) error {
- var slice []int
- err := node.Decode(&slice)
- if err == nil {
- *su = slice
- return nil
- }
-
- var intVal int
- err = node.Decode(&intVal)
- if err == nil {
- *su = []int{intVal}
- return nil
- }
-
- return err
-}
-
-func (s *S) TestUnmarshalerRetry(c *C) {
- var su sliceUnmarshaler
- err := yaml.Unmarshal([]byte("[1, 2, 3]"), &su)
- c.Assert(err, IsNil)
- c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1, 2, 3}))
-
- err = yaml.Unmarshal([]byte("1"), &su)
- c.Assert(err, IsNil)
- c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1}))
-}
-
-type obsoleteSliceUnmarshaler []int
-
-func (su *obsoleteSliceUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
- var slice []int
- err := unmarshal(&slice)
- if err == nil {
- *su = slice
- return nil
- }
-
- var intVal int
- err = unmarshal(&intVal)
- if err == nil {
- *su = []int{intVal}
- return nil
- }
-
- return err
-}
-
-func (s *S) TestObsoleteUnmarshalerRetry(c *C) {
- var su obsoleteSliceUnmarshaler
- err := yaml.Unmarshal([]byte("[1, 2, 3]"), &su)
- c.Assert(err, IsNil)
- c.Assert(su, DeepEquals, obsoleteSliceUnmarshaler([]int{1, 2, 3}))
-
- err = yaml.Unmarshal([]byte("1"), &su)
- c.Assert(err, IsNil)
- c.Assert(su, DeepEquals, obsoleteSliceUnmarshaler([]int{1}))
-}
-
-// From http://yaml.org/type/merge.html
-var mergeTests = `
-anchors:
- list:
- - &CENTER { "x": 1, "y": 2 }
- - &LEFT { "x": 0, "y": 2 }
- - &BIG { "r": 10 }
- - &SMALL { "r": 1 }
-
-# All the following maps are equal:
-
-plain:
- # Explicit keys
- "x": 1
- "y": 2
- "r": 10
- label: center/big
-
-mergeOne:
- # Merge one map
- << : *CENTER
- "r": 10
- label: center/big
-
-mergeMultiple:
- # Merge multiple maps
- << : [ *CENTER, *BIG ]
- label: center/big
-
-override:
- # Override
- << : [ *BIG, *LEFT, *SMALL ]
- "x": 1
- label: center/big
-
-shortTag:
- # Explicit short merge tag
- !!merge "<<" : [ *CENTER, *BIG ]
- label: center/big
-
-longTag:
- # Explicit merge long tag
- !<tag:yaml.org,2002:merge> "<<" : [ *CENTER, *BIG ]
- label: center/big
-
-inlineMap:
- # Inlined map
- << : {"x": 1, "y": 2, "r": 10}
- label: center/big
-
-inlineSequenceMap:
- # Inlined map in sequence
- << : [ *CENTER, {"r": 10} ]
- label: center/big
-`
-
-func (s *S) TestMerge(c *C) {
- var want = map[string]interface{}{
- "x": 1,
- "y": 2,
- "r": 10,
- "label": "center/big",
- }
-
- wantStringMap := make(map[string]interface{})
- for k, v := range want {
- wantStringMap[fmt.Sprintf("%v", k)] = v
- }
-
- var m map[interface{}]interface{}
- err := yaml.Unmarshal([]byte(mergeTests), &m)
- c.Assert(err, IsNil)
- for name, test := range m {
- if name == "anchors" {
- continue
- }
- if name == "plain" {
- c.Assert(test, DeepEquals, wantStringMap, Commentf("test %q failed", name))
- continue
- }
- c.Assert(test, DeepEquals, want, Commentf("test %q failed", name))
- }
-}
-
-func (s *S) TestMergeStruct(c *C) {
- type Data struct {
- X, Y, R int
- Label string
- }
- want := Data{1, 2, 10, "center/big"}
-
- var m map[string]Data
- err := yaml.Unmarshal([]byte(mergeTests), &m)
- c.Assert(err, IsNil)
- for name, test := range m {
- if name == "anchors" {
- continue
- }
- c.Assert(test, Equals, want, Commentf("test %q failed", name))
- }
-}
-
-var mergeTestsNested = `
-mergeouter1: &mergeouter1
- d: 40
- e: 50
-
-mergeouter2: &mergeouter2
- e: 5
- f: 6
- g: 70
-
-mergeinner1: &mergeinner1
- <<: *mergeouter1
- inner:
- a: 1
- b: 2
-
-mergeinner2: &mergeinner2
- <<: *mergeouter2
- inner:
- a: -1
- b: -2
-
-outer:
- <<: [*mergeinner1, *mergeinner2]
- f: 60
- inner:
- a: 10
-`
-
-func (s *S) TestMergeNestedStruct(c *C) {
- // Issue #818: Merging used to just unmarshal twice on the target
- // value, which worked for maps as these were replaced by the new map,
- // but not on struct values as these are preserved. This resulted in
- // the nested data from the merged map to be mixed up with the data
- // from the map being merged into.
- //
- // This test also prevents two potential bugs from showing up:
- //
- // 1) A simple implementation might just zero out the nested value
- // before unmarshaling the second time, but this would clobber previous
- // data that is usually respected ({C: 30} below).
- //
- // 2) A simple implementation might attempt to handle the key skipping
- // directly by iterating over the merging map without recursion, but
- // there are more complex cases that require recursion.
- //
- // Quick summary of the fields:
- //
- // - A must come from outer and not overriden
- // - B must not be set as its in the ignored merge
- // - C should still be set as it's preset in the value
- // - D should be set from the recursive merge
- // - E should be set from the first recursive merge, ignored on the second
- // - F should be set in the inlined map from outer, ignored later
- // - G should be set in the inlined map from the second recursive merge
- //
-
- type Inner struct {
- A, B, C int
- }
- type Outer struct {
- D, E int
- Inner Inner
- Inline map[string]int `yaml:",inline"`
- }
- type Data struct {
- Outer Outer
- }
-
- test := Data{Outer{0, 0, Inner{C: 30}, nil}}
- want := Data{Outer{40, 50, Inner{A: 10, C: 30}, map[string]int{"f": 60, "g": 70}}}
-
- err := yaml.Unmarshal([]byte(mergeTestsNested), &test)
- c.Assert(err, IsNil)
- c.Assert(test, DeepEquals, want)
-
- // Repeat test with a map.
-
- var testm map[string]interface{}
- var wantm = map[string]interface {} {
- "f": 60,
- "inner": map[string]interface{}{
- "a": 10,
- },
- "d": 40,
- "e": 50,
- "g": 70,
- }
- err = yaml.Unmarshal([]byte(mergeTestsNested), &testm)
- c.Assert(err, IsNil)
- c.Assert(testm["outer"], DeepEquals, wantm)
-}
-
-var unmarshalNullTests = []struct {
- input string
- pristine, expected func() interface{}
-}{{
- "null",
- func() interface{} { var v interface{}; v = "v"; return &v },
- func() interface{} { var v interface{}; v = nil; return &v },
-}, {
- "null",
- func() interface{} { var s = "s"; return &s },
- func() interface{} { var s = "s"; return &s },
-}, {
- "null",
- func() interface{} { var s = "s"; sptr := &s; return &sptr },
- func() interface{} { var sptr *string; return &sptr },
-}, {
- "null",
- func() interface{} { var i = 1; return &i },
- func() interface{} { var i = 1; return &i },
-}, {
- "null",
- func() interface{} { var i = 1; iptr := &i; return &iptr },
- func() interface{} { var iptr *int; return &iptr },
-}, {
- "null",
- func() interface{} { var m = map[string]int{"s": 1}; return &m },
- func() interface{} { var m map[string]int; return &m },
-}, {
- "null",
- func() interface{} { var m = map[string]int{"s": 1}; return m },
- func() interface{} { var m = map[string]int{"s": 1}; return m },
-}, {
- "s2: null\ns3: null",
- func() interface{} { var m = map[string]int{"s1": 1, "s2": 2}; return m },
- func() interface{} { var m = map[string]int{"s1": 1, "s2": 2, "s3": 0}; return m },
-}, {
- "s2: null\ns3: null",
- func() interface{} { var m = map[string]interface{}{"s1": 1, "s2": 2}; return m },
- func() interface{} { var m = map[string]interface{}{"s1": 1, "s2": nil, "s3": nil}; return m },
-}}
-
-func (s *S) TestUnmarshalNull(c *C) {
- for _, test := range unmarshalNullTests {
- pristine := test.pristine()
- expected := test.expected()
- err := yaml.Unmarshal([]byte(test.input), pristine)
- c.Assert(err, IsNil)
- c.Assert(pristine, DeepEquals, expected)
- }
-}
-
-func (s *S) TestUnmarshalPreservesData(c *C) {
- var v struct {
- A, B int
- C int `yaml:"-"`
- }
- v.A = 42
- v.C = 88
- err := yaml.Unmarshal([]byte("---"), &v)
- c.Assert(err, IsNil)
- c.Assert(v.A, Equals, 42)
- c.Assert(v.B, Equals, 0)
- c.Assert(v.C, Equals, 88)
-
- err = yaml.Unmarshal([]byte("b: 21\nc: 99"), &v)
- c.Assert(err, IsNil)
- c.Assert(v.A, Equals, 42)
- c.Assert(v.B, Equals, 21)
- c.Assert(v.C, Equals, 88)
-}
-
-func (s *S) TestUnmarshalSliceOnPreset(c *C) {
- // Issue #48.
- v := struct{ A []int }{[]int{1}}
- yaml.Unmarshal([]byte("a: [2]"), &v)
- c.Assert(v.A, DeepEquals, []int{2})
-}
-
-var unmarshalStrictTests = []struct {
- known bool
- unique bool
- data string
- value interface{}
- error string
-}{{
- known: true,
- data: "a: 1\nc: 2\n",
- value: struct{ A, B int }{A: 1},
- error: `yaml: unmarshal errors:\n line 2: field c not found in type struct { A int; B int }`,
-}, {
- unique: true,
- data: "a: 1\nb: 2\na: 3\n",
- value: struct{ A, B int }{A: 3, B: 2},
- error: `yaml: unmarshal errors:\n line 3: mapping key "a" already defined at line 1`,
-}, {
- unique: true,
- data: "c: 3\na: 1\nb: 2\nc: 4\n",
- value: struct {
- A int
- inlineB `yaml:",inline"`
- }{
- A: 1,
- inlineB: inlineB{
- B: 2,
- inlineC: inlineC{
- C: 4,
- },
- },
- },
- error: `yaml: unmarshal errors:\n line 4: mapping key "c" already defined at line 1`,
-}, {
- unique: true,
- data: "c: 0\na: 1\nb: 2\nc: 1\n",
- value: struct {
- A int
- inlineB `yaml:",inline"`
- }{
- A: 1,
- inlineB: inlineB{
- B: 2,
- inlineC: inlineC{
- C: 1,
- },
- },
- },
- error: `yaml: unmarshal errors:\n line 4: mapping key "c" already defined at line 1`,
-}, {
- unique: true,
- data: "c: 1\na: 1\nb: 2\nc: 3\n",
- value: struct {
- A int
- M map[string]interface{} `yaml:",inline"`
- }{
- A: 1,
- M: map[string]interface{}{
- "b": 2,
- "c": 3,
- },
- },
- error: `yaml: unmarshal errors:\n line 4: mapping key "c" already defined at line 1`,
-}, {
- unique: true,
- data: "a: 1\n9: 2\nnull: 3\n9: 4",
- value: map[interface{}]interface{}{
- "a": 1,
- nil: 3,
- 9: 4,
- },
- error: `yaml: unmarshal errors:\n line 4: mapping key "9" already defined at line 2`,
-}}
-
-func (s *S) TestUnmarshalKnownFields(c *C) {
- for i, item := range unmarshalStrictTests {
- c.Logf("test %d: %q", i, item.data)
- // First test that normal Unmarshal unmarshals to the expected value.
- if !item.unique {
- t := reflect.ValueOf(item.value).Type()
- value := reflect.New(t)
- err := yaml.Unmarshal([]byte(item.data), value.Interface())
- c.Assert(err, Equals, nil)
- c.Assert(value.Elem().Interface(), DeepEquals, item.value)
- }
-
- // Then test that it fails on the same thing with KnownFields on.
- t := reflect.ValueOf(item.value).Type()
- value := reflect.New(t)
- dec := yaml.NewDecoder(bytes.NewBuffer([]byte(item.data)))
- dec.KnownFields(item.known)
- err := dec.Decode(value.Interface())
- c.Assert(err, ErrorMatches, item.error)
- }
-}
-
-type textUnmarshaler struct {
- S string
-}
-
-func (t *textUnmarshaler) UnmarshalText(s []byte) error {
- t.S = string(s)
- return nil
-}
-
-func (s *S) TestFuzzCrashers(c *C) {
- cases := []string{
- // runtime error: index out of range
- "\"\\0\\\r\n",
-
- // should not happen
- " 0: [\n] 0",
- "? ? \"\n\" 0",
- " - {\n000}0",
- "0:\n 0: [0\n] 0",
- " - \"\n000\"0",
- " - \"\n000\"\"",
- "0:\n - {\n000}0",
- "0:\n - \"\n000\"0",
- "0:\n - \"\n000\"\"",
-
- // runtime error: index out of range
- " \ufeff\n",
- "? \ufeff\n",
- "? \ufeff:\n",
- "0: \ufeff\n",
- "? \ufeff: \ufeff\n",
- }
- for _, data := range cases {
- var v interface{}
- _ = yaml.Unmarshal([]byte(data), &v)
- }
-}
-
-//var data []byte
-//func init() {
-// var err error
-// data, err = ioutil.ReadFile("/tmp/file.yaml")
-// if err != nil {
-// panic(err)
-// }
-//}
-//
-//func (s *S) BenchmarkUnmarshal(c *C) {
-// var err error
-// for i := 0; i < c.N; i++ {
-// var v map[string]interface{}
-// err = yaml.Unmarshal(data, &v)
-// }
-// if err != nil {
-// panic(err)
-// }
-//}
-//
-//func (s *S) BenchmarkMarshal(c *C) {
-// var v map[string]interface{}
-// yaml.Unmarshal(data, &v)
-// c.ResetTimer()
-// for i := 0; i < c.N; i++ {
-// yaml.Marshal(&v)
-// }
-//}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/emitterc.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/emitterc.go
deleted file mode 100644
index 0f47c9ca8addf8e9d2e454e02842927ae825d0e9..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/emitterc.go
+++ /dev/null
@@ -1,2020 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "bytes"
- "fmt"
-)
-
-// Flush the buffer if needed.
-func flush(emitter *yaml_emitter_t) bool {
- if emitter.buffer_pos+5 >= len(emitter.buffer) {
- return yaml_emitter_flush(emitter)
- }
- return true
-}
-
-// Put a character to the output buffer.
-func put(emitter *yaml_emitter_t, value byte) bool {
- if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
- return false
- }
- emitter.buffer[emitter.buffer_pos] = value
- emitter.buffer_pos++
- emitter.column++
- return true
-}
-
-// Put a line break to the output buffer.
-func put_break(emitter *yaml_emitter_t) bool {
- if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
- return false
- }
- switch emitter.line_break {
- case yaml_CR_BREAK:
- emitter.buffer[emitter.buffer_pos] = '\r'
- emitter.buffer_pos += 1
- case yaml_LN_BREAK:
- emitter.buffer[emitter.buffer_pos] = '\n'
- emitter.buffer_pos += 1
- case yaml_CRLN_BREAK:
- emitter.buffer[emitter.buffer_pos+0] = '\r'
- emitter.buffer[emitter.buffer_pos+1] = '\n'
- emitter.buffer_pos += 2
- default:
- panic("unknown line break setting")
- }
- if emitter.column == 0 {
- emitter.space_above = true
- }
- emitter.column = 0
- emitter.line++
- // [Go] Do this here and below and drop from everywhere else (see commented lines).
- emitter.indention = true
- return true
-}
-
-// Copy a character from a string into buffer.
-func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
- if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
- return false
- }
- p := emitter.buffer_pos
- w := width(s[*i])
- switch w {
- case 4:
- emitter.buffer[p+3] = s[*i+3]
- fallthrough
- case 3:
- emitter.buffer[p+2] = s[*i+2]
- fallthrough
- case 2:
- emitter.buffer[p+1] = s[*i+1]
- fallthrough
- case 1:
- emitter.buffer[p+0] = s[*i+0]
- default:
- panic("unknown character width")
- }
- emitter.column++
- emitter.buffer_pos += w
- *i += w
- return true
-}
-
-// Write a whole string into buffer.
-func write_all(emitter *yaml_emitter_t, s []byte) bool {
- for i := 0; i < len(s); {
- if !write(emitter, s, &i) {
- return false
- }
- }
- return true
-}
-
-// Copy a line break character from a string into buffer.
-func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
- if s[*i] == '\n' {
- if !put_break(emitter) {
- return false
- }
- *i++
- } else {
- if !write(emitter, s, i) {
- return false
- }
- if emitter.column == 0 {
- emitter.space_above = true
- }
- emitter.column = 0
- emitter.line++
- // [Go] Do this here and above and drop from everywhere else (see commented lines).
- emitter.indention = true
- }
- return true
-}
-
-// Set an emitter error and return false.
-func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
- emitter.error = yaml_EMITTER_ERROR
- emitter.problem = problem
- return false
-}
-
-// Emit an event.
-func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- emitter.events = append(emitter.events, *event)
- for !yaml_emitter_need_more_events(emitter) {
- event := &emitter.events[emitter.events_head]
- if !yaml_emitter_analyze_event(emitter, event) {
- return false
- }
- if !yaml_emitter_state_machine(emitter, event) {
- return false
- }
- yaml_event_delete(event)
- emitter.events_head++
- }
- return true
-}
-
-// Check if we need to accumulate more events before emitting.
-//
-// We accumulate extra
-// - 1 event for DOCUMENT-START
-// - 2 events for SEQUENCE-START
-// - 3 events for MAPPING-START
-//
-func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
- if emitter.events_head == len(emitter.events) {
- return true
- }
- var accumulate int
- switch emitter.events[emitter.events_head].typ {
- case yaml_DOCUMENT_START_EVENT:
- accumulate = 1
- break
- case yaml_SEQUENCE_START_EVENT:
- accumulate = 2
- break
- case yaml_MAPPING_START_EVENT:
- accumulate = 3
- break
- default:
- return false
- }
- if len(emitter.events)-emitter.events_head > accumulate {
- return false
- }
- var level int
- for i := emitter.events_head; i < len(emitter.events); i++ {
- switch emitter.events[i].typ {
- case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
- level++
- case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
- level--
- }
- if level == 0 {
- return false
- }
- }
- return true
-}
-
-// Append a directive to the directives stack.
-func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
- for i := 0; i < len(emitter.tag_directives); i++ {
- if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
- if allow_duplicates {
- return true
- }
- return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
- }
- }
-
- // [Go] Do we actually need to copy this given garbage collection
- // and the lack of deallocating destructors?
- tag_copy := yaml_tag_directive_t{
- handle: make([]byte, len(value.handle)),
- prefix: make([]byte, len(value.prefix)),
- }
- copy(tag_copy.handle, value.handle)
- copy(tag_copy.prefix, value.prefix)
- emitter.tag_directives = append(emitter.tag_directives, tag_copy)
- return true
-}
-
-// Increase the indentation level.
-func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
- emitter.indents = append(emitter.indents, emitter.indent)
- if emitter.indent < 0 {
- if flow {
- emitter.indent = emitter.best_indent
- } else {
- emitter.indent = 0
- }
- } else if !indentless {
- // [Go] This was changed so that indentations are more regular.
- if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
- // The first indent inside a sequence will just skip the "- " indicator.
- emitter.indent += 2
- } else {
- // Everything else aligns to the chosen indentation.
- emitter.indent = emitter.best_indent*((emitter.indent+emitter.best_indent)/emitter.best_indent)
- }
- }
- return true
-}
-
-// State dispatcher.
-func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- switch emitter.state {
- default:
- case yaml_EMIT_STREAM_START_STATE:
- return yaml_emitter_emit_stream_start(emitter, event)
-
- case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
- return yaml_emitter_emit_document_start(emitter, event, true)
-
- case yaml_EMIT_DOCUMENT_START_STATE:
- return yaml_emitter_emit_document_start(emitter, event, false)
-
- case yaml_EMIT_DOCUMENT_CONTENT_STATE:
- return yaml_emitter_emit_document_content(emitter, event)
-
- case yaml_EMIT_DOCUMENT_END_STATE:
- return yaml_emitter_emit_document_end(emitter, event)
-
- case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
- return yaml_emitter_emit_flow_sequence_item(emitter, event, true, false)
-
- case yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE:
- return yaml_emitter_emit_flow_sequence_item(emitter, event, false, true)
-
- case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
- return yaml_emitter_emit_flow_sequence_item(emitter, event, false, false)
-
- case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
- return yaml_emitter_emit_flow_mapping_key(emitter, event, true, false)
-
- case yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE:
- return yaml_emitter_emit_flow_mapping_key(emitter, event, false, true)
-
- case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
- return yaml_emitter_emit_flow_mapping_key(emitter, event, false, false)
-
- case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
- return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
-
- case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
- return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
-
- case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
- return yaml_emitter_emit_block_sequence_item(emitter, event, true)
-
- case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
- return yaml_emitter_emit_block_sequence_item(emitter, event, false)
-
- case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
- return yaml_emitter_emit_block_mapping_key(emitter, event, true)
-
- case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
- return yaml_emitter_emit_block_mapping_key(emitter, event, false)
-
- case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
- return yaml_emitter_emit_block_mapping_value(emitter, event, true)
-
- case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
- return yaml_emitter_emit_block_mapping_value(emitter, event, false)
-
- case yaml_EMIT_END_STATE:
- return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
- }
- panic("invalid emitter state")
-}
-
-// Expect STREAM-START.
-func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if event.typ != yaml_STREAM_START_EVENT {
- return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
- }
- if emitter.encoding == yaml_ANY_ENCODING {
- emitter.encoding = event.encoding
- if emitter.encoding == yaml_ANY_ENCODING {
- emitter.encoding = yaml_UTF8_ENCODING
- }
- }
- if emitter.best_indent < 2 || emitter.best_indent > 9 {
- emitter.best_indent = 2
- }
- if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
- emitter.best_width = 80
- }
- if emitter.best_width < 0 {
- emitter.best_width = 1<<31 - 1
- }
- if emitter.line_break == yaml_ANY_BREAK {
- emitter.line_break = yaml_LN_BREAK
- }
-
- emitter.indent = -1
- emitter.line = 0
- emitter.column = 0
- emitter.whitespace = true
- emitter.indention = true
- emitter.space_above = true
- emitter.foot_indent = -1
-
- if emitter.encoding != yaml_UTF8_ENCODING {
- if !yaml_emitter_write_bom(emitter) {
- return false
- }
- }
- emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
- return true
-}
-
-// Expect DOCUMENT-START or STREAM-END.
-func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
-
- if event.typ == yaml_DOCUMENT_START_EVENT {
-
- if event.version_directive != nil {
- if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
- return false
- }
- }
-
- for i := 0; i < len(event.tag_directives); i++ {
- tag_directive := &event.tag_directives[i]
- if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
- return false
- }
- if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
- return false
- }
- }
-
- for i := 0; i < len(default_tag_directives); i++ {
- tag_directive := &default_tag_directives[i]
- if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
- return false
- }
- }
-
- implicit := event.implicit
- if !first || emitter.canonical {
- implicit = false
- }
-
- if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
- if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
-
- if event.version_directive != nil {
- implicit = false
- if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
- return false
- }
- if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
-
- if len(event.tag_directives) > 0 {
- implicit = false
- for i := 0; i < len(event.tag_directives); i++ {
- tag_directive := &event.tag_directives[i]
- if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
- return false
- }
- if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
- return false
- }
- if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- }
-
- if yaml_emitter_check_empty_document(emitter) {
- implicit = false
- }
- if !implicit {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
- return false
- }
- if emitter.canonical || true {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- }
-
- if len(emitter.head_comment) > 0 {
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- if !put_break(emitter) {
- return false
- }
- }
-
- emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
- return true
- }
-
- if event.typ == yaml_STREAM_END_EVENT {
- if emitter.open_ended {
- if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !yaml_emitter_flush(emitter) {
- return false
- }
- emitter.state = yaml_EMIT_END_STATE
- return true
- }
-
- return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
-}
-
-// Expect the root node.
-func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
-
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- if !yaml_emitter_emit_node(emitter, event, true, false, false, false) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- return true
-}
-
-// Expect DOCUMENT-END.
-func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if event.typ != yaml_DOCUMENT_END_EVENT {
- return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
- }
- // [Go] Force document foot separation.
- emitter.foot_indent = 0
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- emitter.foot_indent = -1
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !event.implicit {
- // [Go] Allocate the slice elsewhere.
- if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !yaml_emitter_flush(emitter) {
- return false
- }
- emitter.state = yaml_EMIT_DOCUMENT_START_STATE
- emitter.tag_directives = emitter.tag_directives[:0]
- return true
-}
-
-// Expect a flow item node.
-func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
- if first {
- if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
- return false
- }
- if !yaml_emitter_increase_indent(emitter, true, false) {
- return false
- }
- emitter.flow_level++
- }
-
- if event.typ == yaml_SEQUENCE_END_EVENT {
- if emitter.canonical && !first && !trail {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
- emitter.flow_level--
- emitter.indent = emitter.indents[len(emitter.indents)-1]
- emitter.indents = emitter.indents[:len(emitter.indents)-1]
- if emitter.column == 0 || emitter.canonical && !first {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
-
- return true
- }
-
- if !first && !trail {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
-
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- if emitter.column == 0 {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
-
- if emitter.canonical || emitter.column > emitter.best_width {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE)
- } else {
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
- }
- if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
- return false
- }
- if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- return true
-}
-
-// Expect a flow key node.
-func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
- if first {
- if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
- return false
- }
- if !yaml_emitter_increase_indent(emitter, true, false) {
- return false
- }
- emitter.flow_level++
- }
-
- if event.typ == yaml_MAPPING_END_EVENT {
- if (emitter.canonical || len(emitter.head_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0) && !first && !trail {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- emitter.flow_level--
- emitter.indent = emitter.indents[len(emitter.indents)-1]
- emitter.indents = emitter.indents[:len(emitter.indents)-1]
- if emitter.canonical && !first {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
- return true
- }
-
- if !first && !trail {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
-
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
-
- if emitter.column == 0 {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
-
- if emitter.canonical || emitter.column > emitter.best_width {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
-
- if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
- return yaml_emitter_emit_node(emitter, event, false, false, true, true)
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
- return false
- }
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
- return yaml_emitter_emit_node(emitter, event, false, false, true, false)
-}
-
-// Expect a flow value node.
-func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
- if simple {
- if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
- return false
- }
- } else {
- if emitter.canonical || emitter.column > emitter.best_width {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
- return false
- }
- }
- if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE)
- } else {
- emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
- }
- if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
- return false
- }
- if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
- if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
- return false
- }
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- return true
-}
-
-// Expect a block item node.
-func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
- if first {
- if !yaml_emitter_increase_indent(emitter, false, false) {
- return false
- }
- }
- if event.typ == yaml_SEQUENCE_END_EVENT {
- emitter.indent = emitter.indents[len(emitter.indents)-1]
- emitter.indents = emitter.indents[:len(emitter.indents)-1]
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
- return true
- }
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
- return false
- }
- emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
- if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- return true
-}
-
-// Expect a block key node.
-func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
- if first {
- if !yaml_emitter_increase_indent(emitter, false, false) {
- return false
- }
- }
- if !yaml_emitter_process_head_comment(emitter) {
- return false
- }
- if event.typ == yaml_MAPPING_END_EVENT {
- emitter.indent = emitter.indents[len(emitter.indents)-1]
- emitter.indents = emitter.indents[:len(emitter.indents)-1]
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
- return true
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if len(emitter.line_comment) > 0 {
- // [Go] A line comment was provided for the key. That's unusual as the
- // scanner associates line comments with the value. Either way,
- // save the line comment and render it appropriately later.
- emitter.key_line_comment = emitter.line_comment
- emitter.line_comment = nil
- }
- if yaml_emitter_check_simple_key(emitter) {
- emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
- return yaml_emitter_emit_node(emitter, event, false, false, true, true)
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
- return false
- }
- emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
- return yaml_emitter_emit_node(emitter, event, false, false, true, false)
-}
-
-// Expect a block value node.
-func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
- if simple {
- if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
- return false
- }
- } else {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
- return false
- }
- }
- if len(emitter.key_line_comment) > 0 {
- // [Go] Line comments are generally associated with the value, but when there's
- // no value on the same line as a mapping key they end up attached to the
- // key itself.
- if event.typ == yaml_SCALAR_EVENT {
- if len(emitter.line_comment) == 0 {
- // A scalar is coming and it has no line comments by itself yet,
- // so just let it handle the line comment as usual. If it has a
- // line comment, we can't have both so the one from the key is lost.
- emitter.line_comment = emitter.key_line_comment
- emitter.key_line_comment = nil
- }
- } else if event.sequence_style() != yaml_FLOW_SEQUENCE_STYLE && (event.typ == yaml_MAPPING_START_EVENT || event.typ == yaml_SEQUENCE_START_EVENT) {
- // An indented block follows, so write the comment right now.
- emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
- }
- }
- emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
- if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- if !yaml_emitter_process_foot_comment(emitter) {
- return false
- }
- return true
-}
-
-func yaml_emitter_silent_nil_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- return event.typ == yaml_SCALAR_EVENT && event.implicit && !emitter.canonical && len(emitter.scalar_data.value) == 0
-}
-
-// Expect a node.
-func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
- root bool, sequence bool, mapping bool, simple_key bool) bool {
-
- emitter.root_context = root
- emitter.sequence_context = sequence
- emitter.mapping_context = mapping
- emitter.simple_key_context = simple_key
-
- switch event.typ {
- case yaml_ALIAS_EVENT:
- return yaml_emitter_emit_alias(emitter, event)
- case yaml_SCALAR_EVENT:
- return yaml_emitter_emit_scalar(emitter, event)
- case yaml_SEQUENCE_START_EVENT:
- return yaml_emitter_emit_sequence_start(emitter, event)
- case yaml_MAPPING_START_EVENT:
- return yaml_emitter_emit_mapping_start(emitter, event)
- default:
- return yaml_emitter_set_emitter_error(emitter,
- fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
- }
-}
-
-// Expect ALIAS.
-func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if !yaml_emitter_process_anchor(emitter) {
- return false
- }
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
- return true
-}
-
-// Expect SCALAR.
-func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if !yaml_emitter_select_scalar_style(emitter, event) {
- return false
- }
- if !yaml_emitter_process_anchor(emitter) {
- return false
- }
- if !yaml_emitter_process_tag(emitter) {
- return false
- }
- if !yaml_emitter_increase_indent(emitter, true, false) {
- return false
- }
- if !yaml_emitter_process_scalar(emitter) {
- return false
- }
- emitter.indent = emitter.indents[len(emitter.indents)-1]
- emitter.indents = emitter.indents[:len(emitter.indents)-1]
- emitter.state = emitter.states[len(emitter.states)-1]
- emitter.states = emitter.states[:len(emitter.states)-1]
- return true
-}
-
-// Expect SEQUENCE-START.
-func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if !yaml_emitter_process_anchor(emitter) {
- return false
- }
- if !yaml_emitter_process_tag(emitter) {
- return false
- }
- if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
- yaml_emitter_check_empty_sequence(emitter) {
- emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
- } else {
- emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
- }
- return true
-}
-
-// Expect MAPPING-START.
-func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
- if !yaml_emitter_process_anchor(emitter) {
- return false
- }
- if !yaml_emitter_process_tag(emitter) {
- return false
- }
- if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
- yaml_emitter_check_empty_mapping(emitter) {
- emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
- } else {
- emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
- }
- return true
-}
-
-// Check if the document content is an empty scalar.
-func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
- return false // [Go] Huh?
-}
-
-// Check if the next events represent an empty sequence.
-func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
- if len(emitter.events)-emitter.events_head < 2 {
- return false
- }
- return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
- emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
-}
-
-// Check if the next events represent an empty mapping.
-func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
- if len(emitter.events)-emitter.events_head < 2 {
- return false
- }
- return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
- emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
-}
-
-// Check if the next node can be expressed as a simple key.
-func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
- length := 0
- switch emitter.events[emitter.events_head].typ {
- case yaml_ALIAS_EVENT:
- length += len(emitter.anchor_data.anchor)
- case yaml_SCALAR_EVENT:
- if emitter.scalar_data.multiline {
- return false
- }
- length += len(emitter.anchor_data.anchor) +
- len(emitter.tag_data.handle) +
- len(emitter.tag_data.suffix) +
- len(emitter.scalar_data.value)
- case yaml_SEQUENCE_START_EVENT:
- if !yaml_emitter_check_empty_sequence(emitter) {
- return false
- }
- length += len(emitter.anchor_data.anchor) +
- len(emitter.tag_data.handle) +
- len(emitter.tag_data.suffix)
- case yaml_MAPPING_START_EVENT:
- if !yaml_emitter_check_empty_mapping(emitter) {
- return false
- }
- length += len(emitter.anchor_data.anchor) +
- len(emitter.tag_data.handle) +
- len(emitter.tag_data.suffix)
- default:
- return false
- }
- return length <= 128
-}
-
-// Determine an acceptable scalar style.
-func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
-
- no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
- if no_tag && !event.implicit && !event.quoted_implicit {
- return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
- }
-
- style := event.scalar_style()
- if style == yaml_ANY_SCALAR_STYLE {
- style = yaml_PLAIN_SCALAR_STYLE
- }
- if emitter.canonical {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
- if emitter.simple_key_context && emitter.scalar_data.multiline {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
-
- if style == yaml_PLAIN_SCALAR_STYLE {
- if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
- emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
- style = yaml_SINGLE_QUOTED_SCALAR_STYLE
- }
- if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
- style = yaml_SINGLE_QUOTED_SCALAR_STYLE
- }
- if no_tag && !event.implicit {
- style = yaml_SINGLE_QUOTED_SCALAR_STYLE
- }
- }
- if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
- if !emitter.scalar_data.single_quoted_allowed {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
- }
- if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
- if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
- }
-
- if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
- emitter.tag_data.handle = []byte{'!'}
- }
- emitter.scalar_data.style = style
- return true
-}
-
-// Write an anchor.
-func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
- if emitter.anchor_data.anchor == nil {
- return true
- }
- c := []byte{'&'}
- if emitter.anchor_data.alias {
- c[0] = '*'
- }
- if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
- return false
- }
- return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
-}
-
-// Write a tag.
-func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
- if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
- return true
- }
- if len(emitter.tag_data.handle) > 0 {
- if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
- return false
- }
- if len(emitter.tag_data.suffix) > 0 {
- if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
- return false
- }
- }
- } else {
- // [Go] Allocate these slices elsewhere.
- if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
- return false
- }
- if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
- return false
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
- return false
- }
- }
- return true
-}
-
-// Write a scalar.
-func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
- switch emitter.scalar_data.style {
- case yaml_PLAIN_SCALAR_STYLE:
- return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
-
- case yaml_SINGLE_QUOTED_SCALAR_STYLE:
- return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
-
- case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
- return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
-
- case yaml_LITERAL_SCALAR_STYLE:
- return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
-
- case yaml_FOLDED_SCALAR_STYLE:
- return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
- }
- panic("unknown scalar style")
-}
-
-// Write a head comment.
-func yaml_emitter_process_head_comment(emitter *yaml_emitter_t) bool {
- if len(emitter.tail_comment) > 0 {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_comment(emitter, emitter.tail_comment) {
- return false
- }
- emitter.tail_comment = emitter.tail_comment[:0]
- emitter.foot_indent = emitter.indent
- if emitter.foot_indent < 0 {
- emitter.foot_indent = 0
- }
- }
-
- if len(emitter.head_comment) == 0 {
- return true
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_comment(emitter, emitter.head_comment) {
- return false
- }
- emitter.head_comment = emitter.head_comment[:0]
- return true
-}
-
-// Write an line comment.
-func yaml_emitter_process_line_comment(emitter *yaml_emitter_t) bool {
- if len(emitter.line_comment) == 0 {
- return true
- }
- if !emitter.whitespace {
- if !put(emitter, ' ') {
- return false
- }
- }
- if !yaml_emitter_write_comment(emitter, emitter.line_comment) {
- return false
- }
- emitter.line_comment = emitter.line_comment[:0]
- return true
-}
-
-// Write a foot comment.
-func yaml_emitter_process_foot_comment(emitter *yaml_emitter_t) bool {
- if len(emitter.foot_comment) == 0 {
- return true
- }
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !yaml_emitter_write_comment(emitter, emitter.foot_comment) {
- return false
- }
- emitter.foot_comment = emitter.foot_comment[:0]
- emitter.foot_indent = emitter.indent
- if emitter.foot_indent < 0 {
- emitter.foot_indent = 0
- }
- return true
-}
-
-// Check if a %YAML directive is valid.
-func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
- if version_directive.major != 1 || version_directive.minor != 1 {
- return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
- }
- return true
-}
-
-// Check if a %TAG directive is valid.
-func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
- handle := tag_directive.handle
- prefix := tag_directive.prefix
- if len(handle) == 0 {
- return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
- }
- if handle[0] != '!' {
- return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
- }
- if handle[len(handle)-1] != '!' {
- return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
- }
- for i := 1; i < len(handle)-1; i += width(handle[i]) {
- if !is_alpha(handle, i) {
- return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
- }
- }
- if len(prefix) == 0 {
- return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
- }
- return true
-}
-
-// Check if an anchor is valid.
-func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
- if len(anchor) == 0 {
- problem := "anchor value must not be empty"
- if alias {
- problem = "alias value must not be empty"
- }
- return yaml_emitter_set_emitter_error(emitter, problem)
- }
- for i := 0; i < len(anchor); i += width(anchor[i]) {
- if !is_alpha(anchor, i) {
- problem := "anchor value must contain alphanumerical characters only"
- if alias {
- problem = "alias value must contain alphanumerical characters only"
- }
- return yaml_emitter_set_emitter_error(emitter, problem)
- }
- }
- emitter.anchor_data.anchor = anchor
- emitter.anchor_data.alias = alias
- return true
-}
-
-// Check if a tag is valid.
-func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
- if len(tag) == 0 {
- return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
- }
- for i := 0; i < len(emitter.tag_directives); i++ {
- tag_directive := &emitter.tag_directives[i]
- if bytes.HasPrefix(tag, tag_directive.prefix) {
- emitter.tag_data.handle = tag_directive.handle
- emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
- return true
- }
- }
- emitter.tag_data.suffix = tag
- return true
-}
-
-// Check if a scalar is valid.
-func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
- var (
- block_indicators = false
- flow_indicators = false
- line_breaks = false
- special_characters = false
- tab_characters = false
-
- leading_space = false
- leading_break = false
- trailing_space = false
- trailing_break = false
- break_space = false
- space_break = false
-
- preceded_by_whitespace = false
- followed_by_whitespace = false
- previous_space = false
- previous_break = false
- )
-
- emitter.scalar_data.value = value
-
- if len(value) == 0 {
- emitter.scalar_data.multiline = false
- emitter.scalar_data.flow_plain_allowed = false
- emitter.scalar_data.block_plain_allowed = true
- emitter.scalar_data.single_quoted_allowed = true
- emitter.scalar_data.block_allowed = false
- return true
- }
-
- if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
- block_indicators = true
- flow_indicators = true
- }
-
- preceded_by_whitespace = true
- for i, w := 0, 0; i < len(value); i += w {
- w = width(value[i])
- followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
-
- if i == 0 {
- switch value[i] {
- case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
- flow_indicators = true
- block_indicators = true
- case '?', ':':
- flow_indicators = true
- if followed_by_whitespace {
- block_indicators = true
- }
- case '-':
- if followed_by_whitespace {
- flow_indicators = true
- block_indicators = true
- }
- }
- } else {
- switch value[i] {
- case ',', '?', '[', ']', '{', '}':
- flow_indicators = true
- case ':':
- flow_indicators = true
- if followed_by_whitespace {
- block_indicators = true
- }
- case '#':
- if preceded_by_whitespace {
- flow_indicators = true
- block_indicators = true
- }
- }
- }
-
- if value[i] == '\t' {
- tab_characters = true
- } else if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
- special_characters = true
- }
- if is_space(value, i) {
- if i == 0 {
- leading_space = true
- }
- if i+width(value[i]) == len(value) {
- trailing_space = true
- }
- if previous_break {
- break_space = true
- }
- previous_space = true
- previous_break = false
- } else if is_break(value, i) {
- line_breaks = true
- if i == 0 {
- leading_break = true
- }
- if i+width(value[i]) == len(value) {
- trailing_break = true
- }
- if previous_space {
- space_break = true
- }
- previous_space = false
- previous_break = true
- } else {
- previous_space = false
- previous_break = false
- }
-
- // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
- preceded_by_whitespace = is_blankz(value, i)
- }
-
- emitter.scalar_data.multiline = line_breaks
- emitter.scalar_data.flow_plain_allowed = true
- emitter.scalar_data.block_plain_allowed = true
- emitter.scalar_data.single_quoted_allowed = true
- emitter.scalar_data.block_allowed = true
-
- if leading_space || leading_break || trailing_space || trailing_break {
- emitter.scalar_data.flow_plain_allowed = false
- emitter.scalar_data.block_plain_allowed = false
- }
- if trailing_space {
- emitter.scalar_data.block_allowed = false
- }
- if break_space {
- emitter.scalar_data.flow_plain_allowed = false
- emitter.scalar_data.block_plain_allowed = false
- emitter.scalar_data.single_quoted_allowed = false
- }
- if space_break || tab_characters || special_characters {
- emitter.scalar_data.flow_plain_allowed = false
- emitter.scalar_data.block_plain_allowed = false
- emitter.scalar_data.single_quoted_allowed = false
- }
- if space_break || special_characters {
- emitter.scalar_data.block_allowed = false
- }
- if line_breaks {
- emitter.scalar_data.flow_plain_allowed = false
- emitter.scalar_data.block_plain_allowed = false
- }
- if flow_indicators {
- emitter.scalar_data.flow_plain_allowed = false
- }
- if block_indicators {
- emitter.scalar_data.block_plain_allowed = false
- }
- return true
-}
-
-// Check if the event data is valid.
-func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
-
- emitter.anchor_data.anchor = nil
- emitter.tag_data.handle = nil
- emitter.tag_data.suffix = nil
- emitter.scalar_data.value = nil
-
- if len(event.head_comment) > 0 {
- emitter.head_comment = event.head_comment
- }
- if len(event.line_comment) > 0 {
- emitter.line_comment = event.line_comment
- }
- if len(event.foot_comment) > 0 {
- emitter.foot_comment = event.foot_comment
- }
- if len(event.tail_comment) > 0 {
- emitter.tail_comment = event.tail_comment
- }
-
- switch event.typ {
- case yaml_ALIAS_EVENT:
- if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
- return false
- }
-
- case yaml_SCALAR_EVENT:
- if len(event.anchor) > 0 {
- if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
- return false
- }
- }
- if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
- if !yaml_emitter_analyze_tag(emitter, event.tag) {
- return false
- }
- }
- if !yaml_emitter_analyze_scalar(emitter, event.value) {
- return false
- }
-
- case yaml_SEQUENCE_START_EVENT:
- if len(event.anchor) > 0 {
- if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
- return false
- }
- }
- if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
- if !yaml_emitter_analyze_tag(emitter, event.tag) {
- return false
- }
- }
-
- case yaml_MAPPING_START_EVENT:
- if len(event.anchor) > 0 {
- if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
- return false
- }
- }
- if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
- if !yaml_emitter_analyze_tag(emitter, event.tag) {
- return false
- }
- }
- }
- return true
-}
-
-// Write the BOM character.
-func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
- if !flush(emitter) {
- return false
- }
- pos := emitter.buffer_pos
- emitter.buffer[pos+0] = '\xEF'
- emitter.buffer[pos+1] = '\xBB'
- emitter.buffer[pos+2] = '\xBF'
- emitter.buffer_pos += 3
- return true
-}
-
-func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
- indent := emitter.indent
- if indent < 0 {
- indent = 0
- }
- if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
- if !put_break(emitter) {
- return false
- }
- }
- if emitter.foot_indent == indent {
- if !put_break(emitter) {
- return false
- }
- }
- for emitter.column < indent {
- if !put(emitter, ' ') {
- return false
- }
- }
- emitter.whitespace = true
- //emitter.indention = true
- emitter.space_above = false
- emitter.foot_indent = -1
- return true
-}
-
-func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
- if need_whitespace && !emitter.whitespace {
- if !put(emitter, ' ') {
- return false
- }
- }
- if !write_all(emitter, indicator) {
- return false
- }
- emitter.whitespace = is_whitespace
- emitter.indention = (emitter.indention && is_indention)
- emitter.open_ended = false
- return true
-}
-
-func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
- if !write_all(emitter, value) {
- return false
- }
- emitter.whitespace = false
- emitter.indention = false
- return true
-}
-
-func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
- if !emitter.whitespace {
- if !put(emitter, ' ') {
- return false
- }
- }
- if !write_all(emitter, value) {
- return false
- }
- emitter.whitespace = false
- emitter.indention = false
- return true
-}
-
-func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
- if need_whitespace && !emitter.whitespace {
- if !put(emitter, ' ') {
- return false
- }
- }
- for i := 0; i < len(value); {
- var must_write bool
- switch value[i] {
- case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
- must_write = true
- default:
- must_write = is_alpha(value, i)
- }
- if must_write {
- if !write(emitter, value, &i) {
- return false
- }
- } else {
- w := width(value[i])
- for k := 0; k < w; k++ {
- octet := value[i]
- i++
- if !put(emitter, '%') {
- return false
- }
-
- c := octet >> 4
- if c < 10 {
- c += '0'
- } else {
- c += 'A' - 10
- }
- if !put(emitter, c) {
- return false
- }
-
- c = octet & 0x0f
- if c < 10 {
- c += '0'
- } else {
- c += 'A' - 10
- }
- if !put(emitter, c) {
- return false
- }
- }
- }
- }
- emitter.whitespace = false
- emitter.indention = false
- return true
-}
-
-func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
- if len(value) > 0 && !emitter.whitespace {
- if !put(emitter, ' ') {
- return false
- }
- }
-
- spaces := false
- breaks := false
- for i := 0; i < len(value); {
- if is_space(value, i) {
- if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- i += width(value[i])
- } else {
- if !write(emitter, value, &i) {
- return false
- }
- }
- spaces = true
- } else if is_break(value, i) {
- if !breaks && value[i] == '\n' {
- if !put_break(emitter) {
- return false
- }
- }
- if !write_break(emitter, value, &i) {
- return false
- }
- //emitter.indention = true
- breaks = true
- } else {
- if breaks {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !write(emitter, value, &i) {
- return false
- }
- emitter.indention = false
- spaces = false
- breaks = false
- }
- }
-
- if len(value) > 0 {
- emitter.whitespace = false
- }
- emitter.indention = false
- if emitter.root_context {
- emitter.open_ended = true
- }
-
- return true
-}
-
-func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
-
- if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
- return false
- }
-
- spaces := false
- breaks := false
- for i := 0; i < len(value); {
- if is_space(value, i) {
- if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- i += width(value[i])
- } else {
- if !write(emitter, value, &i) {
- return false
- }
- }
- spaces = true
- } else if is_break(value, i) {
- if !breaks && value[i] == '\n' {
- if !put_break(emitter) {
- return false
- }
- }
- if !write_break(emitter, value, &i) {
- return false
- }
- //emitter.indention = true
- breaks = true
- } else {
- if breaks {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if value[i] == '\'' {
- if !put(emitter, '\'') {
- return false
- }
- }
- if !write(emitter, value, &i) {
- return false
- }
- emitter.indention = false
- spaces = false
- breaks = false
- }
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
- return false
- }
- emitter.whitespace = false
- emitter.indention = false
- return true
-}
-
-func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
- spaces := false
- if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
- return false
- }
-
- for i := 0; i < len(value); {
- if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
- is_bom(value, i) || is_break(value, i) ||
- value[i] == '"' || value[i] == '\\' {
-
- octet := value[i]
-
- var w int
- var v rune
- switch {
- case octet&0x80 == 0x00:
- w, v = 1, rune(octet&0x7F)
- case octet&0xE0 == 0xC0:
- w, v = 2, rune(octet&0x1F)
- case octet&0xF0 == 0xE0:
- w, v = 3, rune(octet&0x0F)
- case octet&0xF8 == 0xF0:
- w, v = 4, rune(octet&0x07)
- }
- for k := 1; k < w; k++ {
- octet = value[i+k]
- v = (v << 6) + (rune(octet) & 0x3F)
- }
- i += w
-
- if !put(emitter, '\\') {
- return false
- }
-
- var ok bool
- switch v {
- case 0x00:
- ok = put(emitter, '0')
- case 0x07:
- ok = put(emitter, 'a')
- case 0x08:
- ok = put(emitter, 'b')
- case 0x09:
- ok = put(emitter, 't')
- case 0x0A:
- ok = put(emitter, 'n')
- case 0x0b:
- ok = put(emitter, 'v')
- case 0x0c:
- ok = put(emitter, 'f')
- case 0x0d:
- ok = put(emitter, 'r')
- case 0x1b:
- ok = put(emitter, 'e')
- case 0x22:
- ok = put(emitter, '"')
- case 0x5c:
- ok = put(emitter, '\\')
- case 0x85:
- ok = put(emitter, 'N')
- case 0xA0:
- ok = put(emitter, '_')
- case 0x2028:
- ok = put(emitter, 'L')
- case 0x2029:
- ok = put(emitter, 'P')
- default:
- if v <= 0xFF {
- ok = put(emitter, 'x')
- w = 2
- } else if v <= 0xFFFF {
- ok = put(emitter, 'u')
- w = 4
- } else {
- ok = put(emitter, 'U')
- w = 8
- }
- for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
- digit := byte((v >> uint(k)) & 0x0F)
- if digit < 10 {
- ok = put(emitter, digit+'0')
- } else {
- ok = put(emitter, digit+'A'-10)
- }
- }
- }
- if !ok {
- return false
- }
- spaces = false
- } else if is_space(value, i) {
- if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- if is_space(value, i+1) {
- if !put(emitter, '\\') {
- return false
- }
- }
- i += width(value[i])
- } else if !write(emitter, value, &i) {
- return false
- }
- spaces = true
- } else {
- if !write(emitter, value, &i) {
- return false
- }
- spaces = false
- }
- }
- if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
- return false
- }
- emitter.whitespace = false
- emitter.indention = false
- return true
-}
-
-func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
- if is_space(value, 0) || is_break(value, 0) {
- indent_hint := []byte{'0' + byte(emitter.best_indent)}
- if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
- return false
- }
- }
-
- emitter.open_ended = false
-
- var chomp_hint [1]byte
- if len(value) == 0 {
- chomp_hint[0] = '-'
- } else {
- i := len(value) - 1
- for value[i]&0xC0 == 0x80 {
- i--
- }
- if !is_break(value, i) {
- chomp_hint[0] = '-'
- } else if i == 0 {
- chomp_hint[0] = '+'
- emitter.open_ended = true
- } else {
- i--
- for value[i]&0xC0 == 0x80 {
- i--
- }
- if is_break(value, i) {
- chomp_hint[0] = '+'
- emitter.open_ended = true
- }
- }
- }
- if chomp_hint[0] != 0 {
- if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
- return false
- }
- }
- return true
-}
-
-func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
- if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
- return false
- }
- if !yaml_emitter_write_block_scalar_hints(emitter, value) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
- //emitter.indention = true
- emitter.whitespace = true
- breaks := true
- for i := 0; i < len(value); {
- if is_break(value, i) {
- if !write_break(emitter, value, &i) {
- return false
- }
- //emitter.indention = true
- breaks = true
- } else {
- if breaks {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- }
- if !write(emitter, value, &i) {
- return false
- }
- emitter.indention = false
- breaks = false
- }
- }
-
- return true
-}
-
-func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
- if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
- return false
- }
- if !yaml_emitter_write_block_scalar_hints(emitter, value) {
- return false
- }
- if !yaml_emitter_process_line_comment(emitter) {
- return false
- }
-
- //emitter.indention = true
- emitter.whitespace = true
-
- breaks := true
- leading_spaces := true
- for i := 0; i < len(value); {
- if is_break(value, i) {
- if !breaks && !leading_spaces && value[i] == '\n' {
- k := 0
- for is_break(value, k) {
- k += width(value[k])
- }
- if !is_blankz(value, k) {
- if !put_break(emitter) {
- return false
- }
- }
- }
- if !write_break(emitter, value, &i) {
- return false
- }
- //emitter.indention = true
- breaks = true
- } else {
- if breaks {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- leading_spaces = is_blank(value, i)
- }
- if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
- if !yaml_emitter_write_indent(emitter) {
- return false
- }
- i += width(value[i])
- } else {
- if !write(emitter, value, &i) {
- return false
- }
- }
- emitter.indention = false
- breaks = false
- }
- }
- return true
-}
-
-func yaml_emitter_write_comment(emitter *yaml_emitter_t, comment []byte) bool {
- breaks := false
- pound := false
- for i := 0; i < len(comment); {
- if is_break(comment, i) {
- if !write_break(emitter, comment, &i) {
- return false
- }
- //emitter.indention = true
- breaks = true
- pound = false
- } else {
- if breaks && !yaml_emitter_write_indent(emitter) {
- return false
- }
- if !pound {
- if comment[i] != '#' && (!put(emitter, '#') || !put(emitter, ' ')) {
- return false
- }
- pound = true
- }
- if !write(emitter, comment, &i) {
- return false
- }
- emitter.indention = false
- breaks = false
- }
- }
- if !breaks && !put_break(emitter) {
- return false
- }
-
- emitter.whitespace = true
- //emitter.indention = true
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode.go
deleted file mode 100644
index de9e72a3e638d166e96ceab3d77ce59afe6e6f8a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode.go
+++ /dev/null
@@ -1,577 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml
-
-import (
- "encoding"
- "fmt"
- "io"
- "reflect"
- "regexp"
- "sort"
- "strconv"
- "strings"
- "time"
- "unicode/utf8"
-)
-
-type encoder struct {
- emitter yaml_emitter_t
- event yaml_event_t
- out []byte
- flow bool
- indent int
- doneInit bool
-}
-
-func newEncoder() *encoder {
- e := &encoder{}
- yaml_emitter_initialize(&e.emitter)
- yaml_emitter_set_output_string(&e.emitter, &e.out)
- yaml_emitter_set_unicode(&e.emitter, true)
- return e
-}
-
-func newEncoderWithWriter(w io.Writer) *encoder {
- e := &encoder{}
- yaml_emitter_initialize(&e.emitter)
- yaml_emitter_set_output_writer(&e.emitter, w)
- yaml_emitter_set_unicode(&e.emitter, true)
- return e
-}
-
-func (e *encoder) init() {
- if e.doneInit {
- return
- }
- if e.indent == 0 {
- e.indent = 4
- }
- e.emitter.best_indent = e.indent
- yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
- e.emit()
- e.doneInit = true
-}
-
-func (e *encoder) finish() {
- e.emitter.open_ended = false
- yaml_stream_end_event_initialize(&e.event)
- e.emit()
-}
-
-func (e *encoder) destroy() {
- yaml_emitter_delete(&e.emitter)
-}
-
-func (e *encoder) emit() {
- // This will internally delete the e.event value.
- e.must(yaml_emitter_emit(&e.emitter, &e.event))
-}
-
-func (e *encoder) must(ok bool) {
- if !ok {
- msg := e.emitter.problem
- if msg == "" {
- msg = "unknown problem generating YAML content"
- }
- failf("%s", msg)
- }
-}
-
-func (e *encoder) marshalDoc(tag string, in reflect.Value) {
- e.init()
- var node *Node
- if in.IsValid() {
- node, _ = in.Interface().(*Node)
- }
- if node != nil && node.Kind == DocumentNode {
- e.nodev(in)
- } else {
- yaml_document_start_event_initialize(&e.event, nil, nil, true)
- e.emit()
- e.marshal(tag, in)
- yaml_document_end_event_initialize(&e.event, true)
- e.emit()
- }
-}
-
-func (e *encoder) marshal(tag string, in reflect.Value) {
- tag = shortTag(tag)
- if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
- e.nilv()
- return
- }
- iface := in.Interface()
- switch value := iface.(type) {
- case *Node:
- e.nodev(in)
- return
- case Node:
- if !in.CanAddr() {
- var n = reflect.New(in.Type()).Elem()
- n.Set(in)
- in = n
- }
- e.nodev(in.Addr())
- return
- case time.Time:
- e.timev(tag, in)
- return
- case *time.Time:
- e.timev(tag, in.Elem())
- return
- case time.Duration:
- e.stringv(tag, reflect.ValueOf(value.String()))
- return
- case Marshaler:
- v, err := value.MarshalYAML()
- if err != nil {
- fail(err)
- }
- if v == nil {
- e.nilv()
- return
- }
- e.marshal(tag, reflect.ValueOf(v))
- return
- case encoding.TextMarshaler:
- text, err := value.MarshalText()
- if err != nil {
- fail(err)
- }
- in = reflect.ValueOf(string(text))
- case nil:
- e.nilv()
- return
- }
- switch in.Kind() {
- case reflect.Interface:
- e.marshal(tag, in.Elem())
- case reflect.Map:
- e.mapv(tag, in)
- case reflect.Ptr:
- e.marshal(tag, in.Elem())
- case reflect.Struct:
- e.structv(tag, in)
- case reflect.Slice, reflect.Array:
- e.slicev(tag, in)
- case reflect.String:
- e.stringv(tag, in)
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- e.intv(tag, in)
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- e.uintv(tag, in)
- case reflect.Float32, reflect.Float64:
- e.floatv(tag, in)
- case reflect.Bool:
- e.boolv(tag, in)
- default:
- panic("cannot marshal type: " + in.Type().String())
- }
-}
-
-func (e *encoder) mapv(tag string, in reflect.Value) {
- e.mappingv(tag, func() {
- keys := keyList(in.MapKeys())
- sort.Sort(keys)
- for _, k := range keys {
- e.marshal("", k)
- e.marshal("", in.MapIndex(k))
- }
- })
-}
-
-func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
- for _, num := range index {
- for {
- if v.Kind() == reflect.Ptr {
- if v.IsNil() {
- return reflect.Value{}
- }
- v = v.Elem()
- continue
- }
- break
- }
- v = v.Field(num)
- }
- return v
-}
-
-func (e *encoder) structv(tag string, in reflect.Value) {
- sinfo, err := getStructInfo(in.Type())
- if err != nil {
- panic(err)
- }
- e.mappingv(tag, func() {
- for _, info := range sinfo.FieldsList {
- var value reflect.Value
- if info.Inline == nil {
- value = in.Field(info.Num)
- } else {
- value = e.fieldByIndex(in, info.Inline)
- if !value.IsValid() {
- continue
- }
- }
- if info.OmitEmpty && isZero(value) {
- continue
- }
- e.marshal("", reflect.ValueOf(info.Key))
- e.flow = info.Flow
- e.marshal("", value)
- }
- if sinfo.InlineMap >= 0 {
- m := in.Field(sinfo.InlineMap)
- if m.Len() > 0 {
- e.flow = false
- keys := keyList(m.MapKeys())
- sort.Sort(keys)
- for _, k := range keys {
- if _, found := sinfo.FieldsMap[k.String()]; found {
- panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
- }
- e.marshal("", k)
- e.flow = false
- e.marshal("", m.MapIndex(k))
- }
- }
- }
- })
-}
-
-func (e *encoder) mappingv(tag string, f func()) {
- implicit := tag == ""
- style := yaml_BLOCK_MAPPING_STYLE
- if e.flow {
- e.flow = false
- style = yaml_FLOW_MAPPING_STYLE
- }
- yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
- e.emit()
- f()
- yaml_mapping_end_event_initialize(&e.event)
- e.emit()
-}
-
-func (e *encoder) slicev(tag string, in reflect.Value) {
- implicit := tag == ""
- style := yaml_BLOCK_SEQUENCE_STYLE
- if e.flow {
- e.flow = false
- style = yaml_FLOW_SEQUENCE_STYLE
- }
- e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
- e.emit()
- n := in.Len()
- for i := 0; i < n; i++ {
- e.marshal("", in.Index(i))
- }
- e.must(yaml_sequence_end_event_initialize(&e.event))
- e.emit()
-}
-
-// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
-//
-// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
-// in YAML 1.2 and by this package, but these should be marshalled quoted for
-// the time being for compatibility with other parsers.
-func isBase60Float(s string) (result bool) {
- // Fast path.
- if s == "" {
- return false
- }
- c := s[0]
- if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
- return false
- }
- // Do the full match.
- return base60float.MatchString(s)
-}
-
-// From http://yaml.org/type/float.html, except the regular expression there
-// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
-var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
-
-// isOldBool returns whether s is bool notation as defined in YAML 1.1.
-//
-// We continue to force strings that YAML 1.1 would interpret as booleans to be
-// rendered as quotes strings so that the marshalled output valid for YAML 1.1
-// parsing.
-func isOldBool(s string) (result bool) {
- switch s {
- case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
- "n", "N", "no", "No", "NO", "off", "Off", "OFF":
- return true
- default:
- return false
- }
-}
-
-func (e *encoder) stringv(tag string, in reflect.Value) {
- var style yaml_scalar_style_t
- s := in.String()
- canUsePlain := true
- switch {
- case !utf8.ValidString(s):
- if tag == binaryTag {
- failf("explicitly tagged !!binary data must be base64-encoded")
- }
- if tag != "" {
- failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
- }
- // It can't be encoded directly as YAML so use a binary tag
- // and encode it as base64.
- tag = binaryTag
- s = encodeBase64(s)
- case tag == "":
- // Check to see if it would resolve to a specific
- // tag when encoded unquoted. If it doesn't,
- // there's no need to quote it.
- rtag, _ := resolve("", s)
- canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
- }
- // Note: it's possible for user code to emit invalid YAML
- // if they explicitly specify a tag and a string containing
- // text that's incompatible with that tag.
- switch {
- case strings.Contains(s, "\n"):
- if e.flow {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- } else {
- style = yaml_LITERAL_SCALAR_STYLE
- }
- case canUsePlain:
- style = yaml_PLAIN_SCALAR_STYLE
- default:
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
- e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
-}
-
-func (e *encoder) boolv(tag string, in reflect.Value) {
- var s string
- if in.Bool() {
- s = "true"
- } else {
- s = "false"
- }
- e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) intv(tag string, in reflect.Value) {
- s := strconv.FormatInt(in.Int(), 10)
- e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) uintv(tag string, in reflect.Value) {
- s := strconv.FormatUint(in.Uint(), 10)
- e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) timev(tag string, in reflect.Value) {
- t := in.Interface().(time.Time)
- s := t.Format(time.RFC3339Nano)
- e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) floatv(tag string, in reflect.Value) {
- // Issue #352: When formatting, use the precision of the underlying value
- precision := 64
- if in.Kind() == reflect.Float32 {
- precision = 32
- }
-
- s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
- switch s {
- case "+Inf":
- s = ".inf"
- case "-Inf":
- s = "-.inf"
- case "NaN":
- s = ".nan"
- }
- e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) nilv() {
- e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
-}
-
-func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
- // TODO Kill this function. Replace all initialize calls by their underlining Go literals.
- implicit := tag == ""
- if !implicit {
- tag = longTag(tag)
- }
- e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
- e.event.head_comment = head
- e.event.line_comment = line
- e.event.foot_comment = foot
- e.event.tail_comment = tail
- e.emit()
-}
-
-func (e *encoder) nodev(in reflect.Value) {
- e.node(in.Interface().(*Node), "")
-}
-
-func (e *encoder) node(node *Node, tail string) {
- // Zero nodes behave as nil.
- if node.Kind == 0 && node.IsZero() {
- e.nilv()
- return
- }
-
- // If the tag was not explicitly requested, and dropping it won't change the
- // implicit tag of the value, don't include it in the presentation.
- var tag = node.Tag
- var stag = shortTag(tag)
- var forceQuoting bool
- if tag != "" && node.Style&TaggedStyle == 0 {
- if node.Kind == ScalarNode {
- if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
- tag = ""
- } else {
- rtag, _ := resolve("", node.Value)
- if rtag == stag {
- tag = ""
- } else if stag == strTag {
- tag = ""
- forceQuoting = true
- }
- }
- } else {
- var rtag string
- switch node.Kind {
- case MappingNode:
- rtag = mapTag
- case SequenceNode:
- rtag = seqTag
- }
- if rtag == stag {
- tag = ""
- }
- }
- }
-
- switch node.Kind {
- case DocumentNode:
- yaml_document_start_event_initialize(&e.event, nil, nil, true)
- e.event.head_comment = []byte(node.HeadComment)
- e.emit()
- for _, node := range node.Content {
- e.node(node, "")
- }
- yaml_document_end_event_initialize(&e.event, true)
- e.event.foot_comment = []byte(node.FootComment)
- e.emit()
-
- case SequenceNode:
- style := yaml_BLOCK_SEQUENCE_STYLE
- if node.Style&FlowStyle != 0 {
- style = yaml_FLOW_SEQUENCE_STYLE
- }
- e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
- e.event.head_comment = []byte(node.HeadComment)
- e.emit()
- for _, node := range node.Content {
- e.node(node, "")
- }
- e.must(yaml_sequence_end_event_initialize(&e.event))
- e.event.line_comment = []byte(node.LineComment)
- e.event.foot_comment = []byte(node.FootComment)
- e.emit()
-
- case MappingNode:
- style := yaml_BLOCK_MAPPING_STYLE
- if node.Style&FlowStyle != 0 {
- style = yaml_FLOW_MAPPING_STYLE
- }
- yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
- e.event.tail_comment = []byte(tail)
- e.event.head_comment = []byte(node.HeadComment)
- e.emit()
-
- // The tail logic below moves the foot comment of prior keys to the following key,
- // since the value for each key may be a nested structure and the foot needs to be
- // processed only the entirety of the value is streamed. The last tail is processed
- // with the mapping end event.
- var tail string
- for i := 0; i+1 < len(node.Content); i += 2 {
- k := node.Content[i]
- foot := k.FootComment
- if foot != "" {
- kopy := *k
- kopy.FootComment = ""
- k = &kopy
- }
- e.node(k, tail)
- tail = foot
-
- v := node.Content[i+1]
- e.node(v, "")
- }
-
- yaml_mapping_end_event_initialize(&e.event)
- e.event.tail_comment = []byte(tail)
- e.event.line_comment = []byte(node.LineComment)
- e.event.foot_comment = []byte(node.FootComment)
- e.emit()
-
- case AliasNode:
- yaml_alias_event_initialize(&e.event, []byte(node.Value))
- e.event.head_comment = []byte(node.HeadComment)
- e.event.line_comment = []byte(node.LineComment)
- e.event.foot_comment = []byte(node.FootComment)
- e.emit()
-
- case ScalarNode:
- value := node.Value
- if !utf8.ValidString(value) {
- if stag == binaryTag {
- failf("explicitly tagged !!binary data must be base64-encoded")
- }
- if stag != "" {
- failf("cannot marshal invalid UTF-8 data as %s", stag)
- }
- // It can't be encoded directly as YAML so use a binary tag
- // and encode it as base64.
- tag = binaryTag
- value = encodeBase64(value)
- }
-
- style := yaml_PLAIN_SCALAR_STYLE
- switch {
- case node.Style&DoubleQuotedStyle != 0:
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- case node.Style&SingleQuotedStyle != 0:
- style = yaml_SINGLE_QUOTED_SCALAR_STYLE
- case node.Style&LiteralStyle != 0:
- style = yaml_LITERAL_SCALAR_STYLE
- case node.Style&FoldedStyle != 0:
- style = yaml_FOLDED_SCALAR_STYLE
- case strings.Contains(value, "\n"):
- style = yaml_LITERAL_SCALAR_STYLE
- case forceQuoting:
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
-
- e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
- default:
- failf("cannot encode node with unknown kind %d", node.Kind)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode_test.go
deleted file mode 100644
index 4a8bf2e264ee2a3d34a62c191b7bcde35075e5f1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/encode_test.go
+++ /dev/null
@@ -1,736 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml_test
-
-import (
- "bytes"
- "fmt"
- "math"
- "strconv"
- "strings"
- "time"
-
- "net"
- "os"
-
- . "gopkg.in/check.v1"
- "gopkg.in/yaml.v3"
-)
-
-var marshalIntTest = 123
-
-var marshalTests = []struct {
- value interface{}
- data string
-}{
- {
- nil,
- "null\n",
- }, {
- (*marshalerType)(nil),
- "null\n",
- }, {
- &struct{}{},
- "{}\n",
- }, {
- map[string]string{"v": "hi"},
- "v: hi\n",
- }, {
- map[string]interface{}{"v": "hi"},
- "v: hi\n",
- }, {
- map[string]string{"v": "true"},
- "v: \"true\"\n",
- }, {
- map[string]string{"v": "false"},
- "v: \"false\"\n",
- }, {
- map[string]interface{}{"v": true},
- "v: true\n",
- }, {
- map[string]interface{}{"v": false},
- "v: false\n",
- }, {
- map[string]interface{}{"v": 10},
- "v: 10\n",
- }, {
- map[string]interface{}{"v": -10},
- "v: -10\n",
- }, {
- map[string]uint{"v": 42},
- "v: 42\n",
- }, {
- map[string]interface{}{"v": int64(4294967296)},
- "v: 4294967296\n",
- }, {
- map[string]int64{"v": int64(4294967296)},
- "v: 4294967296\n",
- }, {
- map[string]uint64{"v": 4294967296},
- "v: 4294967296\n",
- }, {
- map[string]interface{}{"v": "10"},
- "v: \"10\"\n",
- }, {
- map[string]interface{}{"v": 0.1},
- "v: 0.1\n",
- }, {
- map[string]interface{}{"v": float64(0.1)},
- "v: 0.1\n",
- }, {
- map[string]interface{}{"v": float32(0.99)},
- "v: 0.99\n",
- }, {
- map[string]interface{}{"v": -0.1},
- "v: -0.1\n",
- }, {
- map[string]interface{}{"v": math.Inf(+1)},
- "v: .inf\n",
- }, {
- map[string]interface{}{"v": math.Inf(-1)},
- "v: -.inf\n",
- }, {
- map[string]interface{}{"v": math.NaN()},
- "v: .nan\n",
- }, {
- map[string]interface{}{"v": nil},
- "v: null\n",
- }, {
- map[string]interface{}{"v": ""},
- "v: \"\"\n",
- }, {
- map[string][]string{"v": []string{"A", "B"}},
- "v:\n - A\n - B\n",
- }, {
- map[string][]string{"v": []string{"A", "B\nC"}},
- "v:\n - A\n - |-\n B\n C\n",
- }, {
- map[string][]interface{}{"v": []interface{}{"A", 1, map[string][]int{"B": []int{2, 3}}}},
- "v:\n - A\n - 1\n - B:\n - 2\n - 3\n",
- }, {
- map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
- "a:\n b: c\n",
- }, {
- map[string]interface{}{"a": "-"},
- "a: '-'\n",
- },
-
- // Simple values.
- {
- &marshalIntTest,
- "123\n",
- },
-
- // Structures
- {
- &struct{ Hello string }{"world"},
- "hello: world\n",
- }, {
- &struct {
- A struct {
- B string
- }
- }{struct{ B string }{"c"}},
- "a:\n b: c\n",
- }, {
- &struct {
- A *struct {
- B string
- }
- }{&struct{ B string }{"c"}},
- "a:\n b: c\n",
- }, {
- &struct {
- A *struct {
- B string
- }
- }{},
- "a: null\n",
- }, {
- &struct{ A int }{1},
- "a: 1\n",
- }, {
- &struct{ A []int }{[]int{1, 2}},
- "a:\n - 1\n - 2\n",
- }, {
- &struct{ A [2]int }{[2]int{1, 2}},
- "a:\n - 1\n - 2\n",
- }, {
- &struct {
- B int "a"
- }{1},
- "a: 1\n",
- }, {
- &struct{ A bool }{true},
- "a: true\n",
- }, {
- &struct{ A string }{"true"},
- "a: \"true\"\n",
- }, {
- &struct{ A string }{"off"},
- "a: \"off\"\n",
- },
-
- // Conditional flag
- {
- &struct {
- A int "a,omitempty"
- B int "b,omitempty"
- }{1, 0},
- "a: 1\n",
- }, {
- &struct {
- A int "a,omitempty"
- B int "b,omitempty"
- }{0, 0},
- "{}\n",
- }, {
- &struct {
- A *struct{ X, y int } "a,omitempty,flow"
- }{&struct{ X, y int }{1, 2}},
- "a: {x: 1}\n",
- }, {
- &struct {
- A *struct{ X, y int } "a,omitempty,flow"
- }{nil},
- "{}\n",
- }, {
- &struct {
- A *struct{ X, y int } "a,omitempty,flow"
- }{&struct{ X, y int }{}},
- "a: {x: 0}\n",
- }, {
- &struct {
- A struct{ X, y int } "a,omitempty,flow"
- }{struct{ X, y int }{1, 2}},
- "a: {x: 1}\n",
- }, {
- &struct {
- A struct{ X, y int } "a,omitempty,flow"
- }{struct{ X, y int }{0, 1}},
- "{}\n",
- }, {
- &struct {
- A float64 "a,omitempty"
- B float64 "b,omitempty"
- }{1, 0},
- "a: 1\n",
- },
- {
- &struct {
- T1 time.Time "t1,omitempty"
- T2 time.Time "t2,omitempty"
- T3 *time.Time "t3,omitempty"
- T4 *time.Time "t4,omitempty"
- }{
- T2: time.Date(2018, 1, 9, 10, 40, 47, 0, time.UTC),
- T4: newTime(time.Date(2098, 1, 9, 10, 40, 47, 0, time.UTC)),
- },
- "t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n",
- },
- // Nil interface that implements Marshaler.
- {
- map[string]yaml.Marshaler{
- "a": nil,
- },
- "a: null\n",
- },
-
- // Flow flag
- {
- &struct {
- A []int "a,flow"
- }{[]int{1, 2}},
- "a: [1, 2]\n",
- }, {
- &struct {
- A map[string]string "a,flow"
- }{map[string]string{"b": "c", "d": "e"}},
- "a: {b: c, d: e}\n",
- }, {
- &struct {
- A struct {
- B, D string
- } "a,flow"
- }{struct{ B, D string }{"c", "e"}},
- "a: {b: c, d: e}\n",
- }, {
- &struct {
- A string "a,flow"
- }{"b\nc"},
- "a: \"b\\nc\"\n",
- },
-
- // Unexported field
- {
- &struct {
- u int
- A int
- }{0, 1},
- "a: 1\n",
- },
-
- // Ignored field
- {
- &struct {
- A int
- B int "-"
- }{1, 2},
- "a: 1\n",
- },
-
- // Struct inlining
- {
- &struct {
- A int
- C inlineB `yaml:",inline"`
- }{1, inlineB{2, inlineC{3}}},
- "a: 1\nb: 2\nc: 3\n",
- },
- // Struct inlining as a pointer
- {
- &struct {
- A int
- C *inlineB `yaml:",inline"`
- }{1, &inlineB{2, inlineC{3}}},
- "a: 1\nb: 2\nc: 3\n",
- }, {
- &struct {
- A int
- C *inlineB `yaml:",inline"`
- }{1, nil},
- "a: 1\n",
- }, {
- &struct {
- A int
- D *inlineD `yaml:",inline"`
- }{1, &inlineD{&inlineC{3}, 4}},
- "a: 1\nc: 3\nd: 4\n",
- },
-
- // Map inlining
- {
- &struct {
- A int
- C map[string]int `yaml:",inline"`
- }{1, map[string]int{"b": 2, "c": 3}},
- "a: 1\nb: 2\nc: 3\n",
- },
-
- // Duration
- {
- map[string]time.Duration{"a": 3 * time.Second},
- "a: 3s\n",
- },
-
- // Issue #24: bug in map merging logic.
- {
- map[string]string{"a": "<foo>"},
- "a: <foo>\n",
- },
-
- // Issue #34: marshal unsupported base 60 floats quoted for compatibility
- // with old YAML 1.1 parsers.
- {
- map[string]string{"a": "1:1"},
- "a: \"1:1\"\n",
- },
-
- // Binary data.
- {
- map[string]string{"a": "\x00"},
- "a: \"\\0\"\n",
- }, {
- map[string]string{"a": "\x80\x81\x82"},
- "a: !!binary gIGC\n",
- }, {
- map[string]string{"a": strings.Repeat("\x90", 54)},
- "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
- },
-
- // Encode unicode as utf-8 rather than in escaped form.
- {
- map[string]string{"a": "你好"},
- "a: 你好\n",
- },
-
- // Support encoding.TextMarshaler.
- {
- map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
- "a: 1.2.3.4\n",
- },
- // time.Time gets a timestamp tag.
- {
- map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
- "a: 2015-02-24T18:19:39Z\n",
- },
- {
- map[string]*time.Time{"a": newTime(time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC))},
- "a: 2015-02-24T18:19:39Z\n",
- },
- {
- // This is confirmed to be properly decoded in Python (libyaml) without a timestamp tag.
- map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 123456789, time.FixedZone("FOO", -3*60*60))},
- "a: 2015-02-24T18:19:39.123456789-03:00\n",
- },
- // Ensure timestamp-like strings are quoted.
- {
- map[string]string{"a": "2015-02-24T18:19:39Z"},
- "a: \"2015-02-24T18:19:39Z\"\n",
- },
-
- // Ensure strings containing ": " are quoted (reported as PR #43, but not reproducible).
- {
- map[string]string{"a": "b: c"},
- "a: 'b: c'\n",
- },
-
- // Containing hash mark ('#') in string should be quoted
- {
- map[string]string{"a": "Hello #comment"},
- "a: 'Hello #comment'\n",
- },
- {
- map[string]string{"a": "你好 #comment"},
- "a: '你好 #comment'\n",
- },
-
- // Ensure MarshalYAML also gets called on the result of MarshalYAML itself.
- {
- &marshalerType{marshalerType{true}},
- "true\n",
- }, {
- &marshalerType{&marshalerType{true}},
- "true\n",
- },
-
- // Check indentation of maps inside sequences inside maps.
- {
- map[string]interface{}{"a": map[string]interface{}{"b": []map[string]int{{"c": 1, "d": 2}}}},
- "a:\n b:\n - c: 1\n d: 2\n",
- },
-
- // Strings with tabs were disallowed as literals (issue #471).
- {
- map[string]string{"a": "\tB\n\tC\n"},
- "a: |\n \tB\n \tC\n",
- },
-
- // Ensure that strings do not wrap
- {
- map[string]string{"a": "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 "},
- "a: 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 '\n",
- },
-
- // yaml.Node
- {
- &struct {
- Value yaml.Node
- }{
- yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "foo",
- Style: yaml.SingleQuotedStyle,
- },
- },
- "value: 'foo'\n",
- }, {
- yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "foo",
- Style: yaml.SingleQuotedStyle,
- },
- "'foo'\n",
- },
-
- // Enforced tagging with shorthand notation (issue #616).
- {
- &struct {
- Value yaml.Node
- }{
- yaml.Node{
- Kind: yaml.ScalarNode,
- Style: yaml.TaggedStyle,
- Value: "foo",
- Tag: "!!str",
- },
- },
- "value: !!str foo\n",
- }, {
- &struct {
- Value yaml.Node
- }{
- yaml.Node{
- Kind: yaml.MappingNode,
- Style: yaml.TaggedStyle,
- Tag: "!!map",
- },
- },
- "value: !!map {}\n",
- }, {
- &struct {
- Value yaml.Node
- }{
- yaml.Node{
- Kind: yaml.SequenceNode,
- Style: yaml.TaggedStyle,
- Tag: "!!seq",
- },
- },
- "value: !!seq []\n",
- },
-}
-
-func (s *S) TestMarshal(c *C) {
- defer os.Setenv("TZ", os.Getenv("TZ"))
- os.Setenv("TZ", "UTC")
- for i, item := range marshalTests {
- c.Logf("test %d: %q", i, item.data)
- data, err := yaml.Marshal(item.value)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, item.data)
- }
-}
-
-func (s *S) TestEncoderSingleDocument(c *C) {
- for i, item := range marshalTests {
- c.Logf("test %d. %q", i, item.data)
- var buf bytes.Buffer
- enc := yaml.NewEncoder(&buf)
- err := enc.Encode(item.value)
- c.Assert(err, Equals, nil)
- err = enc.Close()
- c.Assert(err, Equals, nil)
- c.Assert(buf.String(), Equals, item.data)
- }
-}
-
-func (s *S) TestEncoderMultipleDocuments(c *C) {
- var buf bytes.Buffer
- enc := yaml.NewEncoder(&buf)
- err := enc.Encode(map[string]string{"a": "b"})
- c.Assert(err, Equals, nil)
- err = enc.Encode(map[string]string{"c": "d"})
- c.Assert(err, Equals, nil)
- err = enc.Close()
- c.Assert(err, Equals, nil)
- c.Assert(buf.String(), Equals, "a: b\n---\nc: d\n")
-}
-
-func (s *S) TestEncoderWriteError(c *C) {
- enc := yaml.NewEncoder(errorWriter{})
- err := enc.Encode(map[string]string{"a": "b"})
- c.Assert(err, ErrorMatches, `yaml: write error: some write error`) // Data not flushed yet
-}
-
-type errorWriter struct{}
-
-func (errorWriter) Write([]byte) (int, error) {
- return 0, fmt.Errorf("some write error")
-}
-
-var marshalErrorTests = []struct {
- value interface{}
- error string
- panic string
-}{{
- value: &struct {
- B int
- inlineB ",inline"
- }{1, inlineB{2, inlineC{3}}},
- panic: `duplicated key 'b' in struct struct \{ B int; .*`,
-}, {
- value: &struct {
- A int
- B map[string]int ",inline"
- }{1, map[string]int{"a": 2}},
- panic: `cannot have key "a" in inlined map: conflicts with struct field`,
-}}
-
-func (s *S) TestMarshalErrors(c *C) {
- for _, item := range marshalErrorTests {
- if item.panic != "" {
- c.Assert(func() { yaml.Marshal(item.value) }, PanicMatches, item.panic)
- } else {
- _, err := yaml.Marshal(item.value)
- c.Assert(err, ErrorMatches, item.error)
- }
- }
-}
-
-func (s *S) TestMarshalTypeCache(c *C) {
- var data []byte
- var err error
- func() {
- type T struct{ A int }
- data, err = yaml.Marshal(&T{})
- c.Assert(err, IsNil)
- }()
- func() {
- type T struct{ B int }
- data, err = yaml.Marshal(&T{})
- c.Assert(err, IsNil)
- }()
- c.Assert(string(data), Equals, "b: 0\n")
-}
-
-var marshalerTests = []struct {
- data string
- value interface{}
-}{
- {"_:\n hi: there\n", map[interface{}]interface{}{"hi": "there"}},
- {"_:\n - 1\n - A\n", []interface{}{1, "A"}},
- {"_: 10\n", 10},
- {"_: null\n", nil},
- {"_: BAR!\n", "BAR!"},
-}
-
-type marshalerType struct {
- value interface{}
-}
-
-func (o marshalerType) MarshalText() ([]byte, error) {
- panic("MarshalText called on type with MarshalYAML")
-}
-
-func (o marshalerType) MarshalYAML() (interface{}, error) {
- return o.value, nil
-}
-
-type marshalerValue struct {
- Field marshalerType "_"
-}
-
-func (s *S) TestMarshaler(c *C) {
- for _, item := range marshalerTests {
- obj := &marshalerValue{}
- obj.Field.value = item.value
- data, err := yaml.Marshal(obj)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, string(item.data))
- }
-}
-
-func (s *S) TestMarshalerWholeDocument(c *C) {
- obj := &marshalerType{}
- obj.value = map[string]string{"hello": "world!"}
- data, err := yaml.Marshal(obj)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, "hello: world!\n")
-}
-
-type failingMarshaler struct{}
-
-func (ft *failingMarshaler) MarshalYAML() (interface{}, error) {
- return nil, failingErr
-}
-
-func (s *S) TestMarshalerError(c *C) {
- _, err := yaml.Marshal(&failingMarshaler{})
- c.Assert(err, Equals, failingErr)
-}
-
-func (s *S) TestSetIndent(c *C) {
- var buf bytes.Buffer
- enc := yaml.NewEncoder(&buf)
- enc.SetIndent(8)
- err := enc.Encode(map[string]interface{}{"a": map[string]interface{}{"b": map[string]string{"c": "d"}}})
- c.Assert(err, Equals, nil)
- err = enc.Close()
- c.Assert(err, Equals, nil)
- c.Assert(buf.String(), Equals, "a:\n b:\n c: d\n")
-}
-
-func (s *S) TestSortedOutput(c *C) {
- order := []interface{}{
- false,
- true,
- 1,
- uint(1),
- 1.0,
- 1.1,
- 1.2,
- 2,
- uint(2),
- 2.0,
- 2.1,
- "",
- ".1",
- ".2",
- ".a",
- "1",
- "2",
- "a!10",
- "a/0001",
- "a/002",
- "a/3",
- "a/10",
- "a/11",
- "a/0012",
- "a/100",
- "a~10",
- "ab/1",
- "b/1",
- "b/01",
- "b/2",
- "b/02",
- "b/3",
- "b/03",
- "b1",
- "b01",
- "b3",
- "c2.10",
- "c10.2",
- "d1",
- "d7",
- "d7abc",
- "d12",
- "d12a",
- "e2b",
- "e4b",
- "e21a",
- }
- m := make(map[interface{}]int)
- for _, k := range order {
- m[k] = 1
- }
- data, err := yaml.Marshal(m)
- c.Assert(err, IsNil)
- out := "\n" + string(data)
- last := 0
- for i, k := range order {
- repr := fmt.Sprint(k)
- if s, ok := k.(string); ok {
- if _, err = strconv.ParseFloat(repr, 32); s == "" || err == nil {
- repr = `"` + repr + `"`
- }
- }
- index := strings.Index(out, "\n"+repr+":")
- if index == -1 {
- c.Fatalf("%#v is not in the output: %#v", k, out)
- }
- if index < last {
- c.Fatalf("%#v was generated before %#v: %q", k, order[i-1], out)
- }
- last = index
- }
-}
-
-func newTime(t time.Time) *time.Time {
- return &t
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/example_embedded_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/example_embedded_test.go
deleted file mode 100644
index 9d17398a51f103f9a7dd8b3b11478cf83a39ed6a..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/example_embedded_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml_test
-
-import (
- "fmt"
- "log"
-
- "gopkg.in/yaml.v3"
-)
-
-// An example showing how to unmarshal embedded
-// structs from YAML.
-
-type StructA struct {
- A string `yaml:"a"`
-}
-
-type StructB struct {
- // Embedded structs are not treated as embedded in YAML by default. To do that,
- // add the ",inline" annotation below
- StructA `yaml:",inline"`
- B string `yaml:"b"`
-}
-
-var data = `
-a: a string from struct A
-b: a string from struct B
-`
-
-func ExampleUnmarshal_embedded() {
- var b StructB
-
- err := yaml.Unmarshal([]byte(data), &b)
- if err != nil {
- log.Fatalf("cannot unmarshal data: %v", err)
- }
- fmt.Println(b.A)
- fmt.Println(b.B)
- // Output:
- // a string from struct A
- // a string from struct B
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/go.mod b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/go.mod
deleted file mode 100644
index f407ea3213edc12392275945f8291202b0712c9d..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/go.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module "gopkg.in/yaml.v3"
-
-require (
- "gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405
-)
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/limit_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/limit_test.go
deleted file mode 100644
index 07a3cbd4ba5d2915f6b71cbf041a05dd407c12fe..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/limit_test.go
+++ /dev/null
@@ -1,128 +0,0 @@
-package yaml_test
-
-import (
- "strings"
- "testing"
-
- . "gopkg.in/check.v1"
- "gopkg.in/yaml.v3"
-)
-
-var limitTests = []struct {
- name string
- data []byte
- error string
-}{
- {
- name: "1000kb of maps with 100 aliases",
- data: []byte(`{a: &a [{a}` + strings.Repeat(`,{a}`, 1000*1024/4-100) + `], b: &b [*a` + strings.Repeat(`,*a`, 99) + `]}`),
- error: "yaml: document contains excessive aliasing",
- }, {
- name: "1000kb of deeply nested slices",
- data: []byte(strings.Repeat(`[`, 1000*1024)),
- error: "yaml: exceeded max depth of 10000",
- }, {
- name: "1000kb of deeply nested maps",
- data: []byte("x: " + strings.Repeat(`{`, 1000*1024)),
- error: "yaml: exceeded max depth of 10000",
- }, {
- name: "1000kb of deeply nested indents",
- data: []byte(strings.Repeat(`- `, 1000*1024)),
- error: "yaml: exceeded max depth of 10000",
- }, {
- name: "1000kb of 1000-indent lines",
- data: []byte(strings.Repeat(strings.Repeat(`- `, 1000)+"\n", 1024/2)),
- },
- {name: "1kb of maps", data: []byte(`a: &a [{a}` + strings.Repeat(`,{a}`, 1*1024/4-1) + `]`)},
- {name: "10kb of maps", data: []byte(`a: &a [{a}` + strings.Repeat(`,{a}`, 10*1024/4-1) + `]`)},
- {name: "100kb of maps", data: []byte(`a: &a [{a}` + strings.Repeat(`,{a}`, 100*1024/4-1) + `]`)},
- {name: "1000kb of maps", data: []byte(`a: &a [{a}` + strings.Repeat(`,{a}`, 1000*1024/4-1) + `]`)},
- {name: "1000kb slice nested at max-depth", data: []byte(strings.Repeat(`[`, 10000) + `1` + strings.Repeat(`,1`, 1000*1024/2-20000-1) + strings.Repeat(`]`, 10000))},
- {name: "1000kb slice nested in maps at max-depth", data: []byte("{a,b:\n" + strings.Repeat(" {a,b:", 10000-2) + ` [1` + strings.Repeat(",1", 1000*1024/2-6*10000-1) + `]` + strings.Repeat(`}`, 10000-1))},
- {name: "1000kb of 10000-nested lines", data: []byte(strings.Repeat(`- `+strings.Repeat(`[`, 10000)+strings.Repeat(`]`, 10000)+"\n", 1000*1024/20000))},
-}
-
-func (s *S) TestLimits(c *C) {
- if testing.Short() {
- return
- }
- for _, tc := range limitTests {
- var v interface{}
- err := yaml.Unmarshal(tc.data, &v)
- if len(tc.error) > 0 {
- c.Assert(err, ErrorMatches, tc.error, Commentf("testcase: %s", tc.name))
- } else {
- c.Assert(err, IsNil, Commentf("testcase: %s", tc.name))
- }
- }
-}
-
-func Benchmark1000KB100Aliases(b *testing.B) {
- benchmark(b, "1000kb of maps with 100 aliases")
-}
-func Benchmark1000KBDeeplyNestedSlices(b *testing.B) {
- benchmark(b, "1000kb of deeply nested slices")
-}
-func Benchmark1000KBDeeplyNestedMaps(b *testing.B) {
- benchmark(b, "1000kb of deeply nested maps")
-}
-func Benchmark1000KBDeeplyNestedIndents(b *testing.B) {
- benchmark(b, "1000kb of deeply nested indents")
-}
-func Benchmark1000KB1000IndentLines(b *testing.B) {
- benchmark(b, "1000kb of 1000-indent lines")
-}
-func Benchmark1KBMaps(b *testing.B) {
- benchmark(b, "1kb of maps")
-}
-func Benchmark10KBMaps(b *testing.B) {
- benchmark(b, "10kb of maps")
-}
-func Benchmark100KBMaps(b *testing.B) {
- benchmark(b, "100kb of maps")
-}
-func Benchmark1000KBMaps(b *testing.B) {
- benchmark(b, "1000kb of maps")
-}
-
-func BenchmarkDeepSlice(b *testing.B) {
- benchmark(b, "1000kb slice nested at max-depth")
-}
-
-func BenchmarkDeepFlow(b *testing.B) {
- benchmark(b, "1000kb slice nested in maps at max-depth")
-}
-
-func Benchmark1000KBMaxDepthNested(b *testing.B) {
- benchmark(b, "1000kb of 10000-nested lines")
-}
-
-func benchmark(b *testing.B, name string) {
- for _, t := range limitTests {
- if t.name != name {
- continue
- }
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- var v interface{}
- err := yaml.Unmarshal(t.data, &v)
- if len(t.error) > 0 {
- if err == nil {
- b.Errorf("expected error, got none")
- } else if err.Error() != t.error {
- b.Errorf("expected error '%s', got '%s'", t.error, err.Error())
- }
- } else {
- if err != nil {
- b.Errorf("unexpected error: %v", err)
- }
- }
- }
-
- return
- }
-
- b.Errorf("testcase %q not found", name)
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/node_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/node_test.go
deleted file mode 100644
index b7d0c9a30d5daccb687447c4606584959a70b1c7..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/node_test.go
+++ /dev/null
@@ -1,2886 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml_test
-
-import (
- "bytes"
- "fmt"
- "os"
-
- . "gopkg.in/check.v1"
- "gopkg.in/yaml.v3"
- "io"
- "strings"
-)
-
-var nodeTests = []struct {
- yaml string
- node yaml.Node
-}{
- {
- "null\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "null",
- Tag: "!!null",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "[encode]null\n",
- yaml.Node{},
- }, {
- "foo\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "foo",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "\"foo\"\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.DoubleQuotedStyle,
- Value: "foo",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "'foo'\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.SingleQuotedStyle,
- Value: "foo",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "!!str 123\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.TaggedStyle,
- Value: "123",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- // Although the node isn't TaggedStyle, dropping the tag would change the value.
- "[encode]!!binary gIGC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "gIGC",
- Tag: "!!binary",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- // Item doesn't have a tag, but needs to be binary encoded due to its content.
- "[encode]!!binary gIGC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "\x80\x81\x82",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- // Same, but with strings we can just quote them.
- "[encode]\"123\"\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "123",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "!tag:something 123\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.TaggedStyle,
- Value: "123",
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "[encode]!tag:something 123\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "123",
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "!tag:something {}\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Style: yaml.TaggedStyle | yaml.FlowStyle,
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "[encode]!tag:something {}\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Style: yaml.FlowStyle,
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "!tag:something []\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Style: yaml.TaggedStyle | yaml.FlowStyle,
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "[encode]!tag:something []\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Style: yaml.FlowStyle,
- Tag: "!tag:something",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "''\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.SingleQuotedStyle,
- Value: "",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "|\n foo\n bar\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: yaml.LiteralStyle,
- Value: "foo\nbar\n",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "true\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "-10\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "-10",
- Tag: "!!int",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "4294967296\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "4294967296",
- Tag: "!!int",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "0.1000\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "0.1000",
- Tag: "!!float",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "-.inf\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "-.inf",
- Tag: "!!float",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- ".nan\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: ".nan",
- Tag: "!!float",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "{}\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Style: yaml.FlowStyle,
- Value: "",
- Tag: "!!map",
- Line: 1,
- Column: 1,
- }},
- },
- }, {
- "a: b c\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Value: "",
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Value: "b c",
- Tag: "!!str",
- Line: 1,
- Column: 4,
- }},
- }},
- },
- }, {
- "a:\n b: c\n d: e\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Value: "c",
- Tag: "!!str",
- Line: 2,
- Column: 6,
- }, {
- Kind: yaml.ScalarNode,
- Value: "d",
- Tag: "!!str",
- Line: 3,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Value: "e",
- Tag: "!!str",
- Line: 3,
- Column: 6,
- }},
- }},
- }},
- },
- }, {
- "a:\n - b: c\n d: e\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 5,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Value: "c",
- Tag: "!!str",
- Line: 2,
- Column: 8,
- }, {
- Kind: yaml.ScalarNode,
- Value: "d",
- Tag: "!!str",
- Line: 3,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Value: "e",
- Tag: "!!str",
- Line: 3,
- Column: 8,
- }},
- }},
- }},
- }},
- },
- }, {
- "a: # AI\n - b\nc:\n - d\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "a",
- LineComment: "# AI",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "b",
- Line: 2,
- Column: 5,
- }},
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "c",
- Line: 3,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "d",
- Line: 4,
- Column: 5,
- }},
- Line: 4,
- Column: 3,
- }},
- }},
- },
- }, {
- "[decode]a:\n # HM\n - # HB1\n # HB2\n b: # IB\n c # IC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: 0x0,
- Tag: "!!str",
- Value: "a",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 3,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- HeadComment: "# HM",
- Line: 5,
- Column: 5,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "b",
- HeadComment: "# HB1\n# HB2",
- LineComment: "# IB",
- Line: 5,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "c",
- LineComment: "# IC",
- Line: 6,
- Column: 7,
- }},
- }},
- }},
- }},
- },
- }, {
- // When encoding the value above, it loses b's inline comment.
- "[encode]a:\n # HM\n - # HB1\n # HB2\n b: c # IC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Style: 0x0,
- Tag: "!!str",
- Value: "a",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 3,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- HeadComment: "# HM",
- Line: 5,
- Column: 5,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "b",
- HeadComment: "# HB1\n# HB2",
- LineComment: "# IB",
- Line: 5,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "c",
- LineComment: "# IC",
- Line: 6,
- Column: 7,
- }},
- }},
- }},
- }},
- },
- }, {
- // Multiple cases of comment inlining next to mapping keys.
- "a: | # IA\n str\nb: >- # IB\n str\nc: # IC\n - str\nd: # ID\n str:\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "a",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Style: yaml.LiteralStyle,
- Tag: "!!str",
- Value: "str\n",
- LineComment: "# IA",
- Line: 1,
- Column: 4,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "b",
- Line: 3,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Style: yaml.FoldedStyle,
- Tag: "!!str",
- Value: "str",
- LineComment: "# IB",
- Line: 3,
- Column: 4,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "c",
- LineComment: "# IC",
- Line: 5,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 6,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "str",
- Line: 6,
- Column: 5,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "d",
- LineComment: "# ID",
- Line: 7,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 8,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "str",
- Line: 8,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!null",
- Line: 8,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Indentless sequence.
- "[decode]a:\n# HM\n- # HB1\n # HB2\n b: # IB\n c # IC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "a",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 3,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- HeadComment: "# HM",
- Line: 5,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "b",
- HeadComment: "# HB1\n# HB2",
- LineComment: "# IB",
- Line: 5,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "c",
- LineComment: "# IC",
- Line: 6,
- Column: 5,
- }},
- }},
- }},
- }},
- },
- }, {
- "- a\n- b\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Value: "",
- Tag: "!!seq",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 3,
- }},
- }},
- },
- }, {
- "- a\n- - b\n - c\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 3,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Value: "c",
- Tag: "!!str",
- Line: 3,
- Column: 5,
- }},
- }},
- }},
- },
- }, {
- "[a, b]\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Style: yaml.FlowStyle,
- Value: "",
- Tag: "!!seq",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 2,
- }, {
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 1,
- Column: 5,
- }},
- }},
- },
- }, {
- "- a\n- [b, c]\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 3,
- }, {
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Style: yaml.FlowStyle,
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 4,
- }, {
- Kind: yaml.ScalarNode,
- Value: "c",
- Tag: "!!str",
- Line: 2,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- "a: &x 1\nb: &y 2\nc: *x\nd: *y\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Line: 1,
- Column: 1,
- Tag: "!!map",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- Line: 1,
- Column: 1,
- },
- saveNode("x", &yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "1",
- Tag: "!!int",
- Anchor: "x",
- Line: 1,
- Column: 4,
- }),
- {
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- Line: 2,
- Column: 1,
- },
- saveNode("y", &yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "2",
- Tag: "!!int",
- Anchor: "y",
- Line: 2,
- Column: 4,
- }),
- {
- Kind: yaml.ScalarNode,
- Value: "c",
- Tag: "!!str",
- Line: 3,
- Column: 1,
- }, {
- Kind: yaml.AliasNode,
- Value: "x",
- Alias: dropNode("x"),
- Line: 3,
- Column: 4,
- }, {
- Kind: yaml.ScalarNode,
- Value: "d",
- Tag: "!!str",
- Line: 4,
- Column: 1,
- }, {
- Kind: yaml.AliasNode,
- Value: "y",
- Tag: "",
- Alias: dropNode("y"),
- Line: 4,
- Column: 4,
- }},
- }},
- },
- }, {
-
- "# One\n# Two\ntrue # Three\n# Four\n# Five\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 3,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 3,
- Column: 1,
- HeadComment: "# One\n# Two",
- LineComment: "# Three",
- FootComment: "# Four\n# Five",
- }},
- },
- }, {
-
- "# š\ntrue # š\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 2,
- Column: 1,
- HeadComment: "# š",
- LineComment: "# š",
- }},
- },
- }, {
-
- "[decode]\n# One\n\n# Two\n\n# Three\ntrue # Four\n# Five\n\n# Six\n\n# Seven\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 7,
- Column: 1,
- HeadComment: "# One\n\n# Two",
- FootComment: "# Six\n\n# Seven",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 7,
- Column: 1,
- HeadComment: "# Three",
- LineComment: "# Four",
- FootComment: "# Five",
- }},
- },
- }, {
- // Write out the pound character if missing from comments.
- "[encode]# One\n# Two\ntrue # Three\n# Four\n# Five\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 3,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 3,
- Column: 1,
- HeadComment: "One\nTwo\n",
- LineComment: "Three\n",
- FootComment: "Four\nFive\n",
- }},
- },
- }, {
- "[encode]# One\n# Two\ntrue # Three\n# Four\n# Five\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 3,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 3,
- Column: 1,
- HeadComment: " One\n Two",
- LineComment: " Three",
- FootComment: " Four\n Five",
- }},
- },
- }, {
- "# DH1\n\n# DH2\n\n# H1\n# H2\ntrue # I\n# F1\n# F2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 7,
- Column: 1,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "true",
- Tag: "!!bool",
- Line: 7,
- Column: 1,
- HeadComment: "# H1\n# H2",
- LineComment: "# I",
- FootComment: "# F1\n# F2",
- }},
- },
- }, {
- "# DH1\n\n# DH2\n\n# HA1\n# HA2\nka: va # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\nkb: vb # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 7,
- Column: 1,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Line: 7,
- Column: 1,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1\n# HA2",
- FootComment: "# FA1\n# FA2",
- }, {
- Kind: yaml.ScalarNode,
- Line: 7,
- Column: 5,
- Tag: "!!str",
- Value: "va",
- LineComment: "# IA",
- }, {
- Kind: yaml.ScalarNode,
- Line: 13,
- Column: 1,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1\n# HB2",
- FootComment: "# FB1\n# FB2",
- }, {
- Kind: yaml.ScalarNode,
- Line: 13,
- Column: 5,
- Tag: "!!str",
- Value: "vb",
- LineComment: "# IB",
- }},
- }},
- },
- }, {
- "# DH1\n\n# DH2\n\n# HA1\n# HA2\n- la # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\n- lb # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 7,
- Column: 1,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 7,
- Column: 3,
- Value: "la",
- HeadComment: "# HA1\n# HA2",
- LineComment: "# IA",
- FootComment: "# FA1\n# FA2",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 13,
- Column: 3,
- Value: "lb",
- HeadComment: "# HB1\n# HB2",
- LineComment: "# IB",
- FootComment: "# FB1\n# FB2",
- }},
- }},
- },
- }, {
- "# DH1\n\n- la # IA\n# HB1\n- lb\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 3,
- Column: 1,
- HeadComment: "# DH1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 3,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 3,
- Column: 3,
- Value: "la",
- LineComment: "# IA",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 5,
- Column: 3,
- Value: "lb",
- HeadComment: "# HB1",
- }},
- }},
- },
- }, {
- "- la # IA\n- lb # IB\n- lc # IC\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 1,
- Column: 3,
- Value: "la",
- LineComment: "# IA",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 2,
- Column: 3,
- Value: "lb",
- LineComment: "# IB",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 3,
- Column: 3,
- Value: "lc",
- LineComment: "# IC",
- }},
- }},
- },
- }, {
- "# DH1\n\n# HL1\n- - la\n # HB1\n - lb\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 4,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 4,
- Column: 3,
- HeadComment: "# HL1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 4,
- Column: 5,
- Value: "la",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 5,
- Value: "lb",
- HeadComment: "# HB1",
- }},
- }},
- }},
- },
- }, {
- "# DH1\n\n# HL1\n- # HA1\n - la\n # HB1\n - lb\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 4,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 5,
- Column: 3,
- HeadComment: "# HL1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 5,
- Column: 5,
- Value: "la",
- HeadComment: "# HA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 7,
- Column: 5,
- Value: "lb",
- HeadComment: "# HB1",
- }},
- }},
- }},
- },
- }, {
- "[decode]# DH1\n\n# HL1\n- # HA1\n\n - la\n # HB1\n - lb\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 4,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 6,
- Column: 3,
- HeadComment: "# HL1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 5,
- Value: "la",
- HeadComment: "# HA1\n",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 8,
- Column: 5,
- Value: "lb",
- HeadComment: "# HB1",
- }},
- }},
- }},
- },
- }, {
- "# DH1\n\n# HA1\nka:\n # HB1\n kb:\n # HC1\n # HC2\n - lc # IC\n # FC1\n # FC2\n\n # HD1\n - ld # ID\n # FD1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 4,
- Column: 1,
- Value: "ka",
- HeadComment: "# HA1",
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 6,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "kb",
- HeadComment: "# HB1",
- }, {
- Kind: yaml.SequenceNode,
- Line: 9,
- Column: 5,
- Tag: "!!seq",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 9,
- Column: 7,
- Value: "lc",
- HeadComment: "# HC1\n# HC2",
- LineComment: "# IC",
- FootComment: "# FC1\n# FC2",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 14,
- Column: 7,
- Value: "ld",
- HeadComment: "# HD1",
-
- LineComment: "# ID",
- FootComment: "# FD1",
- }},
- }},
- }},
- }},
- },
- }, {
- "# DH1\n\n# HA1\nka:\n # HB1\n kb:\n # HC1\n # HC2\n - lc # IC\n # FC1\n # FC2\n\n # HD1\n - ld # ID\n # FD1\nke: ve\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 4,
- Column: 1,
- Value: "ka",
- HeadComment: "# HA1",
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 6,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "kb",
- HeadComment: "# HB1",
- }, {
- Kind: yaml.SequenceNode,
- Line: 9,
- Column: 5,
- Tag: "!!seq",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 9,
- Column: 7,
- Value: "lc",
- HeadComment: "# HC1\n# HC2",
- LineComment: "# IC",
- FootComment: "# FC1\n# FC2",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 14,
- Column: 7,
- Value: "ld",
- HeadComment: "# HD1",
- LineComment: "# ID",
- FootComment: "# FD1",
- }},
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 16,
- Column: 1,
- Value: "ke",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 16,
- Column: 5,
- Value: "ve",
- }},
- }},
- },
- }, {
- "# DH1\n\n# DH2\n\n# HA1\n# HA2\nka:\n # HB1\n # HB2\n kb:\n" +
- " # HC1\n # HC2\n kc:\n # HD1\n # HD2\n kd: vd\n # FD1\n # FD2\n" +
- " # FC1\n # FC2\n # FB1\n # FB2\n# FA1\n# FA2\n\n# HE1\n# HE2\nke: ve\n# FE1\n# FE2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1\n# HA2",
- FootComment: "# FA1\n# FA2",
- Line: 7,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 10,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1\n# HB2",
- FootComment: "# FB1\n# FB2",
- Line: 10,
- Column: 3,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 13,
- Column: 5,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1\n# HC2",
- FootComment: "# FC1\n# FC2",
- Line: 13,
- Column: 5,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 16,
- Column: 7,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kd",
- HeadComment: "# HD1\n# HD2",
- FootComment: "# FD1\n# FD2",
- Line: 16,
- Column: 7,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vd",
- Line: 16,
- Column: 11,
- }},
- }},
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ke",
- HeadComment: "# HE1\n# HE2",
- FootComment: "# FE1\n# FE2",
- Line: 28,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ve",
- Line: 28,
- Column: 5,
- }},
- }},
- },
- }, {
- // Same as above but indenting ke in so it's also part of ka's value.
- "# DH1\n\n# DH2\n\n# HA1\n# HA2\nka:\n # HB1\n # HB2\n kb:\n" +
- " # HC1\n # HC2\n kc:\n # HD1\n # HD2\n kd: vd\n # FD1\n # FD2\n" +
- " # FC1\n # FC2\n # FB1\n # FB2\n\n # HE1\n # HE2\n ke: ve\n # FE1\n # FE2\n# FA1\n# FA2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1\n# HA2",
- FootComment: "# FA1\n# FA2",
- Line: 7,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 10,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1\n# HB2",
- FootComment: "# FB1\n# FB2",
- Line: 10,
- Column: 3,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 13,
- Column: 5,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1\n# HC2",
- FootComment: "# FC1\n# FC2",
- Line: 13,
- Column: 5,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 16,
- Column: 7,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kd",
- HeadComment: "# HD1\n# HD2",
- FootComment: "# FD1\n# FD2",
- Line: 16,
- Column: 7,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vd",
- Line: 16,
- Column: 11,
- }},
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ke",
- HeadComment: "# HE1\n# HE2",
- FootComment: "# FE1\n# FE2",
- Line: 26,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ve",
- Line: 26,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Decode only due to lack of newline at the end.
- "[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Same as above, but with newline at the end.
- "# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Same as above, but without FB1.
- "# HA1\nka:\n # HB1\n kb: vb\n# FA1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Same as above, but with two newlines at the end. Decode-only for that.
- "[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# FA1\n\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- // Similar to above, but make HB1 look more like a footer of ka.
- "[decode]# HA1\nka:\n# HB1\n\n kb: vb\n# FA1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 5,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1\n",
- Line: 5,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 5,
- Column: 7,
- }},
- }},
- }},
- },
- }, {
- "ka:\n kb: vb\n# FA1\n\nkc: vc\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- FootComment: "# FA1",
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 2,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- Line: 5,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 5,
- Column: 5,
- }},
- }},
- },
- }, {
- "ka:\n kb: vb\n# HC1\nkc: vc\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 2,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1",
- Line: 4,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 4,
- Column: 5,
- }},
- }},
- },
- }, {
- // Decode only due to empty line before HC1.
- "[decode]ka:\n kb: vb\n\n# HC1\nkc: vc\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 2,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1",
- Line: 5,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 5,
- Column: 5,
- }},
- }},
- },
- }, {
- // Decode-only due to empty lines around HC1.
- "[decode]ka:\n kb: vb\n\n# HC1\n\nkc: vc\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 2,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1\n",
- Line: 6,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 6,
- Column: 5,
- }},
- }},
- },
- }, {
- "ka: # IA\n kb: # IB\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- LineComment: "# IA",
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- LineComment: "# IB",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!null",
- Line: 2,
- Column: 6,
- }},
- }},
- }},
- },
- }, {
- "# HA1\nka:\n # HB1\n kb: vb\n # FB1\n# HC1\n# HC2\nkc: vc\n# FC1\n# FC2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1\n# HC2",
- FootComment: "# FC1\n# FC2",
- Line: 8,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 8,
- Column: 5,
- }},
- }},
- },
- }, {
- // Same as above, but decode only due to empty line between ka's value and kc's headers.
- "[decode]# HA1\nka:\n # HB1\n kb: vb\n # FB1\n\n# HC1\n# HC2\nkc: vc\n# FC1\n# FC2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- HeadComment: "# HA1",
- Line: 2,
- Column: 1,
- }, {
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 4,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 4,
- Column: 3,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vb",
- Line: 4,
- Column: 7,
- }},
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kc",
- HeadComment: "# HC1\n# HC2",
- FootComment: "# FC1\n# FC2",
- Line: 9,
- Column: 1,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "vc",
- Line: 9,
- Column: 5,
- }},
- }},
- },
- }, {
- "# H1\n[la, lb] # I\n# F1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 2,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Style: yaml.FlowStyle,
- Line: 2,
- Column: 1,
- HeadComment: "# H1",
- LineComment: "# I",
- FootComment: "# F1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 2,
- Column: 2,
- Value: "la",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 2,
- Column: 6,
- Value: "lb",
- }},
- }},
- },
- }, {
- "# DH1\n\n# SH1\n[\n # HA1\n la, # IA\n # FA1\n\n # HB1\n lb, # IB\n # FB1\n]\n# SF1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Style: yaml.FlowStyle,
- Line: 4,
- Column: 1,
- HeadComment: "# SH1",
- FootComment: "# SF1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "la",
- HeadComment: "# HA1",
- LineComment: "# IA",
- FootComment: "# FA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 3,
- Value: "lb",
- HeadComment: "# HB1",
- LineComment: "# IB",
- FootComment: "# FB1",
- }},
- }},
- },
- }, {
- // Same as above, but with extra newlines before FB1 and FB2
- "[decode]# DH1\n\n# SH1\n[\n # HA1\n la, # IA\n # FA1\n\n # HB1\n lb, # IB\n\n\n # FB1\n\n# FB2\n]\n# SF1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Style: yaml.FlowStyle,
- Line: 4,
- Column: 1,
- HeadComment: "# SH1",
- FootComment: "# SF1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "la",
- HeadComment: "# HA1",
- LineComment: "# IA",
- FootComment: "# FA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 3,
- Value: "lb",
- HeadComment: "# HB1",
- LineComment: "# IB",
- FootComment: "# FB1\n\n# FB2",
- }},
- }},
- },
- }, {
- "# DH1\n\n# SH1\n[\n # HA1\n la,\n # FA1\n\n # HB1\n lb,\n # FB1\n]\n# SF1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Style: yaml.FlowStyle,
- Line: 4,
- Column: 1,
- HeadComment: "# SH1",
- FootComment: "# SF1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "la",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 3,
- Value: "lb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- }},
- }},
- },
- }, {
- "ka:\n kb: [\n # HA1\n la,\n # FA1\n\n # HB1\n lb,\n # FB1\n ]\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Line: 1,
- Column: 1,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "ka",
- Line: 1,
- Column: 1,
- }, {
- Kind: 0x4,
- Tag: "!!map",
- Line: 2,
- Column: 3,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "kb",
- Line: 2,
- Column: 3,
- }, {
- Kind: yaml.SequenceNode,
- Style: 0x20,
- Tag: "!!seq",
- Line: 2,
- Column: 7,
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "la",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- Line: 4,
- Column: 5,
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Value: "lb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- Line: 8,
- Column: 5,
- }},
- }},
- }},
- }},
- },
- }, {
- "# DH1\n\n# MH1\n{\n # HA1\n ka: va, # IA\n # FA1\n\n # HB1\n kb: vb, # IB\n # FB1\n}\n# MF1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Style: yaml.FlowStyle,
- Line: 4,
- Column: 1,
- HeadComment: "# MH1",
- FootComment: "# MF1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 7,
- Value: "va",
- LineComment: "# IA",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 3,
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 7,
- Value: "vb",
- LineComment: "# IB",
- }},
- }},
- },
- }, {
- "# DH1\n\n# MH1\n{\n # HA1\n ka: va,\n # FA1\n\n # HB1\n kb: vb,\n # FB1\n}\n# MF1\n\n# DF1\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 4,
- Column: 1,
- HeadComment: "# DH1",
- FootComment: "# DF1",
- Content: []*yaml.Node{{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Style: yaml.FlowStyle,
- Line: 4,
- Column: 1,
- HeadComment: "# MH1",
- FootComment: "# MF1",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 3,
- Value: "ka",
- HeadComment: "# HA1",
- FootComment: "# FA1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 6,
- Column: 7,
- Value: "va",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 3,
- Value: "kb",
- HeadComment: "# HB1",
- FootComment: "# FB1",
- }, {
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 10,
- Column: 7,
- Value: "vb",
- }},
- }},
- },
- }, {
- "# DH1\n\n# DH2\n\n# HA1\n# HA2\n- &x la # IA\n# FA1\n# FA2\n\n# HB1\n# HB2\n- *x # IB\n# FB1\n# FB2\n\n# DF1\n\n# DF2\n",
- yaml.Node{
- Kind: yaml.DocumentNode,
- Line: 7,
- Column: 1,
- HeadComment: "# DH1\n\n# DH2",
- FootComment: "# DF1\n\n# DF2",
- Content: []*yaml.Node{{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Line: 7,
- Column: 1,
- Content: []*yaml.Node{
- saveNode("x", &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: "!!str",
- Line: 7,
- Column: 3,
- Value: "la",
- HeadComment: "# HA1\n# HA2",
- LineComment: "# IA",
- FootComment: "# FA1\n# FA2",
- Anchor: "x",
- }), {
- Kind: yaml.AliasNode,
- Line: 13,
- Column: 3,
- Value: "x",
- Alias: dropNode("x"),
- HeadComment: "# HB1\n# HB2",
- LineComment: "# IB",
- FootComment: "# FB1\n# FB2",
- },
- },
- }},
- },
- },
-}
-
-func (s *S) TestNodeRoundtrip(c *C) {
- defer os.Setenv("TZ", os.Getenv("TZ"))
- os.Setenv("TZ", "UTC")
- for i, item := range nodeTests {
- c.Logf("test %d: %q", i, item.yaml)
-
- if strings.Contains(item.yaml, "#") {
- var buf bytes.Buffer
- fprintComments(&buf, &item.node, " ")
- c.Logf(" expected comments:\n%s", buf.Bytes())
- }
-
- decode := true
- encode := true
-
- testYaml := item.yaml
- if s := strings.TrimPrefix(testYaml, "[decode]"); s != testYaml {
- encode = false
- testYaml = s
- }
- if s := strings.TrimPrefix(testYaml, "[encode]"); s != testYaml {
- decode = false
- testYaml = s
- }
-
- if decode {
- var node yaml.Node
- err := yaml.Unmarshal([]byte(testYaml), &node)
- c.Assert(err, IsNil)
- if strings.Contains(item.yaml, "#") {
- var buf bytes.Buffer
- fprintComments(&buf, &node, " ")
- c.Logf(" obtained comments:\n%s", buf.Bytes())
- }
- c.Assert(&node, DeepEquals, &item.node)
- }
- if encode {
- node := deepCopyNode(&item.node, nil)
- buf := bytes.Buffer{}
- enc := yaml.NewEncoder(&buf)
- enc.SetIndent(2)
- err := enc.Encode(node)
- c.Assert(err, IsNil)
- err = enc.Close()
- c.Assert(err, IsNil)
- c.Assert(buf.String(), Equals, testYaml)
-
- // Ensure there were no mutations to the tree.
- c.Assert(node, DeepEquals, &item.node)
- }
- }
-}
-
-func deepCopyNode(node *yaml.Node, cache map[*yaml.Node]*yaml.Node) *yaml.Node {
- if n, ok := cache[node]; ok {
- return n
- }
- if cache == nil {
- cache = make(map[*yaml.Node]*yaml.Node)
- }
- copy := *node
- cache[node] = ©
- copy.Content = nil
- for _, elem := range node.Content {
- copy.Content = append(copy.Content, deepCopyNode(elem, cache))
- }
- if node.Alias != nil {
- copy.Alias = deepCopyNode(node.Alias, cache)
- }
- return ©
-}
-
-var savedNodes = make(map[string]*yaml.Node)
-
-func saveNode(name string, node *yaml.Node) *yaml.Node {
- savedNodes[name] = node
- return node
-}
-
-func peekNode(name string) *yaml.Node {
- return savedNodes[name]
-}
-
-func dropNode(name string) *yaml.Node {
- node := savedNodes[name]
- delete(savedNodes, name)
- return node
-}
-
-var setStringTests = []struct {
- str string
- yaml string
- node yaml.Node
-}{
- {
- "something simple",
- "something simple\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "something simple",
- Tag: "!!str",
- },
- }, {
- `"quoted value"`,
- "'\"quoted value\"'\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: `"quoted value"`,
- Tag: "!!str",
- },
- }, {
- "multi\nline",
- "|-\n multi\n line\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "multi\nline",
- Tag: "!!str",
- Style: yaml.LiteralStyle,
- },
- }, {
- "123",
- "\"123\"\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "123",
- Tag: "!!str",
- },
- }, {
- "multi\nline\n",
- "|\n multi\n line\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "multi\nline\n",
- Tag: "!!str",
- Style: yaml.LiteralStyle,
- },
- }, {
- "\x80\x81\x82",
- "!!binary gIGC\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "gIGC",
- Tag: "!!binary",
- },
- },
-}
-
-func (s *S) TestSetString(c *C) {
- defer os.Setenv("TZ", os.Getenv("TZ"))
- os.Setenv("TZ", "UTC")
- for i, item := range setStringTests {
- c.Logf("test %d: %q", i, item.str)
-
- var node yaml.Node
-
- node.SetString(item.str)
-
- c.Assert(node, DeepEquals, item.node)
-
- buf := bytes.Buffer{}
- enc := yaml.NewEncoder(&buf)
- enc.SetIndent(2)
- err := enc.Encode(&item.node)
- c.Assert(err, IsNil)
- err = enc.Close()
- c.Assert(err, IsNil)
- c.Assert(buf.String(), Equals, item.yaml)
-
- var doc yaml.Node
- err = yaml.Unmarshal([]byte(item.yaml), &doc)
- c.Assert(err, IsNil)
-
- var str string
- err = node.Decode(&str)
- c.Assert(err, IsNil)
- c.Assert(str, Equals, item.str)
- }
-}
-
-var nodeEncodeDecodeTests = []struct {
- value interface{}
- yaml string
- node yaml.Node
-}{{
- "something simple",
- "something simple\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "something simple",
- Tag: "!!str",
- },
-}, {
- `"quoted value"`,
- "'\"quoted value\"'\n",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Style: yaml.SingleQuotedStyle,
- Value: `"quoted value"`,
- Tag: "!!str",
- },
-}, {
- 123,
- "123",
- yaml.Node{
- Kind: yaml.ScalarNode,
- Value: `123`,
- Tag: "!!int",
- },
-}, {
- []interface{}{1, 2},
- "[1, 2]",
- yaml.Node{
- Kind: yaml.SequenceNode,
- Tag: "!!seq",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "1",
- Tag: "!!int",
- }, {
- Kind: yaml.ScalarNode,
- Value: "2",
- Tag: "!!int",
- }},
- },
-}, {
- map[string]interface{}{"a": "b"},
- "a: b",
- yaml.Node{
- Kind: yaml.MappingNode,
- Tag: "!!map",
- Content: []*yaml.Node{{
- Kind: yaml.ScalarNode,
- Value: "a",
- Tag: "!!str",
- }, {
- Kind: yaml.ScalarNode,
- Value: "b",
- Tag: "!!str",
- }},
- },
-}}
-
-func (s *S) TestNodeEncodeDecode(c *C) {
- for i, item := range nodeEncodeDecodeTests {
- c.Logf("Encode/Decode test value #%d: %#v", i, item.value)
-
- var v interface{}
- err := item.node.Decode(&v)
- c.Assert(err, IsNil)
- c.Assert(v, DeepEquals, item.value)
-
- var n yaml.Node
- err = n.Encode(item.value)
- c.Assert(err, IsNil)
- c.Assert(n, DeepEquals, item.node)
- }
-}
-
-func (s *S) TestNodeZeroEncodeDecode(c *C) {
- // Zero node value behaves as nil when encoding...
- var n yaml.Node
- data, err := yaml.Marshal(&n)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, "null\n")
-
- // ... and decoding.
- var v *struct{} = &struct{}{}
- c.Assert(n.Decode(&v), IsNil)
- c.Assert(v, IsNil)
-
- // ... and even when looking for its tag.
- c.Assert(n.ShortTag(), Equals, "!!null")
-
- // Kind zero is still unknown, though.
- n.Line = 1
- _, err = yaml.Marshal(&n)
- c.Assert(err, ErrorMatches, "yaml: cannot encode node with unknown kind 0")
- c.Assert(n.Decode(&v), ErrorMatches, "yaml: cannot decode node with unknown kind 0")
-}
-
-func (s *S) TestNodeOmitEmpty(c *C) {
- var v struct {
- A int
- B yaml.Node ",omitempty"
- }
- v.A = 1
- data, err := yaml.Marshal(&v)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, "a: 1\n")
-
- v.B.Line = 1
- _, err = yaml.Marshal(&v)
- c.Assert(err, ErrorMatches, "yaml: cannot encode node with unknown kind 0")
-}
-
-func fprintComments(out io.Writer, node *yaml.Node, indent string) {
- switch node.Kind {
- case yaml.ScalarNode:
- fmt.Fprintf(out, "%s<%s> ", indent, node.Value)
- fprintCommentSet(out, node)
- fmt.Fprintf(out, "\n")
- case yaml.DocumentNode:
- fmt.Fprintf(out, "%s<DOC> ", indent)
- fprintCommentSet(out, node)
- fmt.Fprintf(out, "\n")
- for i := 0; i < len(node.Content); i++ {
- fprintComments(out, node.Content[i], indent+" ")
- }
- case yaml.MappingNode:
- fmt.Fprintf(out, "%s<MAP> ", indent)
- fprintCommentSet(out, node)
- fmt.Fprintf(out, "\n")
- for i := 0; i < len(node.Content); i += 2 {
- fprintComments(out, node.Content[i], indent+" ")
- fprintComments(out, node.Content[i+1], indent+" ")
- }
- case yaml.SequenceNode:
- fmt.Fprintf(out, "%s<SEQ> ", indent)
- fprintCommentSet(out, node)
- fmt.Fprintf(out, "\n")
- for i := 0; i < len(node.Content); i++ {
- fprintComments(out, node.Content[i], indent+" ")
- }
- }
-}
-
-func fprintCommentSet(out io.Writer, node *yaml.Node) {
- if len(node.HeadComment)+len(node.LineComment)+len(node.FootComment) > 0 {
- fmt.Fprintf(out, "%q / %q / %q", node.HeadComment, node.LineComment, node.FootComment)
- }
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/parserc.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/parserc.go
deleted file mode 100644
index 268558a0d6328a00db835512ca6d72369e2051d0..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/parserc.go
+++ /dev/null
@@ -1,1258 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "bytes"
-)
-
-// The parser implements the following grammar:
-//
-// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
-// implicit_document ::= block_node DOCUMENT-END*
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-// block_node_or_indentless_sequence ::=
-// ALIAS
-// | properties (block_content | indentless_block_sequence)?
-// | block_content
-// | indentless_block_sequence
-// block_node ::= ALIAS
-// | properties block_content?
-// | block_content
-// flow_node ::= ALIAS
-// | properties flow_content?
-// | flow_content
-// properties ::= TAG ANCHOR? | ANCHOR TAG?
-// block_content ::= block_collection | flow_collection | SCALAR
-// flow_content ::= flow_collection | SCALAR
-// block_collection ::= block_sequence | block_mapping
-// flow_collection ::= flow_sequence | flow_mapping
-// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
-// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
-// block_mapping ::= BLOCK-MAPPING_START
-// ((KEY block_node_or_indentless_sequence?)?
-// (VALUE block_node_or_indentless_sequence?)?)*
-// BLOCK-END
-// flow_sequence ::= FLOW-SEQUENCE-START
-// (flow_sequence_entry FLOW-ENTRY)*
-// flow_sequence_entry?
-// FLOW-SEQUENCE-END
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// flow_mapping ::= FLOW-MAPPING-START
-// (flow_mapping_entry FLOW-ENTRY)*
-// flow_mapping_entry?
-// FLOW-MAPPING-END
-// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-
-// Peek the next token in the token queue.
-func peek_token(parser *yaml_parser_t) *yaml_token_t {
- if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
- token := &parser.tokens[parser.tokens_head]
- yaml_parser_unfold_comments(parser, token)
- return token
- }
- return nil
-}
-
-// yaml_parser_unfold_comments walks through the comments queue and joins all
-// comments behind the position of the provided token into the respective
-// top-level comment slices in the parser.
-func yaml_parser_unfold_comments(parser *yaml_parser_t, token *yaml_token_t) {
- for parser.comments_head < len(parser.comments) && token.start_mark.index >= parser.comments[parser.comments_head].token_mark.index {
- comment := &parser.comments[parser.comments_head]
- if len(comment.head) > 0 {
- if token.typ == yaml_BLOCK_END_TOKEN {
- // No heads on ends, so keep comment.head for a follow up token.
- break
- }
- if len(parser.head_comment) > 0 {
- parser.head_comment = append(parser.head_comment, '\n')
- }
- parser.head_comment = append(parser.head_comment, comment.head...)
- }
- if len(comment.foot) > 0 {
- if len(parser.foot_comment) > 0 {
- parser.foot_comment = append(parser.foot_comment, '\n')
- }
- parser.foot_comment = append(parser.foot_comment, comment.foot...)
- }
- if len(comment.line) > 0 {
- if len(parser.line_comment) > 0 {
- parser.line_comment = append(parser.line_comment, '\n')
- }
- parser.line_comment = append(parser.line_comment, comment.line...)
- }
- *comment = yaml_comment_t{}
- parser.comments_head++
- }
-}
-
-// Remove the next token from the queue (must be called after peek_token).
-func skip_token(parser *yaml_parser_t) {
- parser.token_available = false
- parser.tokens_parsed++
- parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
- parser.tokens_head++
-}
-
-// Get the next event.
-func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool {
- // Erase the event object.
- *event = yaml_event_t{}
-
- // No events after the end of the stream or error.
- if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE {
- return true
- }
-
- // Generate the next event.
- return yaml_parser_state_machine(parser, event)
-}
-
-// Set parser error.
-func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
- parser.error = yaml_PARSER_ERROR
- parser.problem = problem
- parser.problem_mark = problem_mark
- return false
-}
-
-func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool {
- parser.error = yaml_PARSER_ERROR
- parser.context = context
- parser.context_mark = context_mark
- parser.problem = problem
- parser.problem_mark = problem_mark
- return false
-}
-
-// State dispatcher.
-func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool {
- //trace("yaml_parser_state_machine", "state:", parser.state.String())
-
- switch parser.state {
- case yaml_PARSE_STREAM_START_STATE:
- return yaml_parser_parse_stream_start(parser, event)
-
- case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
- return yaml_parser_parse_document_start(parser, event, true)
-
- case yaml_PARSE_DOCUMENT_START_STATE:
- return yaml_parser_parse_document_start(parser, event, false)
-
- case yaml_PARSE_DOCUMENT_CONTENT_STATE:
- return yaml_parser_parse_document_content(parser, event)
-
- case yaml_PARSE_DOCUMENT_END_STATE:
- return yaml_parser_parse_document_end(parser, event)
-
- case yaml_PARSE_BLOCK_NODE_STATE:
- return yaml_parser_parse_node(parser, event, true, false)
-
- case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
- return yaml_parser_parse_node(parser, event, true, true)
-
- case yaml_PARSE_FLOW_NODE_STATE:
- return yaml_parser_parse_node(parser, event, false, false)
-
- case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
- return yaml_parser_parse_block_sequence_entry(parser, event, true)
-
- case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
- return yaml_parser_parse_block_sequence_entry(parser, event, false)
-
- case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
- return yaml_parser_parse_indentless_sequence_entry(parser, event)
-
- case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
- return yaml_parser_parse_block_mapping_key(parser, event, true)
-
- case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
- return yaml_parser_parse_block_mapping_key(parser, event, false)
-
- case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
- return yaml_parser_parse_block_mapping_value(parser, event)
-
- case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
- return yaml_parser_parse_flow_sequence_entry(parser, event, true)
-
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
- return yaml_parser_parse_flow_sequence_entry(parser, event, false)
-
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
- return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
-
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
- return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
-
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
- return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
-
- case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
- return yaml_parser_parse_flow_mapping_key(parser, event, true)
-
- case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
- return yaml_parser_parse_flow_mapping_key(parser, event, false)
-
- case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
- return yaml_parser_parse_flow_mapping_value(parser, event, false)
-
- case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
- return yaml_parser_parse_flow_mapping_value(parser, event, true)
-
- default:
- panic("invalid parser state")
- }
-}
-
-// Parse the production:
-// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
-// ************
-func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_STREAM_START_TOKEN {
- return yaml_parser_set_parser_error(parser, "did not find expected <stream-start>", token.start_mark)
- }
- parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
- *event = yaml_event_t{
- typ: yaml_STREAM_START_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- encoding: token.encoding,
- }
- skip_token(parser)
- return true
-}
-
-// Parse the productions:
-// implicit_document ::= block_node DOCUMENT-END*
-// *
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-// *************************
-func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- // Parse extra document end indicators.
- if !implicit {
- for token.typ == yaml_DOCUMENT_END_TOKEN {
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- }
- }
-
- if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
- token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
- token.typ != yaml_DOCUMENT_START_TOKEN &&
- token.typ != yaml_STREAM_END_TOKEN {
- // Parse an implicit document.
- if !yaml_parser_process_directives(parser, nil, nil) {
- return false
- }
- parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
- parser.state = yaml_PARSE_BLOCK_NODE_STATE
-
- var head_comment []byte
- if len(parser.head_comment) > 0 {
- // [Go] Scan the header comment backwards, and if an empty line is found, break
- // the header so the part before the last empty line goes into the
- // document header, while the bottom of it goes into a follow up event.
- for i := len(parser.head_comment) - 1; i > 0; i-- {
- if parser.head_comment[i] == '\n' {
- if i == len(parser.head_comment)-1 {
- head_comment = parser.head_comment[:i]
- parser.head_comment = parser.head_comment[i+1:]
- break
- } else if parser.head_comment[i-1] == '\n' {
- head_comment = parser.head_comment[:i-1]
- parser.head_comment = parser.head_comment[i+1:]
- break
- }
- }
- }
- }
-
- *event = yaml_event_t{
- typ: yaml_DOCUMENT_START_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
-
- head_comment: head_comment,
- }
-
- } else if token.typ != yaml_STREAM_END_TOKEN {
- // Parse an explicit document.
- var version_directive *yaml_version_directive_t
- var tag_directives []yaml_tag_directive_t
- start_mark := token.start_mark
- if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
- return false
- }
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_DOCUMENT_START_TOKEN {
- yaml_parser_set_parser_error(parser,
- "did not find expected <document start>", token.start_mark)
- return false
- }
- parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
- parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
- end_mark := token.end_mark
-
- *event = yaml_event_t{
- typ: yaml_DOCUMENT_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- version_directive: version_directive,
- tag_directives: tag_directives,
- implicit: false,
- }
- skip_token(parser)
-
- } else {
- // Parse the stream end.
- parser.state = yaml_PARSE_END_STATE
- *event = yaml_event_t{
- typ: yaml_STREAM_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- }
- skip_token(parser)
- }
-
- return true
-}
-
-// Parse the productions:
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-// ***********
-//
-func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
- token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
- token.typ == yaml_DOCUMENT_START_TOKEN ||
- token.typ == yaml_DOCUMENT_END_TOKEN ||
- token.typ == yaml_STREAM_END_TOKEN {
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- return yaml_parser_process_empty_scalar(parser, event,
- token.start_mark)
- }
- return yaml_parser_parse_node(parser, event, true, false)
-}
-
-// Parse the productions:
-// implicit_document ::= block_node DOCUMENT-END*
-// *************
-// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-//
-func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- start_mark := token.start_mark
- end_mark := token.start_mark
-
- implicit := true
- if token.typ == yaml_DOCUMENT_END_TOKEN {
- end_mark = token.end_mark
- skip_token(parser)
- implicit = false
- }
-
- parser.tag_directives = parser.tag_directives[:0]
-
- parser.state = yaml_PARSE_DOCUMENT_START_STATE
- *event = yaml_event_t{
- typ: yaml_DOCUMENT_END_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- implicit: implicit,
- }
- yaml_parser_set_event_comments(parser, event)
- if len(event.head_comment) > 0 && len(event.foot_comment) == 0 {
- event.foot_comment = event.head_comment
- event.head_comment = nil
- }
- return true
-}
-
-func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t) {
- event.head_comment = parser.head_comment
- event.line_comment = parser.line_comment
- event.foot_comment = parser.foot_comment
- parser.head_comment = nil
- parser.line_comment = nil
- parser.foot_comment = nil
- parser.tail_comment = nil
- parser.stem_comment = nil
-}
-
-// Parse the productions:
-// block_node_or_indentless_sequence ::=
-// ALIAS
-// *****
-// | properties (block_content | indentless_block_sequence)?
-// ********** *
-// | block_content | indentless_block_sequence
-// *
-// block_node ::= ALIAS
-// *****
-// | properties block_content?
-// ********** *
-// | block_content
-// *
-// flow_node ::= ALIAS
-// *****
-// | properties flow_content?
-// ********** *
-// | flow_content
-// *
-// properties ::= TAG ANCHOR? | ANCHOR TAG?
-// *************************
-// block_content ::= block_collection | flow_collection | SCALAR
-// ******
-// flow_content ::= flow_collection | SCALAR
-// ******
-func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
- //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- if token.typ == yaml_ALIAS_TOKEN {
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- *event = yaml_event_t{
- typ: yaml_ALIAS_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- anchor: token.value,
- }
- yaml_parser_set_event_comments(parser, event)
- skip_token(parser)
- return true
- }
-
- start_mark := token.start_mark
- end_mark := token.start_mark
-
- var tag_token bool
- var tag_handle, tag_suffix, anchor []byte
- var tag_mark yaml_mark_t
- if token.typ == yaml_ANCHOR_TOKEN {
- anchor = token.value
- start_mark = token.start_mark
- end_mark = token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ == yaml_TAG_TOKEN {
- tag_token = true
- tag_handle = token.value
- tag_suffix = token.suffix
- tag_mark = token.start_mark
- end_mark = token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- }
- } else if token.typ == yaml_TAG_TOKEN {
- tag_token = true
- tag_handle = token.value
- tag_suffix = token.suffix
- start_mark = token.start_mark
- tag_mark = token.start_mark
- end_mark = token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ == yaml_ANCHOR_TOKEN {
- anchor = token.value
- end_mark = token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- }
- }
-
- var tag []byte
- if tag_token {
- if len(tag_handle) == 0 {
- tag = tag_suffix
- tag_suffix = nil
- } else {
- for i := range parser.tag_directives {
- if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
- tag = append([]byte(nil), parser.tag_directives[i].prefix...)
- tag = append(tag, tag_suffix...)
- break
- }
- }
- if len(tag) == 0 {
- yaml_parser_set_parser_error_context(parser,
- "while parsing a node", start_mark,
- "found undefined tag handle", tag_mark)
- return false
- }
- }
- }
-
- implicit := len(tag) == 0
- if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
- end_mark = token.end_mark
- parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
- }
- return true
- }
- if token.typ == yaml_SCALAR_TOKEN {
- var plain_implicit, quoted_implicit bool
- end_mark = token.end_mark
- if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') {
- plain_implicit = true
- } else if len(tag) == 0 {
- quoted_implicit = true
- }
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
-
- *event = yaml_event_t{
- typ: yaml_SCALAR_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- value: token.value,
- implicit: plain_implicit,
- quoted_implicit: quoted_implicit,
- style: yaml_style_t(token.style),
- }
- yaml_parser_set_event_comments(parser, event)
- skip_token(parser)
- return true
- }
- if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
- // [Go] Some of the events below can be merged as they differ only on style.
- end_mark = token.end_mark
- parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
- }
- yaml_parser_set_event_comments(parser, event)
- return true
- }
- if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
- end_mark = token.end_mark
- parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
- *event = yaml_event_t{
- typ: yaml_MAPPING_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
- }
- yaml_parser_set_event_comments(parser, event)
- return true
- }
- if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
- end_mark = token.end_mark
- parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
- }
- if parser.stem_comment != nil {
- event.head_comment = parser.stem_comment
- parser.stem_comment = nil
- }
- return true
- }
- if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
- end_mark = token.end_mark
- parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
- *event = yaml_event_t{
- typ: yaml_MAPPING_START_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
- }
- if parser.stem_comment != nil {
- event.head_comment = parser.stem_comment
- parser.stem_comment = nil
- }
- return true
- }
- if len(anchor) > 0 || len(tag) > 0 {
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
-
- *event = yaml_event_t{
- typ: yaml_SCALAR_EVENT,
- start_mark: start_mark,
- end_mark: end_mark,
- anchor: anchor,
- tag: tag,
- implicit: implicit,
- quoted_implicit: false,
- style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
- }
- return true
- }
-
- context := "while parsing a flow node"
- if block {
- context = "while parsing a block node"
- }
- yaml_parser_set_parser_error_context(parser, context, start_mark,
- "did not find expected node content", token.start_mark)
- return false
-}
-
-// Parse the productions:
-// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
-// ******************** *********** * *********
-//
-func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
- if first {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- parser.marks = append(parser.marks, token.start_mark)
- skip_token(parser)
- }
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- if token.typ == yaml_BLOCK_ENTRY_TOKEN {
- mark := token.end_mark
- prior_head_len := len(parser.head_comment)
- skip_token(parser)
- yaml_parser_split_stem_comment(parser, prior_head_len)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
- return yaml_parser_parse_node(parser, event, true, false)
- } else {
- parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
- return yaml_parser_process_empty_scalar(parser, event, mark)
- }
- }
- if token.typ == yaml_BLOCK_END_TOKEN {
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
-
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- }
-
- skip_token(parser)
- return true
- }
-
- context_mark := parser.marks[len(parser.marks)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- return yaml_parser_set_parser_error_context(parser,
- "while parsing a block collection", context_mark,
- "did not find expected '-' indicator", token.start_mark)
-}
-
-// Parse the productions:
-// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
-// *********** *
-func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- if token.typ == yaml_BLOCK_ENTRY_TOKEN {
- mark := token.end_mark
- prior_head_len := len(parser.head_comment)
- skip_token(parser)
- yaml_parser_split_stem_comment(parser, prior_head_len)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
- token.typ != yaml_KEY_TOKEN &&
- token.typ != yaml_VALUE_TOKEN &&
- token.typ != yaml_BLOCK_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
- return yaml_parser_parse_node(parser, event, true, false)
- }
- parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
- return yaml_parser_process_empty_scalar(parser, event, mark)
- }
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
-
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark?
- }
- return true
-}
-
-// Split stem comment from head comment.
-//
-// When a sequence or map is found under a sequence entry, the former head comment
-// is assigned to the underlying sequence or map as a whole, not the individual
-// sequence or map entry as would be expected otherwise. To handle this case the
-// previous head comment is moved aside as the stem comment.
-func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
- if stem_len == 0 {
- return
- }
-
- token := peek_token(parser)
- if token == nil || token.typ != yaml_BLOCK_SEQUENCE_START_TOKEN && token.typ != yaml_BLOCK_MAPPING_START_TOKEN {
- return
- }
-
- parser.stem_comment = parser.head_comment[:stem_len]
- if len(parser.head_comment) == stem_len {
- parser.head_comment = nil
- } else {
- // Copy suffix to prevent very strange bugs if someone ever appends
- // further bytes to the prefix in the stem_comment slice above.
- parser.head_comment = append([]byte(nil), parser.head_comment[stem_len+1:]...)
- }
-}
-
-// Parse the productions:
-// block_mapping ::= BLOCK-MAPPING_START
-// *******************
-// ((KEY block_node_or_indentless_sequence?)?
-// *** *
-// (VALUE block_node_or_indentless_sequence?)?)*
-//
-// BLOCK-END
-// *********
-//
-func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
- if first {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- parser.marks = append(parser.marks, token.start_mark)
- skip_token(parser)
- }
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- // [Go] A tail comment was left from the prior mapping value processed. Emit an event
- // as it needs to be processed with that value and not the following key.
- if len(parser.tail_comment) > 0 {
- *event = yaml_event_t{
- typ: yaml_TAIL_COMMENT_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- foot_comment: parser.tail_comment,
- }
- parser.tail_comment = nil
- return true
- }
-
- if token.typ == yaml_KEY_TOKEN {
- mark := token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_KEY_TOKEN &&
- token.typ != yaml_VALUE_TOKEN &&
- token.typ != yaml_BLOCK_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
- return yaml_parser_parse_node(parser, event, true, true)
- } else {
- parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
- return yaml_parser_process_empty_scalar(parser, event, mark)
- }
- } else if token.typ == yaml_BLOCK_END_TOKEN {
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- *event = yaml_event_t{
- typ: yaml_MAPPING_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- }
- yaml_parser_set_event_comments(parser, event)
- skip_token(parser)
- return true
- }
-
- context_mark := parser.marks[len(parser.marks)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- return yaml_parser_set_parser_error_context(parser,
- "while parsing a block mapping", context_mark,
- "did not find expected key", token.start_mark)
-}
-
-// Parse the productions:
-// block_mapping ::= BLOCK-MAPPING_START
-//
-// ((KEY block_node_or_indentless_sequence?)?
-//
-// (VALUE block_node_or_indentless_sequence?)?)*
-// ***** *
-// BLOCK-END
-//
-//
-func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ == yaml_VALUE_TOKEN {
- mark := token.end_mark
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_KEY_TOKEN &&
- token.typ != yaml_VALUE_TOKEN &&
- token.typ != yaml_BLOCK_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
- return yaml_parser_parse_node(parser, event, true, true)
- }
- parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
- return yaml_parser_process_empty_scalar(parser, event, mark)
- }
- parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
- return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
-}
-
-// Parse the productions:
-// flow_sequence ::= FLOW-SEQUENCE-START
-// *******************
-// (flow_sequence_entry FLOW-ENTRY)*
-// * **********
-// flow_sequence_entry?
-// *
-// FLOW-SEQUENCE-END
-// *****************
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// *
-//
-func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
- if first {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- parser.marks = append(parser.marks, token.start_mark)
- skip_token(parser)
- }
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
- if !first {
- if token.typ == yaml_FLOW_ENTRY_TOKEN {
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- } else {
- context_mark := parser.marks[len(parser.marks)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- return yaml_parser_set_parser_error_context(parser,
- "while parsing a flow sequence", context_mark,
- "did not find expected ',' or ']'", token.start_mark)
- }
- }
-
- if token.typ == yaml_KEY_TOKEN {
- parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
- *event = yaml_event_t{
- typ: yaml_MAPPING_START_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- implicit: true,
- style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
- }
- skip_token(parser)
- return true
- } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- }
- }
-
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
-
- *event = yaml_event_t{
- typ: yaml_SEQUENCE_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- }
- yaml_parser_set_event_comments(parser, event)
-
- skip_token(parser)
- return true
-}
-
-//
-// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// *** *
-//
-func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_VALUE_TOKEN &&
- token.typ != yaml_FLOW_ENTRY_TOKEN &&
- token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- }
- mark := token.end_mark
- skip_token(parser)
- parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
- return yaml_parser_process_empty_scalar(parser, event, mark)
-}
-
-// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// ***** *
-//
-func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ == yaml_VALUE_TOKEN {
- skip_token(parser)
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- }
- }
- parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
- return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
-}
-
-// Parse the productions:
-// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// *
-//
-func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
- *event = yaml_event_t{
- typ: yaml_MAPPING_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.start_mark, // [Go] Shouldn't this be end_mark?
- }
- return true
-}
-
-// Parse the productions:
-// flow_mapping ::= FLOW-MAPPING-START
-// ******************
-// (flow_mapping_entry FLOW-ENTRY)*
-// * **********
-// flow_mapping_entry?
-// ******************
-// FLOW-MAPPING-END
-// ****************
-// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// * *** *
-//
-func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
- if first {
- token := peek_token(parser)
- parser.marks = append(parser.marks, token.start_mark)
- skip_token(parser)
- }
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
- if !first {
- if token.typ == yaml_FLOW_ENTRY_TOKEN {
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- } else {
- context_mark := parser.marks[len(parser.marks)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- return yaml_parser_set_parser_error_context(parser,
- "while parsing a flow mapping", context_mark,
- "did not find expected ',' or '}'", token.start_mark)
- }
- }
-
- if token.typ == yaml_KEY_TOKEN {
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_VALUE_TOKEN &&
- token.typ != yaml_FLOW_ENTRY_TOKEN &&
- token.typ != yaml_FLOW_MAPPING_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- } else {
- parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
- return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
- }
- } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- }
- }
-
- parser.state = parser.states[len(parser.states)-1]
- parser.states = parser.states[:len(parser.states)-1]
- parser.marks = parser.marks[:len(parser.marks)-1]
- *event = yaml_event_t{
- typ: yaml_MAPPING_END_EVENT,
- start_mark: token.start_mark,
- end_mark: token.end_mark,
- }
- yaml_parser_set_event_comments(parser, event)
- skip_token(parser)
- return true
-}
-
-// Parse the productions:
-// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-// * ***** *
-//
-func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
- token := peek_token(parser)
- if token == nil {
- return false
- }
- if empty {
- parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
- return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
- }
- if token.typ == yaml_VALUE_TOKEN {
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
- parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
- return yaml_parser_parse_node(parser, event, false, false)
- }
- }
- parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
- return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
-}
-
-// Generate an empty scalar event.
-func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool {
- *event = yaml_event_t{
- typ: yaml_SCALAR_EVENT,
- start_mark: mark,
- end_mark: mark,
- value: nil, // Empty
- implicit: true,
- style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
- }
- return true
-}
-
-var default_tag_directives = []yaml_tag_directive_t{
- {[]byte("!"), []byte("!")},
- {[]byte("!!"), []byte("tag:yaml.org,2002:")},
-}
-
-// Parse directives.
-func yaml_parser_process_directives(parser *yaml_parser_t,
- version_directive_ref **yaml_version_directive_t,
- tag_directives_ref *[]yaml_tag_directive_t) bool {
-
- var version_directive *yaml_version_directive_t
- var tag_directives []yaml_tag_directive_t
-
- token := peek_token(parser)
- if token == nil {
- return false
- }
-
- for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN {
- if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
- if version_directive != nil {
- yaml_parser_set_parser_error(parser,
- "found duplicate %YAML directive", token.start_mark)
- return false
- }
- if token.major != 1 || token.minor != 1 {
- yaml_parser_set_parser_error(parser,
- "found incompatible YAML document", token.start_mark)
- return false
- }
- version_directive = &yaml_version_directive_t{
- major: token.major,
- minor: token.minor,
- }
- } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
- value := yaml_tag_directive_t{
- handle: token.value,
- prefix: token.prefix,
- }
- if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
- return false
- }
- tag_directives = append(tag_directives, value)
- }
-
- skip_token(parser)
- token = peek_token(parser)
- if token == nil {
- return false
- }
- }
-
- for i := range default_tag_directives {
- if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
- return false
- }
- }
-
- if version_directive_ref != nil {
- *version_directive_ref = version_directive
- }
- if tag_directives_ref != nil {
- *tag_directives_ref = tag_directives
- }
- return true
-}
-
-// Append a tag directive to the directives stack.
-func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
- for i := range parser.tag_directives {
- if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
- if allow_duplicates {
- return true
- }
- return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
- }
- }
-
- // [Go] I suspect the copy is unnecessary. This was likely done
- // because there was no way to track ownership of the data.
- value_copy := yaml_tag_directive_t{
- handle: make([]byte, len(value.handle)),
- prefix: make([]byte, len(value.prefix)),
- }
- copy(value_copy.handle, value.handle)
- copy(value_copy.prefix, value.prefix)
- parser.tag_directives = append(parser.tag_directives, value_copy)
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/readerc.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/readerc.go
deleted file mode 100644
index b7de0a89c462af605f889bc46ce165e5d4238add..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/readerc.go
+++ /dev/null
@@ -1,434 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "io"
-)
-
-// Set the reader error and return 0.
-func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
- parser.error = yaml_READER_ERROR
- parser.problem = problem
- parser.problem_offset = offset
- parser.problem_value = value
- return false
-}
-
-// Byte order marks.
-const (
- bom_UTF8 = "\xef\xbb\xbf"
- bom_UTF16LE = "\xff\xfe"
- bom_UTF16BE = "\xfe\xff"
-)
-
-// Determine the input stream encoding by checking the BOM symbol. If no BOM is
-// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
-func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
- // Ensure that we had enough bytes in the raw buffer.
- for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
- if !yaml_parser_update_raw_buffer(parser) {
- return false
- }
- }
-
- // Determine the encoding.
- buf := parser.raw_buffer
- pos := parser.raw_buffer_pos
- avail := len(buf) - pos
- if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
- parser.encoding = yaml_UTF16LE_ENCODING
- parser.raw_buffer_pos += 2
- parser.offset += 2
- } else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
- parser.encoding = yaml_UTF16BE_ENCODING
- parser.raw_buffer_pos += 2
- parser.offset += 2
- } else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
- parser.encoding = yaml_UTF8_ENCODING
- parser.raw_buffer_pos += 3
- parser.offset += 3
- } else {
- parser.encoding = yaml_UTF8_ENCODING
- }
- return true
-}
-
-// Update the raw buffer.
-func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
- size_read := 0
-
- // Return if the raw buffer is full.
- if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
- return true
- }
-
- // Return on EOF.
- if parser.eof {
- return true
- }
-
- // Move the remaining bytes in the raw buffer to the beginning.
- if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
- copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
- }
- parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
- parser.raw_buffer_pos = 0
-
- // Call the read handler to fill the buffer.
- size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
- parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
- if err == io.EOF {
- parser.eof = true
- } else if err != nil {
- return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
- }
- return true
-}
-
-// Ensure that the buffer contains at least `length` characters.
-// Return true on success, false on failure.
-//
-// The length is supposed to be significantly less that the buffer size.
-func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
- if parser.read_handler == nil {
- panic("read handler must be set")
- }
-
- // [Go] This function was changed to guarantee the requested length size at EOF.
- // The fact we need to do this is pretty awful, but the description above implies
- // for that to be the case, and there are tests
-
- // If the EOF flag is set and the raw buffer is empty, do nothing.
- if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
- // [Go] ACTUALLY! Read the documentation of this function above.
- // This is just broken. To return true, we need to have the
- // given length in the buffer. Not doing that means every single
- // check that calls this function to make sure the buffer has a
- // given length is Go) panicking; or C) accessing invalid memory.
- //return true
- }
-
- // Return if the buffer contains enough characters.
- if parser.unread >= length {
- return true
- }
-
- // Determine the input encoding if it is not known yet.
- if parser.encoding == yaml_ANY_ENCODING {
- if !yaml_parser_determine_encoding(parser) {
- return false
- }
- }
-
- // Move the unread characters to the beginning of the buffer.
- buffer_len := len(parser.buffer)
- if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
- copy(parser.buffer, parser.buffer[parser.buffer_pos:])
- buffer_len -= parser.buffer_pos
- parser.buffer_pos = 0
- } else if parser.buffer_pos == buffer_len {
- buffer_len = 0
- parser.buffer_pos = 0
- }
-
- // Open the whole buffer for writing, and cut it before returning.
- parser.buffer = parser.buffer[:cap(parser.buffer)]
-
- // Fill the buffer until it has enough characters.
- first := true
- for parser.unread < length {
-
- // Fill the raw buffer if necessary.
- if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
- if !yaml_parser_update_raw_buffer(parser) {
- parser.buffer = parser.buffer[:buffer_len]
- return false
- }
- }
- first = false
-
- // Decode the raw buffer.
- inner:
- for parser.raw_buffer_pos != len(parser.raw_buffer) {
- var value rune
- var width int
-
- raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
-
- // Decode the next character.
- switch parser.encoding {
- case yaml_UTF8_ENCODING:
- // Decode a UTF-8 character. Check RFC 3629
- // (http://www.ietf.org/rfc/rfc3629.txt) for more details.
- //
- // The following table (taken from the RFC) is used for
- // decoding.
- //
- // Char. number range | UTF-8 octet sequence
- // (hexadecimal) | (binary)
- // --------------------+------------------------------------
- // 0000 0000-0000 007F | 0xxxxxxx
- // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
- // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
- // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- //
- // Additionally, the characters in the range 0xD800-0xDFFF
- // are prohibited as they are reserved for use with UTF-16
- // surrogate pairs.
-
- // Determine the length of the UTF-8 sequence.
- octet := parser.raw_buffer[parser.raw_buffer_pos]
- switch {
- case octet&0x80 == 0x00:
- width = 1
- case octet&0xE0 == 0xC0:
- width = 2
- case octet&0xF0 == 0xE0:
- width = 3
- case octet&0xF8 == 0xF0:
- width = 4
- default:
- // The leading octet is invalid.
- return yaml_parser_set_reader_error(parser,
- "invalid leading UTF-8 octet",
- parser.offset, int(octet))
- }
-
- // Check if the raw buffer contains an incomplete character.
- if width > raw_unread {
- if parser.eof {
- return yaml_parser_set_reader_error(parser,
- "incomplete UTF-8 octet sequence",
- parser.offset, -1)
- }
- break inner
- }
-
- // Decode the leading octet.
- switch {
- case octet&0x80 == 0x00:
- value = rune(octet & 0x7F)
- case octet&0xE0 == 0xC0:
- value = rune(octet & 0x1F)
- case octet&0xF0 == 0xE0:
- value = rune(octet & 0x0F)
- case octet&0xF8 == 0xF0:
- value = rune(octet & 0x07)
- default:
- value = 0
- }
-
- // Check and decode the trailing octets.
- for k := 1; k < width; k++ {
- octet = parser.raw_buffer[parser.raw_buffer_pos+k]
-
- // Check if the octet is valid.
- if (octet & 0xC0) != 0x80 {
- return yaml_parser_set_reader_error(parser,
- "invalid trailing UTF-8 octet",
- parser.offset+k, int(octet))
- }
-
- // Decode the octet.
- value = (value << 6) + rune(octet&0x3F)
- }
-
- // Check the length of the sequence against the value.
- switch {
- case width == 1:
- case width == 2 && value >= 0x80:
- case width == 3 && value >= 0x800:
- case width == 4 && value >= 0x10000:
- default:
- return yaml_parser_set_reader_error(parser,
- "invalid length of a UTF-8 sequence",
- parser.offset, -1)
- }
-
- // Check the range of the value.
- if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
- return yaml_parser_set_reader_error(parser,
- "invalid Unicode character",
- parser.offset, int(value))
- }
-
- case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
- var low, high int
- if parser.encoding == yaml_UTF16LE_ENCODING {
- low, high = 0, 1
- } else {
- low, high = 1, 0
- }
-
- // The UTF-16 encoding is not as simple as one might
- // naively think. Check RFC 2781
- // (http://www.ietf.org/rfc/rfc2781.txt).
- //
- // Normally, two subsequent bytes describe a Unicode
- // character. However a special technique (called a
- // surrogate pair) is used for specifying character
- // values larger than 0xFFFF.
- //
- // A surrogate pair consists of two pseudo-characters:
- // high surrogate area (0xD800-0xDBFF)
- // low surrogate area (0xDC00-0xDFFF)
- //
- // The following formulas are used for decoding
- // and encoding characters using surrogate pairs:
- //
- // U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
- // U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
- // W1 = 110110yyyyyyyyyy
- // W2 = 110111xxxxxxxxxx
- //
- // where U is the character value, W1 is the high surrogate
- // area, W2 is the low surrogate area.
-
- // Check for incomplete UTF-16 character.
- if raw_unread < 2 {
- if parser.eof {
- return yaml_parser_set_reader_error(parser,
- "incomplete UTF-16 character",
- parser.offset, -1)
- }
- break inner
- }
-
- // Get the character.
- value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
- (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
-
- // Check for unexpected low surrogate area.
- if value&0xFC00 == 0xDC00 {
- return yaml_parser_set_reader_error(parser,
- "unexpected low surrogate area",
- parser.offset, int(value))
- }
-
- // Check for a high surrogate area.
- if value&0xFC00 == 0xD800 {
- width = 4
-
- // Check for incomplete surrogate pair.
- if raw_unread < 4 {
- if parser.eof {
- return yaml_parser_set_reader_error(parser,
- "incomplete UTF-16 surrogate pair",
- parser.offset, -1)
- }
- break inner
- }
-
- // Get the next character.
- value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
- (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
-
- // Check for a low surrogate area.
- if value2&0xFC00 != 0xDC00 {
- return yaml_parser_set_reader_error(parser,
- "expected low surrogate area",
- parser.offset+2, int(value2))
- }
-
- // Generate the value of the surrogate pair.
- value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
- } else {
- width = 2
- }
-
- default:
- panic("impossible")
- }
-
- // Check if the character is in the allowed range:
- // #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
- // | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
- // | [#x10000-#x10FFFF] (32 bit)
- switch {
- case value == 0x09:
- case value == 0x0A:
- case value == 0x0D:
- case value >= 0x20 && value <= 0x7E:
- case value == 0x85:
- case value >= 0xA0 && value <= 0xD7FF:
- case value >= 0xE000 && value <= 0xFFFD:
- case value >= 0x10000 && value <= 0x10FFFF:
- default:
- return yaml_parser_set_reader_error(parser,
- "control characters are not allowed",
- parser.offset, int(value))
- }
-
- // Move the raw pointers.
- parser.raw_buffer_pos += width
- parser.offset += width
-
- // Finally put the character into the buffer.
- if value <= 0x7F {
- // 0000 0000-0000 007F . 0xxxxxxx
- parser.buffer[buffer_len+0] = byte(value)
- buffer_len += 1
- } else if value <= 0x7FF {
- // 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
- parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
- parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
- buffer_len += 2
- } else if value <= 0xFFFF {
- // 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
- parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
- parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
- parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
- buffer_len += 3
- } else {
- // 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
- parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
- parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
- parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
- parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
- buffer_len += 4
- }
-
- parser.unread++
- }
-
- // On EOF, put NUL into the buffer and return.
- if parser.eof {
- parser.buffer[buffer_len] = 0
- buffer_len++
- parser.unread++
- break
- }
- }
- // [Go] Read the documentation of this function above. To return true,
- // we need to have the given length in the buffer. Not doing that means
- // every single check that calls this function to make sure the buffer
- // has a given length is Go) panicking; or C) accessing invalid memory.
- // This happens here due to the EOF above breaking early.
- for buffer_len < length {
- parser.buffer[buffer_len] = 0
- buffer_len++
- }
- parser.buffer = parser.buffer[:buffer_len]
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/resolve.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/resolve.go
deleted file mode 100644
index 64ae888057a5aa24c5a3a6ca0fcb08a06269e3ad..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/resolve.go
+++ /dev/null
@@ -1,326 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml
-
-import (
- "encoding/base64"
- "math"
- "regexp"
- "strconv"
- "strings"
- "time"
-)
-
-type resolveMapItem struct {
- value interface{}
- tag string
-}
-
-var resolveTable = make([]byte, 256)
-var resolveMap = make(map[string]resolveMapItem)
-
-func init() {
- t := resolveTable
- t[int('+')] = 'S' // Sign
- t[int('-')] = 'S'
- for _, c := range "0123456789" {
- t[int(c)] = 'D' // Digit
- }
- for _, c := range "yYnNtTfFoO~" {
- t[int(c)] = 'M' // In map
- }
- t[int('.')] = '.' // Float (potentially in map)
-
- var resolveMapList = []struct {
- v interface{}
- tag string
- l []string
- }{
- {true, boolTag, []string{"true", "True", "TRUE"}},
- {false, boolTag, []string{"false", "False", "FALSE"}},
- {nil, nullTag, []string{"", "~", "null", "Null", "NULL"}},
- {math.NaN(), floatTag, []string{".nan", ".NaN", ".NAN"}},
- {math.Inf(+1), floatTag, []string{".inf", ".Inf", ".INF"}},
- {math.Inf(+1), floatTag, []string{"+.inf", "+.Inf", "+.INF"}},
- {math.Inf(-1), floatTag, []string{"-.inf", "-.Inf", "-.INF"}},
- {"<<", mergeTag, []string{"<<"}},
- }
-
- m := resolveMap
- for _, item := range resolveMapList {
- for _, s := range item.l {
- m[s] = resolveMapItem{item.v, item.tag}
- }
- }
-}
-
-const (
- nullTag = "!!null"
- boolTag = "!!bool"
- strTag = "!!str"
- intTag = "!!int"
- floatTag = "!!float"
- timestampTag = "!!timestamp"
- seqTag = "!!seq"
- mapTag = "!!map"
- binaryTag = "!!binary"
- mergeTag = "!!merge"
-)
-
-var longTags = make(map[string]string)
-var shortTags = make(map[string]string)
-
-func init() {
- for _, stag := range []string{nullTag, boolTag, strTag, intTag, floatTag, timestampTag, seqTag, mapTag, binaryTag, mergeTag} {
- ltag := longTag(stag)
- longTags[stag] = ltag
- shortTags[ltag] = stag
- }
-}
-
-const longTagPrefix = "tag:yaml.org,2002:"
-
-func shortTag(tag string) string {
- if strings.HasPrefix(tag, longTagPrefix) {
- if stag, ok := shortTags[tag]; ok {
- return stag
- }
- return "!!" + tag[len(longTagPrefix):]
- }
- return tag
-}
-
-func longTag(tag string) string {
- if strings.HasPrefix(tag, "!!") {
- if ltag, ok := longTags[tag]; ok {
- return ltag
- }
- return longTagPrefix + tag[2:]
- }
- return tag
-}
-
-func resolvableTag(tag string) bool {
- switch tag {
- case "", strTag, boolTag, intTag, floatTag, nullTag, timestampTag:
- return true
- }
- return false
-}
-
-var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
-
-func resolve(tag string, in string) (rtag string, out interface{}) {
- tag = shortTag(tag)
- if !resolvableTag(tag) {
- return tag, in
- }
-
- defer func() {
- switch tag {
- case "", rtag, strTag, binaryTag:
- return
- case floatTag:
- if rtag == intTag {
- switch v := out.(type) {
- case int64:
- rtag = floatTag
- out = float64(v)
- return
- case int:
- rtag = floatTag
- out = float64(v)
- return
- }
- }
- }
- failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
- }()
-
- // Any data is accepted as a !!str or !!binary.
- // Otherwise, the prefix is enough of a hint about what it might be.
- hint := byte('N')
- if in != "" {
- hint = resolveTable[in[0]]
- }
- if hint != 0 && tag != strTag && tag != binaryTag {
- // Handle things we can lookup in a map.
- if item, ok := resolveMap[in]; ok {
- return item.tag, item.value
- }
-
- // Base 60 floats are a bad idea, were dropped in YAML 1.2, and
- // are purposefully unsupported here. They're still quoted on
- // the way out for compatibility with other parser, though.
-
- switch hint {
- case 'M':
- // We've already checked the map above.
-
- case '.':
- // Not in the map, so maybe a normal float.
- floatv, err := strconv.ParseFloat(in, 64)
- if err == nil {
- return floatTag, floatv
- }
-
- case 'D', 'S':
- // Int, float, or timestamp.
- // Only try values as a timestamp if the value is unquoted or there's an explicit
- // !!timestamp tag.
- if tag == "" || tag == timestampTag {
- t, ok := parseTimestamp(in)
- if ok {
- return timestampTag, t
- }
- }
-
- plain := strings.Replace(in, "_", "", -1)
- intv, err := strconv.ParseInt(plain, 0, 64)
- if err == nil {
- if intv == int64(int(intv)) {
- return intTag, int(intv)
- } else {
- return intTag, intv
- }
- }
- uintv, err := strconv.ParseUint(plain, 0, 64)
- if err == nil {
- return intTag, uintv
- }
- if yamlStyleFloat.MatchString(plain) {
- floatv, err := strconv.ParseFloat(plain, 64)
- if err == nil {
- return floatTag, floatv
- }
- }
- if strings.HasPrefix(plain, "0b") {
- intv, err := strconv.ParseInt(plain[2:], 2, 64)
- if err == nil {
- if intv == int64(int(intv)) {
- return intTag, int(intv)
- } else {
- return intTag, intv
- }
- }
- uintv, err := strconv.ParseUint(plain[2:], 2, 64)
- if err == nil {
- return intTag, uintv
- }
- } else if strings.HasPrefix(plain, "-0b") {
- intv, err := strconv.ParseInt("-"+plain[3:], 2, 64)
- if err == nil {
- if true || intv == int64(int(intv)) {
- return intTag, int(intv)
- } else {
- return intTag, intv
- }
- }
- }
- // Octals as introduced in version 1.2 of the spec.
- // Octals from the 1.1 spec, spelled as 0777, are still
- // decoded by default in v3 as well for compatibility.
- // May be dropped in v4 depending on how usage evolves.
- if strings.HasPrefix(plain, "0o") {
- intv, err := strconv.ParseInt(plain[2:], 8, 64)
- if err == nil {
- if intv == int64(int(intv)) {
- return intTag, int(intv)
- } else {
- return intTag, intv
- }
- }
- uintv, err := strconv.ParseUint(plain[2:], 8, 64)
- if err == nil {
- return intTag, uintv
- }
- } else if strings.HasPrefix(plain, "-0o") {
- intv, err := strconv.ParseInt("-"+plain[3:], 8, 64)
- if err == nil {
- if true || intv == int64(int(intv)) {
- return intTag, int(intv)
- } else {
- return intTag, intv
- }
- }
- }
- default:
- panic("internal error: missing handler for resolver table: " + string(rune(hint)) + " (with " + in + ")")
- }
- }
- return strTag, in
-}
-
-// encodeBase64 encodes s as base64 that is broken up into multiple lines
-// as appropriate for the resulting length.
-func encodeBase64(s string) string {
- const lineLen = 70
- encLen := base64.StdEncoding.EncodedLen(len(s))
- lines := encLen/lineLen + 1
- buf := make([]byte, encLen*2+lines)
- in := buf[0:encLen]
- out := buf[encLen:]
- base64.StdEncoding.Encode(in, []byte(s))
- k := 0
- for i := 0; i < len(in); i += lineLen {
- j := i + lineLen
- if j > len(in) {
- j = len(in)
- }
- k += copy(out[k:], in[i:j])
- if lines > 1 {
- out[k] = '\n'
- k++
- }
- }
- return string(out[:k])
-}
-
-// This is a subset of the formats allowed by the regular expression
-// defined at http://yaml.org/type/timestamp.html.
-var allowedTimestampFormats = []string{
- "2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
- "2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
- "2006-1-2 15:4:5.999999999", // space separated with no time zone
- "2006-1-2", // date only
- // Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5"
- // from the set of examples.
-}
-
-// parseTimestamp parses s as a timestamp string and
-// returns the timestamp and reports whether it succeeded.
-// Timestamp formats are defined at http://yaml.org/type/timestamp.html
-func parseTimestamp(s string) (time.Time, bool) {
- // TODO write code to check all the formats supported by
- // http://yaml.org/type/timestamp.html instead of using time.Parse.
-
- // Quick check: all date formats start with YYYY-.
- i := 0
- for ; i < len(s); i++ {
- if c := s[i]; c < '0' || c > '9' {
- break
- }
- }
- if i != 4 || i == len(s) || s[i] != '-' {
- return time.Time{}, false
- }
- for _, format := range allowedTimestampFormats {
- if t, err := time.Parse(format, s); err == nil {
- return t, true
- }
- }
- return time.Time{}, false
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/scannerc.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/scannerc.go
deleted file mode 100644
index ca0070108f4ebe6a09a222075267e0ffca996e72..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/scannerc.go
+++ /dev/null
@@ -1,3038 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "bytes"
- "fmt"
-)
-
-// Introduction
-// ************
-//
-// The following notes assume that you are familiar with the YAML specification
-// (http://yaml.org/spec/1.2/spec.html). We mostly follow it, although in
-// some cases we are less restrictive that it requires.
-//
-// The process of transforming a YAML stream into a sequence of events is
-// divided on two steps: Scanning and Parsing.
-//
-// The Scanner transforms the input stream into a sequence of tokens, while the
-// parser transform the sequence of tokens produced by the Scanner into a
-// sequence of parsing events.
-//
-// The Scanner is rather clever and complicated. The Parser, on the contrary,
-// is a straightforward implementation of a recursive-descendant parser (or,
-// LL(1) parser, as it is usually called).
-//
-// Actually there are two issues of Scanning that might be called "clever", the
-// rest is quite straightforward. The issues are "block collection start" and
-// "simple keys". Both issues are explained below in details.
-//
-// Here the Scanning step is explained and implemented. We start with the list
-// of all the tokens produced by the Scanner together with short descriptions.
-//
-// Now, tokens:
-//
-// STREAM-START(encoding) # The stream start.
-// STREAM-END # The stream end.
-// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
-// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
-// DOCUMENT-START # '---'
-// DOCUMENT-END # '...'
-// BLOCK-SEQUENCE-START # Indentation increase denoting a block
-// BLOCK-MAPPING-START # sequence or a block mapping.
-// BLOCK-END # Indentation decrease.
-// FLOW-SEQUENCE-START # '['
-// FLOW-SEQUENCE-END # ']'
-// BLOCK-SEQUENCE-START # '{'
-// BLOCK-SEQUENCE-END # '}'
-// BLOCK-ENTRY # '-'
-// FLOW-ENTRY # ','
-// KEY # '?' or nothing (simple keys).
-// VALUE # ':'
-// ALIAS(anchor) # '*anchor'
-// ANCHOR(anchor) # '&anchor'
-// TAG(handle,suffix) # '!handle!suffix'
-// SCALAR(value,style) # A scalar.
-//
-// The following two tokens are "virtual" tokens denoting the beginning and the
-// end of the stream:
-//
-// STREAM-START(encoding)
-// STREAM-END
-//
-// We pass the information about the input stream encoding with the
-// STREAM-START token.
-//
-// The next two tokens are responsible for tags:
-//
-// VERSION-DIRECTIVE(major,minor)
-// TAG-DIRECTIVE(handle,prefix)
-//
-// Example:
-//
-// %YAML 1.1
-// %TAG ! !foo
-// %TAG !yaml! tag:yaml.org,2002:
-// ---
-//
-// The correspoding sequence of tokens:
-//
-// STREAM-START(utf-8)
-// VERSION-DIRECTIVE(1,1)
-// TAG-DIRECTIVE("!","!foo")
-// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
-// DOCUMENT-START
-// STREAM-END
-//
-// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
-// line.
-//
-// The document start and end indicators are represented by:
-//
-// DOCUMENT-START
-// DOCUMENT-END
-//
-// Note that if a YAML stream contains an implicit document (without '---'
-// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
-// produced.
-//
-// In the following examples, we present whole documents together with the
-// produced tokens.
-//
-// 1. An implicit document:
-//
-// 'a scalar'
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// SCALAR("a scalar",single-quoted)
-// STREAM-END
-//
-// 2. An explicit document:
-//
-// ---
-// 'a scalar'
-// ...
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// DOCUMENT-START
-// SCALAR("a scalar",single-quoted)
-// DOCUMENT-END
-// STREAM-END
-//
-// 3. Several documents in a stream:
-//
-// 'a scalar'
-// ---
-// 'another scalar'
-// ---
-// 'yet another scalar'
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// SCALAR("a scalar",single-quoted)
-// DOCUMENT-START
-// SCALAR("another scalar",single-quoted)
-// DOCUMENT-START
-// SCALAR("yet another scalar",single-quoted)
-// STREAM-END
-//
-// We have already introduced the SCALAR token above. The following tokens are
-// used to describe aliases, anchors, tag, and scalars:
-//
-// ALIAS(anchor)
-// ANCHOR(anchor)
-// TAG(handle,suffix)
-// SCALAR(value,style)
-//
-// The following series of examples illustrate the usage of these tokens:
-//
-// 1. A recursive sequence:
-//
-// &A [ *A ]
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// ANCHOR("A")
-// FLOW-SEQUENCE-START
-// ALIAS("A")
-// FLOW-SEQUENCE-END
-// STREAM-END
-//
-// 2. A tagged scalar:
-//
-// !!float "3.14" # A good approximation.
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// TAG("!!","float")
-// SCALAR("3.14",double-quoted)
-// STREAM-END
-//
-// 3. Various scalar styles:
-//
-// --- # Implicit empty plain scalars do not produce tokens.
-// --- a plain scalar
-// --- 'a single-quoted scalar'
-// --- "a double-quoted scalar"
-// --- |-
-// a literal scalar
-// --- >-
-// a folded
-// scalar
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// DOCUMENT-START
-// DOCUMENT-START
-// SCALAR("a plain scalar",plain)
-// DOCUMENT-START
-// SCALAR("a single-quoted scalar",single-quoted)
-// DOCUMENT-START
-// SCALAR("a double-quoted scalar",double-quoted)
-// DOCUMENT-START
-// SCALAR("a literal scalar",literal)
-// DOCUMENT-START
-// SCALAR("a folded scalar",folded)
-// STREAM-END
-//
-// Now it's time to review collection-related tokens. We will start with
-// flow collections:
-//
-// FLOW-SEQUENCE-START
-// FLOW-SEQUENCE-END
-// FLOW-MAPPING-START
-// FLOW-MAPPING-END
-// FLOW-ENTRY
-// KEY
-// VALUE
-//
-// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
-// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
-// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
-// indicators '?' and ':', which are used for denoting mapping keys and values,
-// are represented by the KEY and VALUE tokens.
-//
-// The following examples show flow collections:
-//
-// 1. A flow sequence:
-//
-// [item 1, item 2, item 3]
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// FLOW-SEQUENCE-START
-// SCALAR("item 1",plain)
-// FLOW-ENTRY
-// SCALAR("item 2",plain)
-// FLOW-ENTRY
-// SCALAR("item 3",plain)
-// FLOW-SEQUENCE-END
-// STREAM-END
-//
-// 2. A flow mapping:
-//
-// {
-// a simple key: a value, # Note that the KEY token is produced.
-// ? a complex key: another value,
-// }
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// FLOW-MAPPING-START
-// KEY
-// SCALAR("a simple key",plain)
-// VALUE
-// SCALAR("a value",plain)
-// FLOW-ENTRY
-// KEY
-// SCALAR("a complex key",plain)
-// VALUE
-// SCALAR("another value",plain)
-// FLOW-ENTRY
-// FLOW-MAPPING-END
-// STREAM-END
-//
-// A simple key is a key which is not denoted by the '?' indicator. Note that
-// the Scanner still produce the KEY token whenever it encounters a simple key.
-//
-// For scanning block collections, the following tokens are used (note that we
-// repeat KEY and VALUE here):
-//
-// BLOCK-SEQUENCE-START
-// BLOCK-MAPPING-START
-// BLOCK-END
-// BLOCK-ENTRY
-// KEY
-// VALUE
-//
-// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
-// increase that precedes a block collection (cf. the INDENT token in Python).
-// The token BLOCK-END denote indentation decrease that ends a block collection
-// (cf. the DEDENT token in Python). However YAML has some syntax pecularities
-// that makes detections of these tokens more complex.
-//
-// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
-// '-', '?', and ':' correspondingly.
-//
-// The following examples show how the tokens BLOCK-SEQUENCE-START,
-// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
-//
-// 1. Block sequences:
-//
-// - item 1
-// - item 2
-// -
-// - item 3.1
-// - item 3.2
-// -
-// key 1: value 1
-// key 2: value 2
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// SCALAR("item 1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 2",plain)
-// BLOCK-ENTRY
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// SCALAR("item 3.1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 3.2",plain)
-// BLOCK-END
-// BLOCK-ENTRY
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("key 1",plain)
-// VALUE
-// SCALAR("value 1",plain)
-// KEY
-// SCALAR("key 2",plain)
-// VALUE
-// SCALAR("value 2",plain)
-// BLOCK-END
-// BLOCK-END
-// STREAM-END
-//
-// 2. Block mappings:
-//
-// a simple key: a value # The KEY token is produced here.
-// ? a complex key
-// : another value
-// a mapping:
-// key 1: value 1
-// key 2: value 2
-// a sequence:
-// - item 1
-// - item 2
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("a simple key",plain)
-// VALUE
-// SCALAR("a value",plain)
-// KEY
-// SCALAR("a complex key",plain)
-// VALUE
-// SCALAR("another value",plain)
-// KEY
-// SCALAR("a mapping",plain)
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("key 1",plain)
-// VALUE
-// SCALAR("value 1",plain)
-// KEY
-// SCALAR("key 2",plain)
-// VALUE
-// SCALAR("value 2",plain)
-// BLOCK-END
-// KEY
-// SCALAR("a sequence",plain)
-// VALUE
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// SCALAR("item 1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 2",plain)
-// BLOCK-END
-// BLOCK-END
-// STREAM-END
-//
-// YAML does not always require to start a new block collection from a new
-// line. If the current line contains only '-', '?', and ':' indicators, a new
-// block collection may start at the current line. The following examples
-// illustrate this case:
-//
-// 1. Collections in a sequence:
-//
-// - - item 1
-// - item 2
-// - key 1: value 1
-// key 2: value 2
-// - ? complex key
-// : complex value
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// SCALAR("item 1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 2",plain)
-// BLOCK-END
-// BLOCK-ENTRY
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("key 1",plain)
-// VALUE
-// SCALAR("value 1",plain)
-// KEY
-// SCALAR("key 2",plain)
-// VALUE
-// SCALAR("value 2",plain)
-// BLOCK-END
-// BLOCK-ENTRY
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("complex key")
-// VALUE
-// SCALAR("complex value")
-// BLOCK-END
-// BLOCK-END
-// STREAM-END
-//
-// 2. Collections in a mapping:
-//
-// ? a sequence
-// : - item 1
-// - item 2
-// ? a mapping
-// : key 1: value 1
-// key 2: value 2
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("a sequence",plain)
-// VALUE
-// BLOCK-SEQUENCE-START
-// BLOCK-ENTRY
-// SCALAR("item 1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 2",plain)
-// BLOCK-END
-// KEY
-// SCALAR("a mapping",plain)
-// VALUE
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("key 1",plain)
-// VALUE
-// SCALAR("value 1",plain)
-// KEY
-// SCALAR("key 2",plain)
-// VALUE
-// SCALAR("value 2",plain)
-// BLOCK-END
-// BLOCK-END
-// STREAM-END
-//
-// YAML also permits non-indented sequences if they are included into a block
-// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
-//
-// key:
-// - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
-// - item 2
-//
-// Tokens:
-//
-// STREAM-START(utf-8)
-// BLOCK-MAPPING-START
-// KEY
-// SCALAR("key",plain)
-// VALUE
-// BLOCK-ENTRY
-// SCALAR("item 1",plain)
-// BLOCK-ENTRY
-// SCALAR("item 2",plain)
-// BLOCK-END
-//
-
-// Ensure that the buffer contains the required number of characters.
-// Return true on success, false on failure (reader error or memory error).
-func cache(parser *yaml_parser_t, length int) bool {
- // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B)
- return parser.unread >= length || yaml_parser_update_buffer(parser, length)
-}
-
-// Advance the buffer pointer.
-func skip(parser *yaml_parser_t) {
- if !is_blank(parser.buffer, parser.buffer_pos) {
- parser.newlines = 0
- }
- parser.mark.index++
- parser.mark.column++
- parser.unread--
- parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
-}
-
-func skip_line(parser *yaml_parser_t) {
- if is_crlf(parser.buffer, parser.buffer_pos) {
- parser.mark.index += 2
- parser.mark.column = 0
- parser.mark.line++
- parser.unread -= 2
- parser.buffer_pos += 2
- parser.newlines++
- } else if is_break(parser.buffer, parser.buffer_pos) {
- parser.mark.index++
- parser.mark.column = 0
- parser.mark.line++
- parser.unread--
- parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
- parser.newlines++
- }
-}
-
-// Copy a character to a string buffer and advance pointers.
-func read(parser *yaml_parser_t, s []byte) []byte {
- if !is_blank(parser.buffer, parser.buffer_pos) {
- parser.newlines = 0
- }
- w := width(parser.buffer[parser.buffer_pos])
- if w == 0 {
- panic("invalid character sequence")
- }
- if len(s) == 0 {
- s = make([]byte, 0, 32)
- }
- if w == 1 && len(s)+w <= cap(s) {
- s = s[:len(s)+1]
- s[len(s)-1] = parser.buffer[parser.buffer_pos]
- parser.buffer_pos++
- } else {
- s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...)
- parser.buffer_pos += w
- }
- parser.mark.index++
- parser.mark.column++
- parser.unread--
- return s
-}
-
-// Copy a line break character to a string buffer and advance pointers.
-func read_line(parser *yaml_parser_t, s []byte) []byte {
- buf := parser.buffer
- pos := parser.buffer_pos
- switch {
- case buf[pos] == '\r' && buf[pos+1] == '\n':
- // CR LF . LF
- s = append(s, '\n')
- parser.buffer_pos += 2
- parser.mark.index++
- parser.unread--
- case buf[pos] == '\r' || buf[pos] == '\n':
- // CR|LF . LF
- s = append(s, '\n')
- parser.buffer_pos += 1
- case buf[pos] == '\xC2' && buf[pos+1] == '\x85':
- // NEL . LF
- s = append(s, '\n')
- parser.buffer_pos += 2
- case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'):
- // LS|PS . LS|PS
- s = append(s, buf[parser.buffer_pos:pos+3]...)
- parser.buffer_pos += 3
- default:
- return s
- }
- parser.mark.index++
- parser.mark.column = 0
- parser.mark.line++
- parser.unread--
- parser.newlines++
- return s
-}
-
-// Get the next token.
-func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool {
- // Erase the token object.
- *token = yaml_token_t{} // [Go] Is this necessary?
-
- // No tokens after STREAM-END or error.
- if parser.stream_end_produced || parser.error != yaml_NO_ERROR {
- return true
- }
-
- // Ensure that the tokens queue contains enough tokens.
- if !parser.token_available {
- if !yaml_parser_fetch_more_tokens(parser) {
- return false
- }
- }
-
- // Fetch the next token from the queue.
- *token = parser.tokens[parser.tokens_head]
- parser.tokens_head++
- parser.tokens_parsed++
- parser.token_available = false
-
- if token.typ == yaml_STREAM_END_TOKEN {
- parser.stream_end_produced = true
- }
- return true
-}
-
-// Set the scanner error and return false.
-func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool {
- parser.error = yaml_SCANNER_ERROR
- parser.context = context
- parser.context_mark = context_mark
- parser.problem = problem
- parser.problem_mark = parser.mark
- return false
-}
-
-func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool {
- context := "while parsing a tag"
- if directive {
- context = "while parsing a %TAG directive"
- }
- return yaml_parser_set_scanner_error(parser, context, context_mark, problem)
-}
-
-func trace(args ...interface{}) func() {
- pargs := append([]interface{}{"+++"}, args...)
- fmt.Println(pargs...)
- pargs = append([]interface{}{"---"}, args...)
- return func() { fmt.Println(pargs...) }
-}
-
-// Ensure that the tokens queue contains at least one token which can be
-// returned to the Parser.
-func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
- // While we need more tokens to fetch, do it.
- for {
- // [Go] The comment parsing logic requires a lookahead of two tokens
- // so that foot comments may be parsed in time of associating them
- // with the tokens that are parsed before them, and also for line
- // comments to be transformed into head comments in some edge cases.
- if parser.tokens_head < len(parser.tokens)-2 {
- // If a potential simple key is at the head position, we need to fetch
- // the next token to disambiguate it.
- head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]
- if !ok {
- break
- } else if valid, ok := yaml_simple_key_is_valid(parser, &parser.simple_keys[head_tok_idx]); !ok {
- return false
- } else if !valid {
- break
- }
- }
- // Fetch the next token.
- if !yaml_parser_fetch_next_token(parser) {
- return false
- }
- }
-
- parser.token_available = true
- return true
-}
-
-// The dispatcher for token fetchers.
-func yaml_parser_fetch_next_token(parser *yaml_parser_t) (ok bool) {
- // Ensure that the buffer is initialized.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- // Check if we just started scanning. Fetch STREAM-START then.
- if !parser.stream_start_produced {
- return yaml_parser_fetch_stream_start(parser)
- }
-
- scan_mark := parser.mark
-
- // Eat whitespaces and comments until we reach the next token.
- if !yaml_parser_scan_to_next_token(parser) {
- return false
- }
-
- // [Go] While unrolling indents, transform the head comments of prior
- // indentation levels observed after scan_start into foot comments at
- // the respective indexes.
-
- // Check the indentation level against the current column.
- if !yaml_parser_unroll_indent(parser, parser.mark.column, scan_mark) {
- return false
- }
-
- // Ensure that the buffer contains at least 4 characters. 4 is the length
- // of the longest indicators ('--- ' and '... ').
- if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
- return false
- }
-
- // Is it the end of the stream?
- if is_z(parser.buffer, parser.buffer_pos) {
- return yaml_parser_fetch_stream_end(parser)
- }
-
- // Is it a directive?
- if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' {
- return yaml_parser_fetch_directive(parser)
- }
-
- buf := parser.buffer
- pos := parser.buffer_pos
-
- // Is it the document start indicator?
- if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) {
- return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN)
- }
-
- // Is it the document end indicator?
- if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) {
- return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
- }
-
- comment_mark := parser.mark
- if len(parser.tokens) > 0 && (parser.flow_level == 0 && buf[pos] == ':' || parser.flow_level > 0 && buf[pos] == ',') {
- // Associate any following comments with the prior token.
- comment_mark = parser.tokens[len(parser.tokens)-1].start_mark
- }
- defer func() {
- if !ok {
- return
- }
- if len(parser.tokens) > 0 && parser.tokens[len(parser.tokens)-1].typ == yaml_BLOCK_ENTRY_TOKEN {
- // Sequence indicators alone have no line comments. It becomes
- // a head comment for whatever follows.
- return
- }
- if !yaml_parser_scan_line_comment(parser, comment_mark) {
- ok = false
- return
- }
- }()
-
- // Is it the flow sequence start indicator?
- if buf[pos] == '[' {
- return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
- }
-
- // Is it the flow mapping start indicator?
- if parser.buffer[parser.buffer_pos] == '{' {
- return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN)
- }
-
- // Is it the flow sequence end indicator?
- if parser.buffer[parser.buffer_pos] == ']' {
- return yaml_parser_fetch_flow_collection_end(parser,
- yaml_FLOW_SEQUENCE_END_TOKEN)
- }
-
- // Is it the flow mapping end indicator?
- if parser.buffer[parser.buffer_pos] == '}' {
- return yaml_parser_fetch_flow_collection_end(parser,
- yaml_FLOW_MAPPING_END_TOKEN)
- }
-
- // Is it the flow entry indicator?
- if parser.buffer[parser.buffer_pos] == ',' {
- return yaml_parser_fetch_flow_entry(parser)
- }
-
- // Is it the block entry indicator?
- if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) {
- return yaml_parser_fetch_block_entry(parser)
- }
-
- // Is it the key indicator?
- if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
- return yaml_parser_fetch_key(parser)
- }
-
- // Is it the value indicator?
- if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
- return yaml_parser_fetch_value(parser)
- }
-
- // Is it an alias?
- if parser.buffer[parser.buffer_pos] == '*' {
- return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN)
- }
-
- // Is it an anchor?
- if parser.buffer[parser.buffer_pos] == '&' {
- return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN)
- }
-
- // Is it a tag?
- if parser.buffer[parser.buffer_pos] == '!' {
- return yaml_parser_fetch_tag(parser)
- }
-
- // Is it a literal scalar?
- if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 {
- return yaml_parser_fetch_block_scalar(parser, true)
- }
-
- // Is it a folded scalar?
- if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 {
- return yaml_parser_fetch_block_scalar(parser, false)
- }
-
- // Is it a single-quoted scalar?
- if parser.buffer[parser.buffer_pos] == '\'' {
- return yaml_parser_fetch_flow_scalar(parser, true)
- }
-
- // Is it a double-quoted scalar?
- if parser.buffer[parser.buffer_pos] == '"' {
- return yaml_parser_fetch_flow_scalar(parser, false)
- }
-
- // Is it a plain scalar?
- //
- // A plain scalar may start with any non-blank characters except
- //
- // '-', '?', ':', ',', '[', ']', '{', '}',
- // '#', '&', '*', '!', '|', '>', '\'', '\"',
- // '%', '@', '`'.
- //
- // In the block context (and, for the '-' indicator, in the flow context
- // too), it may also start with the characters
- //
- // '-', '?', ':'
- //
- // if it is followed by a non-space character.
- //
- // The last rule is more restrictive than the specification requires.
- // [Go] TODO Make this logic more reasonable.
- //switch parser.buffer[parser.buffer_pos] {
- //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':
- //}
- if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' ||
- parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' ||
- parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' ||
- parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
- parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' ||
- parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' ||
- parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' ||
- parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' ||
- parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' ||
- parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') ||
- (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) ||
- (parser.flow_level == 0 &&
- (parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') &&
- !is_blankz(parser.buffer, parser.buffer_pos+1)) {
- return yaml_parser_fetch_plain_scalar(parser)
- }
-
- // If we don't determine the token type so far, it is an error.
- return yaml_parser_set_scanner_error(parser,
- "while scanning for the next token", parser.mark,
- "found character that cannot start any token")
-}
-
-func yaml_simple_key_is_valid(parser *yaml_parser_t, simple_key *yaml_simple_key_t) (valid, ok bool) {
- if !simple_key.possible {
- return false, true
- }
-
- // The 1.2 specification says:
- //
- // "If the ? indicator is omitted, parsing needs to see past the
- // implicit key to recognize it as such. To limit the amount of
- // lookahead required, the “:” indicator must appear at most 1024
- // Unicode characters beyond the start of the key. In addition, the key
- // is restricted to a single line."
- //
- if simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index {
- // Check if the potential simple key to be removed is required.
- if simple_key.required {
- return false, yaml_parser_set_scanner_error(parser,
- "while scanning a simple key", simple_key.mark,
- "could not find expected ':'")
- }
- simple_key.possible = false
- return false, true
- }
- return true, true
-}
-
-// Check if a simple key may start at the current position and add it if
-// needed.
-func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {
- // A simple key is required at the current position if the scanner is in
- // the block context and the current column coincides with the indentation
- // level.
-
- required := parser.flow_level == 0 && parser.indent == parser.mark.column
-
- //
- // If the current position may start a simple key, save it.
- //
- if parser.simple_key_allowed {
- simple_key := yaml_simple_key_t{
- possible: true,
- required: required,
- token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
- mark: parser.mark,
- }
-
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
- parser.simple_keys[len(parser.simple_keys)-1] = simple_key
- parser.simple_keys_by_tok[simple_key.token_number] = len(parser.simple_keys) - 1
- }
- return true
-}
-
-// Remove a potential simple key at the current flow level.
-func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool {
- i := len(parser.simple_keys) - 1
- if parser.simple_keys[i].possible {
- // If the key is required, it is an error.
- if parser.simple_keys[i].required {
- return yaml_parser_set_scanner_error(parser,
- "while scanning a simple key", parser.simple_keys[i].mark,
- "could not find expected ':'")
- }
- // Remove the key from the stack.
- parser.simple_keys[i].possible = false
- delete(parser.simple_keys_by_tok, parser.simple_keys[i].token_number)
- }
- return true
-}
-
-// max_flow_level limits the flow_level
-const max_flow_level = 10000
-
-// Increase the flow level and resize the simple key list if needed.
-func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {
- // Reset the simple key on the next level.
- parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{
- possible: false,
- required: false,
- token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
- mark: parser.mark,
- })
-
- // Increase the flow level.
- parser.flow_level++
- if parser.flow_level > max_flow_level {
- return yaml_parser_set_scanner_error(parser,
- "while increasing flow level", parser.simple_keys[len(parser.simple_keys)-1].mark,
- fmt.Sprintf("exceeded max depth of %d", max_flow_level))
- }
- return true
-}
-
-// Decrease the flow level.
-func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool {
- if parser.flow_level > 0 {
- parser.flow_level--
- last := len(parser.simple_keys) - 1
- delete(parser.simple_keys_by_tok, parser.simple_keys[last].token_number)
- parser.simple_keys = parser.simple_keys[:last]
- }
- return true
-}
-
-// max_indents limits the indents stack size
-const max_indents = 10000
-
-// Push the current indentation level to the stack and set the new level
-// the current column is greater than the indentation level. In this case,
-// append or insert the specified token into the token queue.
-func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool {
- // In the flow context, do nothing.
- if parser.flow_level > 0 {
- return true
- }
-
- if parser.indent < column {
- // Push the current indentation level to the stack and set the new
- // indentation level.
- parser.indents = append(parser.indents, parser.indent)
- parser.indent = column
- if len(parser.indents) > max_indents {
- return yaml_parser_set_scanner_error(parser,
- "while increasing indent level", parser.simple_keys[len(parser.simple_keys)-1].mark,
- fmt.Sprintf("exceeded max depth of %d", max_indents))
- }
-
- // Create a token and insert it into the queue.
- token := yaml_token_t{
- typ: typ,
- start_mark: mark,
- end_mark: mark,
- }
- if number > -1 {
- number -= parser.tokens_parsed
- }
- yaml_insert_token(parser, number, &token)
- }
- return true
-}
-
-// Pop indentation levels from the indents stack until the current level
-// becomes less or equal to the column. For each indentation level, append
-// the BLOCK-END token.
-func yaml_parser_unroll_indent(parser *yaml_parser_t, column int, scan_mark yaml_mark_t) bool {
- // In the flow context, do nothing.
- if parser.flow_level > 0 {
- return true
- }
-
- block_mark := scan_mark
- block_mark.index--
-
- // Loop through the indentation levels in the stack.
- for parser.indent > column {
-
- // [Go] Reposition the end token before potential following
- // foot comments of parent blocks. For that, search
- // backwards for recent comments that were at the same
- // indent as the block that is ending now.
- stop_index := block_mark.index
- for i := len(parser.comments) - 1; i >= 0; i-- {
- comment := &parser.comments[i]
-
- if comment.end_mark.index < stop_index {
- // Don't go back beyond the start of the comment/whitespace scan, unless column < 0.
- // If requested indent column is < 0, then the document is over and everything else
- // is a foot anyway.
- break
- }
- if comment.start_mark.column == parser.indent+1 {
- // This is a good match. But maybe there's a former comment
- // at that same indent level, so keep searching.
- block_mark = comment.start_mark
- }
-
- // While the end of the former comment matches with
- // the start of the following one, we know there's
- // nothing in between and scanning is still safe.
- stop_index = comment.scan_mark.index
- }
-
- // Create a token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_BLOCK_END_TOKEN,
- start_mark: block_mark,
- end_mark: block_mark,
- }
- yaml_insert_token(parser, -1, &token)
-
- // Pop the indentation level.
- parser.indent = parser.indents[len(parser.indents)-1]
- parser.indents = parser.indents[:len(parser.indents)-1]
- }
- return true
-}
-
-// Initialize the scanner and produce the STREAM-START token.
-func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool {
-
- // Set the initial indentation.
- parser.indent = -1
-
- // Initialize the simple key stack.
- parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
-
- parser.simple_keys_by_tok = make(map[int]int)
-
- // A simple key is allowed at the beginning of the stream.
- parser.simple_key_allowed = true
-
- // We have started.
- parser.stream_start_produced = true
-
- // Create the STREAM-START token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_STREAM_START_TOKEN,
- start_mark: parser.mark,
- end_mark: parser.mark,
- encoding: parser.encoding,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the STREAM-END token and shut down the scanner.
-func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
-
- // Force new line.
- if parser.mark.column != 0 {
- parser.mark.column = 0
- parser.mark.line++
- }
-
- // Reset the indentation level.
- if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
- return false
- }
-
- // Reset simple keys.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- parser.simple_key_allowed = false
-
- // Create the STREAM-END token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_STREAM_END_TOKEN,
- start_mark: parser.mark,
- end_mark: parser.mark,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
-func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
- // Reset the indentation level.
- if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
- return false
- }
-
- // Reset simple keys.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- parser.simple_key_allowed = false
-
- // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token.
- token := yaml_token_t{}
- if !yaml_parser_scan_directive(parser, &token) {
- return false
- }
- // Append the token to the queue.
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the DOCUMENT-START or DOCUMENT-END token.
-func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
- // Reset the indentation level.
- if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
- return false
- }
-
- // Reset simple keys.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- parser.simple_key_allowed = false
-
- // Consume the token.
- start_mark := parser.mark
-
- skip(parser)
- skip(parser)
- skip(parser)
-
- end_mark := parser.mark
-
- // Create the DOCUMENT-START or DOCUMENT-END token.
- token := yaml_token_t{
- typ: typ,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- // Append the token to the queue.
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
-func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
-
- // The indicators '[' and '{' may start a simple key.
- if !yaml_parser_save_simple_key(parser) {
- return false
- }
-
- // Increase the flow level.
- if !yaml_parser_increase_flow_level(parser) {
- return false
- }
-
- // A simple key may follow the indicators '[' and '{'.
- parser.simple_key_allowed = true
-
- // Consume the token.
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token.
- token := yaml_token_t{
- typ: typ,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- // Append the token to the queue.
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
-func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool {
- // Reset any potential simple key on the current flow level.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- // Decrease the flow level.
- if !yaml_parser_decrease_flow_level(parser) {
- return false
- }
-
- // No simple keys after the indicators ']' and '}'.
- parser.simple_key_allowed = false
-
- // Consume the token.
-
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token.
- token := yaml_token_t{
- typ: typ,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- // Append the token to the queue.
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the FLOW-ENTRY token.
-func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool {
- // Reset any potential simple keys on the current flow level.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- // Simple keys are allowed after ','.
- parser.simple_key_allowed = true
-
- // Consume the token.
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the FLOW-ENTRY token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_FLOW_ENTRY_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the BLOCK-ENTRY token.
-func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool {
- // Check if the scanner is in the block context.
- if parser.flow_level == 0 {
- // Check if we are allowed to start a new entry.
- if !parser.simple_key_allowed {
- return yaml_parser_set_scanner_error(parser, "", parser.mark,
- "block sequence entries are not allowed in this context")
- }
- // Add the BLOCK-SEQUENCE-START token if needed.
- if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) {
- return false
- }
- } else {
- // It is an error for the '-' indicator to occur in the flow context,
- // but we let the Parser detect and report about it because the Parser
- // is able to point to the context.
- }
-
- // Reset any potential simple keys on the current flow level.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- // Simple keys are allowed after '-'.
- parser.simple_key_allowed = true
-
- // Consume the token.
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the BLOCK-ENTRY token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_BLOCK_ENTRY_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the KEY token.
-func yaml_parser_fetch_key(parser *yaml_parser_t) bool {
-
- // In the block context, additional checks are required.
- if parser.flow_level == 0 {
- // Check if we are allowed to start a new key (not nessesary simple).
- if !parser.simple_key_allowed {
- return yaml_parser_set_scanner_error(parser, "", parser.mark,
- "mapping keys are not allowed in this context")
- }
- // Add the BLOCK-MAPPING-START token if needed.
- if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
- return false
- }
- }
-
- // Reset any potential simple keys on the current flow level.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- // Simple keys are allowed after '?' in the block context.
- parser.simple_key_allowed = parser.flow_level == 0
-
- // Consume the token.
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the KEY token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_KEY_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the VALUE token.
-func yaml_parser_fetch_value(parser *yaml_parser_t) bool {
-
- simple_key := &parser.simple_keys[len(parser.simple_keys)-1]
-
- // Have we found a simple key?
- if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {
- return false
-
- } else if valid {
-
- // Create the KEY token and insert it into the queue.
- token := yaml_token_t{
- typ: yaml_KEY_TOKEN,
- start_mark: simple_key.mark,
- end_mark: simple_key.mark,
- }
- yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token)
-
- // In the block context, we may need to add the BLOCK-MAPPING-START token.
- if !yaml_parser_roll_indent(parser, simple_key.mark.column,
- simple_key.token_number,
- yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) {
- return false
- }
-
- // Remove the simple key.
- simple_key.possible = false
- delete(parser.simple_keys_by_tok, simple_key.token_number)
-
- // A simple key cannot follow another simple key.
- parser.simple_key_allowed = false
-
- } else {
- // The ':' indicator follows a complex key.
-
- // In the block context, extra checks are required.
- if parser.flow_level == 0 {
-
- // Check if we are allowed to start a complex value.
- if !parser.simple_key_allowed {
- return yaml_parser_set_scanner_error(parser, "", parser.mark,
- "mapping values are not allowed in this context")
- }
-
- // Add the BLOCK-MAPPING-START token if needed.
- if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
- return false
- }
- }
-
- // Simple keys after ':' are allowed in the block context.
- parser.simple_key_allowed = parser.flow_level == 0
- }
-
- // Consume the token.
- start_mark := parser.mark
- skip(parser)
- end_mark := parser.mark
-
- // Create the VALUE token and append it to the queue.
- token := yaml_token_t{
- typ: yaml_VALUE_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the ALIAS or ANCHOR token.
-func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
- // An anchor or an alias could be a simple key.
- if !yaml_parser_save_simple_key(parser) {
- return false
- }
-
- // A simple key cannot follow an anchor or an alias.
- parser.simple_key_allowed = false
-
- // Create the ALIAS or ANCHOR token and append it to the queue.
- var token yaml_token_t
- if !yaml_parser_scan_anchor(parser, &token, typ) {
- return false
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the TAG token.
-func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
- // A tag could be a simple key.
- if !yaml_parser_save_simple_key(parser) {
- return false
- }
-
- // A simple key cannot follow a tag.
- parser.simple_key_allowed = false
-
- // Create the TAG token and append it to the queue.
- var token yaml_token_t
- if !yaml_parser_scan_tag(parser, &token) {
- return false
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
-func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool {
- // Remove any potential simple keys.
- if !yaml_parser_remove_simple_key(parser) {
- return false
- }
-
- // A simple key may follow a block scalar.
- parser.simple_key_allowed = true
-
- // Create the SCALAR token and append it to the queue.
- var token yaml_token_t
- if !yaml_parser_scan_block_scalar(parser, &token, literal) {
- return false
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
-func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool {
- // A plain scalar could be a simple key.
- if !yaml_parser_save_simple_key(parser) {
- return false
- }
-
- // A simple key cannot follow a flow scalar.
- parser.simple_key_allowed = false
-
- // Create the SCALAR token and append it to the queue.
- var token yaml_token_t
- if !yaml_parser_scan_flow_scalar(parser, &token, single) {
- return false
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Produce the SCALAR(...,plain) token.
-func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {
- // A plain scalar could be a simple key.
- if !yaml_parser_save_simple_key(parser) {
- return false
- }
-
- // A simple key cannot follow a flow scalar.
- parser.simple_key_allowed = false
-
- // Create the SCALAR token and append it to the queue.
- var token yaml_token_t
- if !yaml_parser_scan_plain_scalar(parser, &token) {
- return false
- }
- yaml_insert_token(parser, -1, &token)
- return true
-}
-
-// Eat whitespaces and comments until the next token is found.
-func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
-
- scan_mark := parser.mark
-
- // Until the next token is not found.
- for {
- // Allow the BOM mark to start a line.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
- skip(parser)
- }
-
- // Eat whitespaces.
- // Tabs are allowed:
- // - in the flow context
- // - in the block context, but not at the beginning of the line or
- // after '-', '?', or ':' (complex value).
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Check if we just had a line comment under a sequence entry that
- // looks more like a header to the following content. Similar to this:
- //
- // - # The comment
- // - Some data
- //
- // If so, transform the line comment to a head comment and reposition.
- if len(parser.comments) > 0 && len(parser.tokens) > 1 {
- tokenA := parser.tokens[len(parser.tokens)-2]
- tokenB := parser.tokens[len(parser.tokens)-1]
- comment := &parser.comments[len(parser.comments)-1]
- if tokenA.typ == yaml_BLOCK_SEQUENCE_START_TOKEN && tokenB.typ == yaml_BLOCK_ENTRY_TOKEN && len(comment.line) > 0 && !is_break(parser.buffer, parser.buffer_pos) {
- // If it was in the prior line, reposition so it becomes a
- // header of the follow up token. Otherwise, keep it in place
- // so it becomes a header of the former.
- comment.head = comment.line
- comment.line = nil
- if comment.start_mark.line == parser.mark.line-1 {
- comment.token_mark = parser.mark
- }
- }
- }
-
- // Eat a comment until a line break.
- if parser.buffer[parser.buffer_pos] == '#' {
- if !yaml_parser_scan_comments(parser, scan_mark) {
- return false
- }
- }
-
- // If it is a line break, eat it.
- if is_break(parser.buffer, parser.buffer_pos) {
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- skip_line(parser)
-
- // In the block context, a new line may start a simple key.
- if parser.flow_level == 0 {
- parser.simple_key_allowed = true
- }
- } else {
- break // We have found a token.
- }
- }
-
- return true
-}
-
-// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
-//
-// Scope:
-// %YAML 1.1 # a comment \n
-// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-// %TAG !yaml! tag:yaml.org,2002: \n
-// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//
-func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool {
- // Eat '%'.
- start_mark := parser.mark
- skip(parser)
-
- // Scan the directive name.
- var name []byte
- if !yaml_parser_scan_directive_name(parser, start_mark, &name) {
- return false
- }
-
- // Is it a YAML directive?
- if bytes.Equal(name, []byte("YAML")) {
- // Scan the VERSION directive value.
- var major, minor int8
- if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) {
- return false
- }
- end_mark := parser.mark
-
- // Create a VERSION-DIRECTIVE token.
- *token = yaml_token_t{
- typ: yaml_VERSION_DIRECTIVE_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- major: major,
- minor: minor,
- }
-
- // Is it a TAG directive?
- } else if bytes.Equal(name, []byte("TAG")) {
- // Scan the TAG directive value.
- var handle, prefix []byte
- if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) {
- return false
- }
- end_mark := parser.mark
-
- // Create a TAG-DIRECTIVE token.
- *token = yaml_token_t{
- typ: yaml_TAG_DIRECTIVE_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- value: handle,
- prefix: prefix,
- }
-
- // Unknown directive.
- } else {
- yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "found unknown directive name")
- return false
- }
-
- // Eat the rest of the line including any comments.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- for is_blank(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- if parser.buffer[parser.buffer_pos] == '#' {
- // [Go] Discard this inline comment for the time being.
- //if !yaml_parser_scan_line_comment(parser, start_mark) {
- // return false
- //}
- for !is_breakz(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
- }
-
- // Check if we are at the end of the line.
- if !is_breakz(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "did not find expected comment or line break")
- return false
- }
-
- // Eat a line break.
- if is_break(parser.buffer, parser.buffer_pos) {
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- skip_line(parser)
- }
-
- return true
-}
-
-// Scan the directive name.
-//
-// Scope:
-// %YAML 1.1 # a comment \n
-// ^^^^
-// %TAG !yaml! tag:yaml.org,2002: \n
-// ^^^
-//
-func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool {
- // Consume the directive name.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- var s []byte
- for is_alpha(parser.buffer, parser.buffer_pos) {
- s = read(parser, s)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Check if the name is empty.
- if len(s) == 0 {
- yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "could not find expected directive name")
- return false
- }
-
- // Check for an blank character after the name.
- if !is_blankz(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a directive",
- start_mark, "found unexpected non-alphabetical character")
- return false
- }
- *name = s
- return true
-}
-
-// Scan the value of VERSION-DIRECTIVE.
-//
-// Scope:
-// %YAML 1.1 # a comment \n
-// ^^^^^^
-func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool {
- // Eat whitespaces.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- for is_blank(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Consume the major version number.
- if !yaml_parser_scan_version_directive_number(parser, start_mark, major) {
- return false
- }
-
- // Eat '.'.
- if parser.buffer[parser.buffer_pos] != '.' {
- return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
- start_mark, "did not find expected digit or '.' character")
- }
-
- skip(parser)
-
- // Consume the minor version number.
- if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) {
- return false
- }
- return true
-}
-
-const max_number_length = 2
-
-// Scan the version number of VERSION-DIRECTIVE.
-//
-// Scope:
-// %YAML 1.1 # a comment \n
-// ^
-// %YAML 1.1 # a comment \n
-// ^
-func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool {
-
- // Repeat while the next character is digit.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- var value, length int8
- for is_digit(parser.buffer, parser.buffer_pos) {
- // Check if the number is too long.
- length++
- if length > max_number_length {
- return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
- start_mark, "found extremely long version number")
- }
- value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos))
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Check if the number was present.
- if length == 0 {
- return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
- start_mark, "did not find expected version number")
- }
- *number = value
- return true
-}
-
-// Scan the value of a TAG-DIRECTIVE token.
-//
-// Scope:
-// %TAG !yaml! tag:yaml.org,2002: \n
-// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//
-func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool {
- var handle_value, prefix_value []byte
-
- // Eat whitespaces.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- for is_blank(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Scan a handle.
- if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) {
- return false
- }
-
- // Expect a whitespace.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if !is_blank(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
- start_mark, "did not find expected whitespace")
- return false
- }
-
- // Eat whitespaces.
- for is_blank(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Scan a prefix.
- if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) {
- return false
- }
-
- // Expect a whitespace or line break.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if !is_blankz(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
- start_mark, "did not find expected whitespace or line break")
- return false
- }
-
- *handle = handle_value
- *prefix = prefix_value
- return true
-}
-
-func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool {
- var s []byte
-
- // Eat the indicator character.
- start_mark := parser.mark
- skip(parser)
-
- // Consume the value.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- for is_alpha(parser.buffer, parser.buffer_pos) {
- s = read(parser, s)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- end_mark := parser.mark
-
- /*
- * Check if length of the anchor is greater than 0 and it is followed by
- * a whitespace character or one of the indicators:
- *
- * '?', ':', ',', ']', '}', '%', '@', '`'.
- */
-
- if len(s) == 0 ||
- !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' ||
- parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' ||
- parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' ||
- parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' ||
- parser.buffer[parser.buffer_pos] == '`') {
- context := "while scanning an alias"
- if typ == yaml_ANCHOR_TOKEN {
- context = "while scanning an anchor"
- }
- yaml_parser_set_scanner_error(parser, context, start_mark,
- "did not find expected alphabetic or numeric character")
- return false
- }
-
- // Create a token.
- *token = yaml_token_t{
- typ: typ,
- start_mark: start_mark,
- end_mark: end_mark,
- value: s,
- }
-
- return true
-}
-
-/*
- * Scan a TAG token.
- */
-
-func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool {
- var handle, suffix []byte
-
- start_mark := parser.mark
-
- // Check if the tag is in the canonical form.
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
-
- if parser.buffer[parser.buffer_pos+1] == '<' {
- // Keep the handle as ''
-
- // Eat '!<'
- skip(parser)
- skip(parser)
-
- // Consume the tag value.
- if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
- return false
- }
-
- // Check for '>' and eat it.
- if parser.buffer[parser.buffer_pos] != '>' {
- yaml_parser_set_scanner_error(parser, "while scanning a tag",
- start_mark, "did not find the expected '>'")
- return false
- }
-
- skip(parser)
- } else {
- // The tag has either the '!suffix' or the '!handle!suffix' form.
-
- // First, try to scan a handle.
- if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) {
- return false
- }
-
- // Check if it is, indeed, handle.
- if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' {
- // Scan the suffix now.
- if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
- return false
- }
- } else {
- // It wasn't a handle after all. Scan the rest of the tag.
- if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) {
- return false
- }
-
- // Set the handle to '!'.
- handle = []byte{'!'}
-
- // A special case: the '!' tag. Set the handle to '' and the
- // suffix to '!'.
- if len(suffix) == 0 {
- handle, suffix = suffix, handle
- }
- }
- }
-
- // Check the character which ends the tag.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if !is_blankz(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a tag",
- start_mark, "did not find expected whitespace or line break")
- return false
- }
-
- end_mark := parser.mark
-
- // Create a token.
- *token = yaml_token_t{
- typ: yaml_TAG_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- value: handle,
- suffix: suffix,
- }
- return true
-}
-
-// Scan a tag handle.
-func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {
- // Check the initial '!' character.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if parser.buffer[parser.buffer_pos] != '!' {
- yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "did not find expected '!'")
- return false
- }
-
- var s []byte
-
- // Copy the '!' character.
- s = read(parser, s)
-
- // Copy all subsequent alphabetical and numerical characters.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- for is_alpha(parser.buffer, parser.buffer_pos) {
- s = read(parser, s)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Check if the trailing character is '!' and copy it.
- if parser.buffer[parser.buffer_pos] == '!' {
- s = read(parser, s)
- } else {
- // It's either the '!' tag or not really a tag handle. If it's a %TAG
- // directive, it's an error. If it's a tag token, it must be a part of URI.
- if directive && string(s) != "!" {
- yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "did not find expected '!'")
- return false
- }
- }
-
- *handle = s
- return true
-}
-
-// Scan a tag.
-func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {
- //size_t length = head ? strlen((char *)head) : 0
- var s []byte
- hasTag := len(head) > 0
-
- // Copy the head if needed.
- //
- // Note that we don't copy the leading '!' character.
- if len(head) > 1 {
- s = append(s, head[1:]...)
- }
-
- // Scan the tag.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- // The set of characters that may appear in URI is as follows:
- //
- // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
- // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
- // '%'.
- // [Go] TODO Convert this into more reasonable logic.
- for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
- parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
- parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
- parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||
- parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||
- parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||
- parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||
- parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||
- parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||
- parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||
- parser.buffer[parser.buffer_pos] == '%' {
- // Check if it is a URI-escape sequence.
- if parser.buffer[parser.buffer_pos] == '%' {
- if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
- return false
- }
- } else {
- s = read(parser, s)
- }
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- hasTag = true
- }
-
- if !hasTag {
- yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "did not find expected tag URI")
- return false
- }
- *uri = s
- return true
-}
-
-// Decode an URI-escape sequence corresponding to a single UTF-8 character.
-func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {
-
- // Decode the required number of characters.
- w := 1024
- for w > 0 {
- // Check for a URI-escaped octet.
- if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
- return false
- }
-
- if !(parser.buffer[parser.buffer_pos] == '%' &&
- is_hex(parser.buffer, parser.buffer_pos+1) &&
- is_hex(parser.buffer, parser.buffer_pos+2)) {
- return yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "did not find URI escaped octet")
- }
-
- // Get the octet.
- octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
-
- // If it is the leading octet, determine the length of the UTF-8 sequence.
- if w == 1024 {
- w = width(octet)
- if w == 0 {
- return yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "found an incorrect leading UTF-8 octet")
- }
- } else {
- // Check if the trailing octet is correct.
- if octet&0xC0 != 0x80 {
- return yaml_parser_set_scanner_tag_error(parser, directive,
- start_mark, "found an incorrect trailing UTF-8 octet")
- }
- }
-
- // Copy the octet and move the pointers.
- *s = append(*s, octet)
- skip(parser)
- skip(parser)
- skip(parser)
- w--
- }
- return true
-}
-
-// Scan a block scalar.
-func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool {
- // Eat the indicator '|' or '>'.
- start_mark := parser.mark
- skip(parser)
-
- // Scan the additional block scalar indicators.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- // Check for a chomping indicator.
- var chomping, increment int
- if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
- // Set the chomping method and eat the indicator.
- if parser.buffer[parser.buffer_pos] == '+' {
- chomping = +1
- } else {
- chomping = -1
- }
- skip(parser)
-
- // Check for an indentation indicator.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if is_digit(parser.buffer, parser.buffer_pos) {
- // Check that the indentation is greater than 0.
- if parser.buffer[parser.buffer_pos] == '0' {
- yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an indentation indicator equal to 0")
- return false
- }
-
- // Get the indentation level and eat the indicator.
- increment = as_digit(parser.buffer, parser.buffer_pos)
- skip(parser)
- }
-
- } else if is_digit(parser.buffer, parser.buffer_pos) {
- // Do the same as above, but in the opposite order.
-
- if parser.buffer[parser.buffer_pos] == '0' {
- yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found an indentation indicator equal to 0")
- return false
- }
- increment = as_digit(parser.buffer, parser.buffer_pos)
- skip(parser)
-
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
- if parser.buffer[parser.buffer_pos] == '+' {
- chomping = +1
- } else {
- chomping = -1
- }
- skip(parser)
- }
- }
-
- // Eat whitespaces and comments to the end of the line.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- for is_blank(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
- if parser.buffer[parser.buffer_pos] == '#' {
- if !yaml_parser_scan_line_comment(parser, start_mark) {
- return false
- }
- for !is_breakz(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
- }
-
- // Check if we are at the end of the line.
- if !is_breakz(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "did not find expected comment or line break")
- return false
- }
-
- // Eat a line break.
- if is_break(parser.buffer, parser.buffer_pos) {
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- skip_line(parser)
- }
-
- end_mark := parser.mark
-
- // Set the indentation level if it was specified.
- var indent int
- if increment > 0 {
- if parser.indent >= 0 {
- indent = parser.indent + increment
- } else {
- indent = increment
- }
- }
-
- // Scan the leading line breaks and determine the indentation level if needed.
- var s, leading_break, trailing_breaks []byte
- if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
- return false
- }
-
- // Scan the block scalar content.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- var leading_blank, trailing_blank bool
- for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) {
- // We are at the beginning of a non-empty line.
-
- // Is it a trailing whitespace?
- trailing_blank = is_blank(parser.buffer, parser.buffer_pos)
-
- // Check if we need to fold the leading line break.
- if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' {
- // Do we need to join the lines by space?
- if len(trailing_breaks) == 0 {
- s = append(s, ' ')
- }
- } else {
- s = append(s, leading_break...)
- }
- leading_break = leading_break[:0]
-
- // Append the remaining line breaks.
- s = append(s, trailing_breaks...)
- trailing_breaks = trailing_breaks[:0]
-
- // Is it a leading whitespace?
- leading_blank = is_blank(parser.buffer, parser.buffer_pos)
-
- // Consume the current line.
- for !is_breakz(parser.buffer, parser.buffer_pos) {
- s = read(parser, s)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Consume the line break.
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
-
- leading_break = read_line(parser, leading_break)
-
- // Eat the following indentation spaces and line breaks.
- if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
- return false
- }
- }
-
- // Chomp the tail.
- if chomping != -1 {
- s = append(s, leading_break...)
- }
- if chomping == 1 {
- s = append(s, trailing_breaks...)
- }
-
- // Create a token.
- *token = yaml_token_t{
- typ: yaml_SCALAR_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- value: s,
- style: yaml_LITERAL_SCALAR_STYLE,
- }
- if !literal {
- token.style = yaml_FOLDED_SCALAR_STYLE
- }
- return true
-}
-
-// Scan indentation spaces and line breaks for a block scalar. Determine the
-// indentation level if needed.
-func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
- *end_mark = parser.mark
-
- // Eat the indentation spaces and line breaks.
- max_indent := 0
- for {
- // Eat the indentation spaces.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {
- skip(parser)
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
- if parser.mark.column > max_indent {
- max_indent = parser.mark.column
- }
-
- // Check for a tab character messing the indentation.
- if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
- return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
- start_mark, "found a tab character where an indentation space is expected")
- }
-
- // Have we found a non-empty line?
- if !is_break(parser.buffer, parser.buffer_pos) {
- break
- }
-
- // Consume the line break.
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- // [Go] Should really be returning breaks instead.
- *breaks = read_line(parser, *breaks)
- *end_mark = parser.mark
- }
-
- // Determine the indentation level if needed.
- if *indent == 0 {
- *indent = max_indent
- if *indent < parser.indent+1 {
- *indent = parser.indent + 1
- }
- if *indent < 1 {
- *indent = 1
- }
- }
- return true
-}
-
-// Scan a quoted scalar.
-func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool {
- // Eat the left quote.
- start_mark := parser.mark
- skip(parser)
-
- // Consume the content of the quoted scalar.
- var s, leading_break, trailing_breaks, whitespaces []byte
- for {
- // Check that there are no document indicators at the beginning of the line.
- if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
- return false
- }
-
- if parser.mark.column == 0 &&
- ((parser.buffer[parser.buffer_pos+0] == '-' &&
- parser.buffer[parser.buffer_pos+1] == '-' &&
- parser.buffer[parser.buffer_pos+2] == '-') ||
- (parser.buffer[parser.buffer_pos+0] == '.' &&
- parser.buffer[parser.buffer_pos+1] == '.' &&
- parser.buffer[parser.buffer_pos+2] == '.')) &&
- is_blankz(parser.buffer, parser.buffer_pos+3) {
- yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
- start_mark, "found unexpected document indicator")
- return false
- }
-
- // Check for EOF.
- if is_z(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
- start_mark, "found unexpected end of stream")
- return false
- }
-
- // Consume non-blank characters.
- leading_blanks := false
- for !is_blankz(parser.buffer, parser.buffer_pos) {
- if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' {
- // Is is an escaped single quote.
- s = append(s, '\'')
- skip(parser)
- skip(parser)
-
- } else if single && parser.buffer[parser.buffer_pos] == '\'' {
- // It is a right single quote.
- break
- } else if !single && parser.buffer[parser.buffer_pos] == '"' {
- // It is a right double quote.
- break
-
- } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) {
- // It is an escaped line break.
- if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
- return false
- }
- skip(parser)
- skip_line(parser)
- leading_blanks = true
- break
-
- } else if !single && parser.buffer[parser.buffer_pos] == '\\' {
- // It is an escape sequence.
- code_length := 0
-
- // Check the escape character.
- switch parser.buffer[parser.buffer_pos+1] {
- case '0':
- s = append(s, 0)
- case 'a':
- s = append(s, '\x07')
- case 'b':
- s = append(s, '\x08')
- case 't', '\t':
- s = append(s, '\x09')
- case 'n':
- s = append(s, '\x0A')
- case 'v':
- s = append(s, '\x0B')
- case 'f':
- s = append(s, '\x0C')
- case 'r':
- s = append(s, '\x0D')
- case 'e':
- s = append(s, '\x1B')
- case ' ':
- s = append(s, '\x20')
- case '"':
- s = append(s, '"')
- case '\'':
- s = append(s, '\'')
- case '\\':
- s = append(s, '\\')
- case 'N': // NEL (#x85)
- s = append(s, '\xC2')
- s = append(s, '\x85')
- case '_': // #xA0
- s = append(s, '\xC2')
- s = append(s, '\xA0')
- case 'L': // LS (#x2028)
- s = append(s, '\xE2')
- s = append(s, '\x80')
- s = append(s, '\xA8')
- case 'P': // PS (#x2029)
- s = append(s, '\xE2')
- s = append(s, '\x80')
- s = append(s, '\xA9')
- case 'x':
- code_length = 2
- case 'u':
- code_length = 4
- case 'U':
- code_length = 8
- default:
- yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
- start_mark, "found unknown escape character")
- return false
- }
-
- skip(parser)
- skip(parser)
-
- // Consume an arbitrary escape code.
- if code_length > 0 {
- var value int
-
- // Scan the character value.
- if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) {
- return false
- }
- for k := 0; k < code_length; k++ {
- if !is_hex(parser.buffer, parser.buffer_pos+k) {
- yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
- start_mark, "did not find expected hexdecimal number")
- return false
- }
- value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k)
- }
-
- // Check the value and write the character.
- if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF {
- yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
- start_mark, "found invalid Unicode character escape code")
- return false
- }
- if value <= 0x7F {
- s = append(s, byte(value))
- } else if value <= 0x7FF {
- s = append(s, byte(0xC0+(value>>6)))
- s = append(s, byte(0x80+(value&0x3F)))
- } else if value <= 0xFFFF {
- s = append(s, byte(0xE0+(value>>12)))
- s = append(s, byte(0x80+((value>>6)&0x3F)))
- s = append(s, byte(0x80+(value&0x3F)))
- } else {
- s = append(s, byte(0xF0+(value>>18)))
- s = append(s, byte(0x80+((value>>12)&0x3F)))
- s = append(s, byte(0x80+((value>>6)&0x3F)))
- s = append(s, byte(0x80+(value&0x3F)))
- }
-
- // Advance the pointer.
- for k := 0; k < code_length; k++ {
- skip(parser)
- }
- }
- } else {
- // It is a non-escaped non-blank character.
- s = read(parser, s)
- }
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- }
-
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- // Check if we are at the end of the scalar.
- if single {
- if parser.buffer[parser.buffer_pos] == '\'' {
- break
- }
- } else {
- if parser.buffer[parser.buffer_pos] == '"' {
- break
- }
- }
-
- // Consume blank characters.
- for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
- if is_blank(parser.buffer, parser.buffer_pos) {
- // Consume a space or a tab character.
- if !leading_blanks {
- whitespaces = read(parser, whitespaces)
- } else {
- skip(parser)
- }
- } else {
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
-
- // Check if it is a first line break.
- if !leading_blanks {
- whitespaces = whitespaces[:0]
- leading_break = read_line(parser, leading_break)
- leading_blanks = true
- } else {
- trailing_breaks = read_line(parser, trailing_breaks)
- }
- }
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Join the whitespaces or fold line breaks.
- if leading_blanks {
- // Do we need to fold line breaks?
- if len(leading_break) > 0 && leading_break[0] == '\n' {
- if len(trailing_breaks) == 0 {
- s = append(s, ' ')
- } else {
- s = append(s, trailing_breaks...)
- }
- } else {
- s = append(s, leading_break...)
- s = append(s, trailing_breaks...)
- }
- trailing_breaks = trailing_breaks[:0]
- leading_break = leading_break[:0]
- } else {
- s = append(s, whitespaces...)
- whitespaces = whitespaces[:0]
- }
- }
-
- // Eat the right quote.
- skip(parser)
- end_mark := parser.mark
-
- // Create a token.
- *token = yaml_token_t{
- typ: yaml_SCALAR_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- value: s,
- style: yaml_SINGLE_QUOTED_SCALAR_STYLE,
- }
- if !single {
- token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
- }
- return true
-}
-
-// Scan a plain scalar.
-func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool {
-
- var s, leading_break, trailing_breaks, whitespaces []byte
- var leading_blanks bool
- var indent = parser.indent + 1
-
- start_mark := parser.mark
- end_mark := parser.mark
-
- // Consume the content of the plain scalar.
- for {
- // Check for a document indicator.
- if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
- return false
- }
- if parser.mark.column == 0 &&
- ((parser.buffer[parser.buffer_pos+0] == '-' &&
- parser.buffer[parser.buffer_pos+1] == '-' &&
- parser.buffer[parser.buffer_pos+2] == '-') ||
- (parser.buffer[parser.buffer_pos+0] == '.' &&
- parser.buffer[parser.buffer_pos+1] == '.' &&
- parser.buffer[parser.buffer_pos+2] == '.')) &&
- is_blankz(parser.buffer, parser.buffer_pos+3) {
- break
- }
-
- // Check for a comment.
- if parser.buffer[parser.buffer_pos] == '#' {
- break
- }
-
- // Consume non-blank characters.
- for !is_blankz(parser.buffer, parser.buffer_pos) {
-
- // Check for indicators that may end a plain scalar.
- if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) ||
- (parser.flow_level > 0 &&
- (parser.buffer[parser.buffer_pos] == ',' ||
- parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' ||
- parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
- parser.buffer[parser.buffer_pos] == '}')) {
- break
- }
-
- // Check if we need to join whitespaces and breaks.
- if leading_blanks || len(whitespaces) > 0 {
- if leading_blanks {
- // Do we need to fold line breaks?
- if leading_break[0] == '\n' {
- if len(trailing_breaks) == 0 {
- s = append(s, ' ')
- } else {
- s = append(s, trailing_breaks...)
- }
- } else {
- s = append(s, leading_break...)
- s = append(s, trailing_breaks...)
- }
- trailing_breaks = trailing_breaks[:0]
- leading_break = leading_break[:0]
- leading_blanks = false
- } else {
- s = append(s, whitespaces...)
- whitespaces = whitespaces[:0]
- }
- }
-
- // Copy the character.
- s = read(parser, s)
-
- end_mark = parser.mark
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- }
-
- // Is it the end?
- if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) {
- break
- }
-
- // Consume blank characters.
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
-
- for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
- if is_blank(parser.buffer, parser.buffer_pos) {
-
- // Check for tab characters that abuse indentation.
- if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {
- yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
- start_mark, "found a tab character that violates indentation")
- return false
- }
-
- // Consume a space or a tab character.
- if !leading_blanks {
- whitespaces = read(parser, whitespaces)
- } else {
- skip(parser)
- }
- } else {
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
-
- // Check if it is a first line break.
- if !leading_blanks {
- whitespaces = whitespaces[:0]
- leading_break = read_line(parser, leading_break)
- leading_blanks = true
- } else {
- trailing_breaks = read_line(parser, trailing_breaks)
- }
- }
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- }
-
- // Check indentation level.
- if parser.flow_level == 0 && parser.mark.column < indent {
- break
- }
- }
-
- // Create a token.
- *token = yaml_token_t{
- typ: yaml_SCALAR_TOKEN,
- start_mark: start_mark,
- end_mark: end_mark,
- value: s,
- style: yaml_PLAIN_SCALAR_STYLE,
- }
-
- // Note that we change the 'simple_key_allowed' flag.
- if leading_blanks {
- parser.simple_key_allowed = true
- }
- return true
-}
-
-func yaml_parser_scan_line_comment(parser *yaml_parser_t, token_mark yaml_mark_t) bool {
- if parser.newlines > 0 {
- return true
- }
-
- var start_mark yaml_mark_t
- var text []byte
-
- for peek := 0; peek < 512; peek++ {
- if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
- break
- }
- if is_blank(parser.buffer, parser.buffer_pos+peek) {
- continue
- }
- if parser.buffer[parser.buffer_pos+peek] == '#' {
- seen := parser.mark.index+peek
- for {
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if is_breakz(parser.buffer, parser.buffer_pos) {
- if parser.mark.index >= seen {
- break
- }
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- skip_line(parser)
- } else if parser.mark.index >= seen {
- if len(text) == 0 {
- start_mark = parser.mark
- }
- text = read(parser, text)
- } else {
- skip(parser)
- }
- }
- }
- break
- }
- if len(text) > 0 {
- parser.comments = append(parser.comments, yaml_comment_t{
- token_mark: token_mark,
- start_mark: start_mark,
- line: text,
- })
- }
- return true
-}
-
-func yaml_parser_scan_comments(parser *yaml_parser_t, scan_mark yaml_mark_t) bool {
- token := parser.tokens[len(parser.tokens)-1]
-
- if token.typ == yaml_FLOW_ENTRY_TOKEN && len(parser.tokens) > 1 {
- token = parser.tokens[len(parser.tokens)-2]
- }
-
- var token_mark = token.start_mark
- var start_mark yaml_mark_t
- var next_indent = parser.indent
- if next_indent < 0 {
- next_indent = 0
- }
-
- var recent_empty = false
- var first_empty = parser.newlines <= 1
-
- var line = parser.mark.line
- var column = parser.mark.column
-
- var text []byte
-
- // The foot line is the place where a comment must start to
- // still be considered as a foot of the prior content.
- // If there's some content in the currently parsed line, then
- // the foot is the line below it.
- var foot_line = -1
- if scan_mark.line > 0 {
- foot_line = parser.mark.line-parser.newlines+1
- if parser.newlines == 0 && parser.mark.column > 1 {
- foot_line++
- }
- }
-
- var peek = 0
- for ; peek < 512; peek++ {
- if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
- break
- }
- column++
- if is_blank(parser.buffer, parser.buffer_pos+peek) {
- continue
- }
- c := parser.buffer[parser.buffer_pos+peek]
- var close_flow = parser.flow_level > 0 && (c == ']' || c == '}')
- if close_flow || is_breakz(parser.buffer, parser.buffer_pos+peek) {
- // Got line break or terminator.
- if close_flow || !recent_empty {
- if close_flow || first_empty && (start_mark.line == foot_line && token.typ != yaml_VALUE_TOKEN || start_mark.column-1 < next_indent) {
- // This is the first empty line and there were no empty lines before,
- // so this initial part of the comment is a foot of the prior token
- // instead of being a head for the following one. Split it up.
- // Alternatively, this might also be the last comment inside a flow
- // scope, so it must be a footer.
- if len(text) > 0 {
- if start_mark.column-1 < next_indent {
- // If dedented it's unrelated to the prior token.
- token_mark = start_mark
- }
- parser.comments = append(parser.comments, yaml_comment_t{
- scan_mark: scan_mark,
- token_mark: token_mark,
- start_mark: start_mark,
- end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
- foot: text,
- })
- scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
- token_mark = scan_mark
- text = nil
- }
- } else {
- if len(text) > 0 && parser.buffer[parser.buffer_pos+peek] != 0 {
- text = append(text, '\n')
- }
- }
- }
- if !is_break(parser.buffer, parser.buffer_pos+peek) {
- break
- }
- first_empty = false
- recent_empty = true
- column = 0
- line++
- continue
- }
-
- if len(text) > 0 && (close_flow || column-1 < next_indent && column != start_mark.column) {
- // The comment at the different indentation is a foot of the
- // preceding data rather than a head of the upcoming one.
- parser.comments = append(parser.comments, yaml_comment_t{
- scan_mark: scan_mark,
- token_mark: token_mark,
- start_mark: start_mark,
- end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
- foot: text,
- })
- scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
- token_mark = scan_mark
- text = nil
- }
-
- if parser.buffer[parser.buffer_pos+peek] != '#' {
- break
- }
-
- if len(text) == 0 {
- start_mark = yaml_mark_t{parser.mark.index + peek, line, column}
- } else {
- text = append(text, '\n')
- }
-
- recent_empty = false
-
- // Consume until after the consumed comment line.
- seen := parser.mark.index+peek
- for {
- if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
- return false
- }
- if is_breakz(parser.buffer, parser.buffer_pos) {
- if parser.mark.index >= seen {
- break
- }
- if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
- return false
- }
- skip_line(parser)
- } else if parser.mark.index >= seen {
- text = read(parser, text)
- } else {
- skip(parser)
- }
- }
-
- peek = 0
- column = 0
- line = parser.mark.line
- next_indent = parser.indent
- if next_indent < 0 {
- next_indent = 0
- }
- }
-
- if len(text) > 0 {
- parser.comments = append(parser.comments, yaml_comment_t{
- scan_mark: scan_mark,
- token_mark: start_mark,
- start_mark: start_mark,
- end_mark: yaml_mark_t{parser.mark.index + peek - 1, line, column},
- head: text,
- })
- }
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/sorter.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/sorter.go
deleted file mode 100644
index 9210ece7e97232891625ed08c549b92c0e9bb169..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/sorter.go
+++ /dev/null
@@ -1,134 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml
-
-import (
- "reflect"
- "unicode"
-)
-
-type keyList []reflect.Value
-
-func (l keyList) Len() int { return len(l) }
-func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
-func (l keyList) Less(i, j int) bool {
- a := l[i]
- b := l[j]
- ak := a.Kind()
- bk := b.Kind()
- for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
- a = a.Elem()
- ak = a.Kind()
- }
- for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
- b = b.Elem()
- bk = b.Kind()
- }
- af, aok := keyFloat(a)
- bf, bok := keyFloat(b)
- if aok && bok {
- if af != bf {
- return af < bf
- }
- if ak != bk {
- return ak < bk
- }
- return numLess(a, b)
- }
- if ak != reflect.String || bk != reflect.String {
- return ak < bk
- }
- ar, br := []rune(a.String()), []rune(b.String())
- digits := false
- for i := 0; i < len(ar) && i < len(br); i++ {
- if ar[i] == br[i] {
- digits = unicode.IsDigit(ar[i])
- continue
- }
- al := unicode.IsLetter(ar[i])
- bl := unicode.IsLetter(br[i])
- if al && bl {
- return ar[i] < br[i]
- }
- if al || bl {
- if digits {
- return al
- } else {
- return bl
- }
- }
- var ai, bi int
- var an, bn int64
- if ar[i] == '0' || br[i] == '0' {
- for j := i - 1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
- if ar[j] != '0' {
- an = 1
- bn = 1
- break
- }
- }
- }
- for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
- an = an*10 + int64(ar[ai]-'0')
- }
- for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
- bn = bn*10 + int64(br[bi]-'0')
- }
- if an != bn {
- return an < bn
- }
- if ai != bi {
- return ai < bi
- }
- return ar[i] < br[i]
- }
- return len(ar) < len(br)
-}
-
-// keyFloat returns a float value for v if it is a number/bool
-// and whether it is a number/bool or not.
-func keyFloat(v reflect.Value) (f float64, ok bool) {
- switch v.Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return float64(v.Int()), true
- case reflect.Float32, reflect.Float64:
- return v.Float(), true
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return float64(v.Uint()), true
- case reflect.Bool:
- if v.Bool() {
- return 1, true
- }
- return 0, true
- }
- return 0, false
-}
-
-// numLess returns whether a < b.
-// a and b must necessarily have the same kind.
-func numLess(a, b reflect.Value) bool {
- switch a.Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return a.Int() < b.Int()
- case reflect.Float32, reflect.Float64:
- return a.Float() < b.Float()
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return a.Uint() < b.Uint()
- case reflect.Bool:
- return !a.Bool() && b.Bool()
- }
- panic("not a number")
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/suite_test.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/suite_test.go
deleted file mode 100644
index 4630b5f23fdd39ea958cc44bc0a71275b6c32a7f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/suite_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package yaml_test
-
-import (
- . "gopkg.in/check.v1"
- "testing"
-)
-
-func Test(t *testing.T) { TestingT(t) }
-
-type S struct{}
-
-var _ = Suite(&S{})
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/writerc.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/writerc.go
deleted file mode 100644
index b8a116bf9a22b9911958f44904289a8c6b482bd2..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/writerc.go
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-// Set the writer error and return false.
-func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
- emitter.error = yaml_WRITER_ERROR
- emitter.problem = problem
- return false
-}
-
-// Flush the output buffer.
-func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
- if emitter.write_handler == nil {
- panic("write handler not set")
- }
-
- // Check if the buffer is empty.
- if emitter.buffer_pos == 0 {
- return true
- }
-
- if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
- return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
- }
- emitter.buffer_pos = 0
- return true
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yaml.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yaml.go
deleted file mode 100644
index 8cec6da48d3ec4d8858ca622383c75e359faee1f..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yaml.go
+++ /dev/null
@@ -1,698 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package yaml implements YAML support for the Go language.
-//
-// Source code and other details for the project are available at GitHub:
-//
-// https://github.com/go-yaml/yaml
-//
-package yaml
-
-import (
- "errors"
- "fmt"
- "io"
- "reflect"
- "strings"
- "sync"
- "unicode/utf8"
-)
-
-// The Unmarshaler interface may be implemented by types to customize their
-// behavior when being unmarshaled from a YAML document.
-type Unmarshaler interface {
- UnmarshalYAML(value *Node) error
-}
-
-type obsoleteUnmarshaler interface {
- UnmarshalYAML(unmarshal func(interface{}) error) error
-}
-
-// The Marshaler interface may be implemented by types to customize their
-// behavior when being marshaled into a YAML document. The returned value
-// is marshaled in place of the original value implementing Marshaler.
-//
-// If an error is returned by MarshalYAML, the marshaling procedure stops
-// and returns with the provided error.
-type Marshaler interface {
- MarshalYAML() (interface{}, error)
-}
-
-// Unmarshal decodes the first document found within the in byte slice
-// and assigns decoded values into the out value.
-//
-// Maps and pointers (to a struct, string, int, etc) are accepted as out
-// values. If an internal pointer within a struct is not initialized,
-// the yaml package will initialize it if necessary for unmarshalling
-// the provided data. The out parameter must not be nil.
-//
-// The type of the decoded values should be compatible with the respective
-// values in out. If one or more values cannot be decoded due to a type
-// mismatches, decoding continues partially until the end of the YAML
-// content, and a *yaml.TypeError is returned with details for all
-// missed values.
-//
-// Struct fields are only unmarshalled if they are exported (have an
-// upper case first letter), and are unmarshalled using the field name
-// lowercased as the default key. Custom keys may be defined via the
-// "yaml" name in the field tag: the content preceding the first comma
-// is used as the key, and the following comma-separated options are
-// used to tweak the marshalling process (see Marshal).
-// Conflicting names result in a runtime error.
-//
-// For example:
-//
-// type T struct {
-// F int `yaml:"a,omitempty"`
-// B int
-// }
-// var t T
-// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
-//
-// See the documentation of Marshal for the format of tags and a list of
-// supported tag options.
-//
-func Unmarshal(in []byte, out interface{}) (err error) {
- return unmarshal(in, out, false)
-}
-
-// A Decoder reads and decodes YAML values from an input stream.
-type Decoder struct {
- parser *parser
- knownFields bool
-}
-
-// NewDecoder returns a new decoder that reads from r.
-//
-// The decoder introduces its own buffering and may read
-// data from r beyond the YAML values requested.
-func NewDecoder(r io.Reader) *Decoder {
- return &Decoder{
- parser: newParserFromReader(r),
- }
-}
-
-// KnownFields ensures that the keys in decoded mappings to
-// exist as fields in the struct being decoded into.
-func (dec *Decoder) KnownFields(enable bool) {
- dec.knownFields = enable
-}
-
-// Decode reads the next YAML-encoded value from its input
-// and stores it in the value pointed to by v.
-//
-// See the documentation for Unmarshal for details about the
-// conversion of YAML into a Go value.
-func (dec *Decoder) Decode(v interface{}) (err error) {
- d := newDecoder()
- d.knownFields = dec.knownFields
- defer handleErr(&err)
- node := dec.parser.parse()
- if node == nil {
- return io.EOF
- }
- out := reflect.ValueOf(v)
- if out.Kind() == reflect.Ptr && !out.IsNil() {
- out = out.Elem()
- }
- d.unmarshal(node, out)
- if len(d.terrors) > 0 {
- return &TypeError{d.terrors}
- }
- return nil
-}
-
-// Decode decodes the node and stores its data into the value pointed to by v.
-//
-// See the documentation for Unmarshal for details about the
-// conversion of YAML into a Go value.
-func (n *Node) Decode(v interface{}) (err error) {
- d := newDecoder()
- defer handleErr(&err)
- out := reflect.ValueOf(v)
- if out.Kind() == reflect.Ptr && !out.IsNil() {
- out = out.Elem()
- }
- d.unmarshal(n, out)
- if len(d.terrors) > 0 {
- return &TypeError{d.terrors}
- }
- return nil
-}
-
-func unmarshal(in []byte, out interface{}, strict bool) (err error) {
- defer handleErr(&err)
- d := newDecoder()
- p := newParser(in)
- defer p.destroy()
- node := p.parse()
- if node != nil {
- v := reflect.ValueOf(out)
- if v.Kind() == reflect.Ptr && !v.IsNil() {
- v = v.Elem()
- }
- d.unmarshal(node, v)
- }
- if len(d.terrors) > 0 {
- return &TypeError{d.terrors}
- }
- return nil
-}
-
-// Marshal serializes the value provided into a YAML document. The structure
-// of the generated document will reflect the structure of the value itself.
-// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
-//
-// Struct fields are only marshalled if they are exported (have an upper case
-// first letter), and are marshalled using the field name lowercased as the
-// default key. Custom keys may be defined via the "yaml" name in the field
-// tag: the content preceding the first comma is used as the key, and the
-// following comma-separated options are used to tweak the marshalling process.
-// Conflicting names result in a runtime error.
-//
-// The field tag format accepted is:
-//
-// `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
-//
-// The following flags are currently supported:
-//
-// omitempty Only include the field if it's not set to the zero
-// value for the type or to empty slices or maps.
-// Zero valued structs will be omitted if all their public
-// fields are zero, unless they implement an IsZero
-// method (see the IsZeroer interface type), in which
-// case the field will be excluded if IsZero returns true.
-//
-// flow Marshal using a flow style (useful for structs,
-// sequences and maps).
-//
-// inline Inline the field, which must be a struct or a map,
-// causing all of its fields or keys to be processed as if
-// they were part of the outer struct. For maps, keys must
-// not conflict with the yaml keys of other struct fields.
-//
-// In addition, if the key is "-", the field is ignored.
-//
-// For example:
-//
-// type T struct {
-// F int `yaml:"a,omitempty"`
-// B int
-// }
-// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
-// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
-//
-func Marshal(in interface{}) (out []byte, err error) {
- defer handleErr(&err)
- e := newEncoder()
- defer e.destroy()
- e.marshalDoc("", reflect.ValueOf(in))
- e.finish()
- out = e.out
- return
-}
-
-// An Encoder writes YAML values to an output stream.
-type Encoder struct {
- encoder *encoder
-}
-
-// NewEncoder returns a new encoder that writes to w.
-// The Encoder should be closed after use to flush all data
-// to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{
- encoder: newEncoderWithWriter(w),
- }
-}
-
-// Encode writes the YAML encoding of v to the stream.
-// If multiple items are encoded to the stream, the
-// second and subsequent document will be preceded
-// with a "---" document separator, but the first will not.
-//
-// See the documentation for Marshal for details about the conversion of Go
-// values to YAML.
-func (e *Encoder) Encode(v interface{}) (err error) {
- defer handleErr(&err)
- e.encoder.marshalDoc("", reflect.ValueOf(v))
- return nil
-}
-
-// Encode encodes value v and stores its representation in n.
-//
-// See the documentation for Marshal for details about the
-// conversion of Go values into YAML.
-func (n *Node) Encode(v interface{}) (err error) {
- defer handleErr(&err)
- e := newEncoder()
- defer e.destroy()
- e.marshalDoc("", reflect.ValueOf(v))
- e.finish()
- p := newParser(e.out)
- p.textless = true
- defer p.destroy()
- doc := p.parse()
- *n = *doc.Content[0]
- return nil
-}
-
-// SetIndent changes the used indentation used when encoding.
-func (e *Encoder) SetIndent(spaces int) {
- if spaces < 0 {
- panic("yaml: cannot indent to a negative number of spaces")
- }
- e.encoder.indent = spaces
-}
-
-// Close closes the encoder by writing any remaining data.
-// It does not write a stream terminating string "...".
-func (e *Encoder) Close() (err error) {
- defer handleErr(&err)
- e.encoder.finish()
- return nil
-}
-
-func handleErr(err *error) {
- if v := recover(); v != nil {
- if e, ok := v.(yamlError); ok {
- *err = e.err
- } else {
- panic(v)
- }
- }
-}
-
-type yamlError struct {
- err error
-}
-
-func fail(err error) {
- panic(yamlError{err})
-}
-
-func failf(format string, args ...interface{}) {
- panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
-}
-
-// A TypeError is returned by Unmarshal when one or more fields in
-// the YAML document cannot be properly decoded into the requested
-// types. When this error is returned, the value is still
-// unmarshaled partially.
-type TypeError struct {
- Errors []string
-}
-
-func (e *TypeError) Error() string {
- return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
-}
-
-type Kind uint32
-
-const (
- DocumentNode Kind = 1 << iota
- SequenceNode
- MappingNode
- ScalarNode
- AliasNode
-)
-
-type Style uint32
-
-const (
- TaggedStyle Style = 1 << iota
- DoubleQuotedStyle
- SingleQuotedStyle
- LiteralStyle
- FoldedStyle
- FlowStyle
-)
-
-// Node represents an element in the YAML document hierarchy. While documents
-// are typically encoded and decoded into higher level types, such as structs
-// and maps, Node is an intermediate representation that allows detailed
-// control over the content being decoded or encoded.
-//
-// It's worth noting that although Node offers access into details such as
-// line numbers, colums, and comments, the content when re-encoded will not
-// have its original textual representation preserved. An effort is made to
-// render the data plesantly, and to preserve comments near the data they
-// describe, though.
-//
-// Values that make use of the Node type interact with the yaml package in the
-// same way any other type would do, by encoding and decoding yaml data
-// directly or indirectly into them.
-//
-// For example:
-//
-// var person struct {
-// Name string
-// Address yaml.Node
-// }
-// err := yaml.Unmarshal(data, &person)
-//
-// Or by itself:
-//
-// var person Node
-// err := yaml.Unmarshal(data, &person)
-//
-type Node struct {
- // Kind defines whether the node is a document, a mapping, a sequence,
- // a scalar value, or an alias to another node. The specific data type of
- // scalar nodes may be obtained via the ShortTag and LongTag methods.
- Kind Kind
-
- // Style allows customizing the apperance of the node in the tree.
- Style Style
-
- // Tag holds the YAML tag defining the data type for the value.
- // When decoding, this field will always be set to the resolved tag,
- // even when it wasn't explicitly provided in the YAML content.
- // When encoding, if this field is unset the value type will be
- // implied from the node properties, and if it is set, it will only
- // be serialized into the representation if TaggedStyle is used or
- // the implicit tag diverges from the provided one.
- Tag string
-
- // Value holds the unescaped and unquoted represenation of the value.
- Value string
-
- // Anchor holds the anchor name for this node, which allows aliases to point to it.
- Anchor string
-
- // Alias holds the node that this alias points to. Only valid when Kind is AliasNode.
- Alias *Node
-
- // Content holds contained nodes for documents, mappings, and sequences.
- Content []*Node
-
- // HeadComment holds any comments in the lines preceding the node and
- // not separated by an empty line.
- HeadComment string
-
- // LineComment holds any comments at the end of the line where the node is in.
- LineComment string
-
- // FootComment holds any comments following the node and before empty lines.
- FootComment string
-
- // Line and Column hold the node position in the decoded YAML text.
- // These fields are not respected when encoding the node.
- Line int
- Column int
-}
-
-// IsZero returns whether the node has all of its fields unset.
-func (n *Node) IsZero() bool {
- return n.Kind == 0 && n.Style == 0 && n.Tag == "" && n.Value == "" && n.Anchor == "" && n.Alias == nil && n.Content == nil &&
- n.HeadComment == "" && n.LineComment == "" && n.FootComment == "" && n.Line == 0 && n.Column == 0
-}
-
-
-// LongTag returns the long form of the tag that indicates the data type for
-// the node. If the Tag field isn't explicitly defined, one will be computed
-// based on the node properties.
-func (n *Node) LongTag() string {
- return longTag(n.ShortTag())
-}
-
-// ShortTag returns the short form of the YAML tag that indicates data type for
-// the node. If the Tag field isn't explicitly defined, one will be computed
-// based on the node properties.
-func (n *Node) ShortTag() string {
- if n.indicatedString() {
- return strTag
- }
- if n.Tag == "" || n.Tag == "!" {
- switch n.Kind {
- case MappingNode:
- return mapTag
- case SequenceNode:
- return seqTag
- case AliasNode:
- if n.Alias != nil {
- return n.Alias.ShortTag()
- }
- case ScalarNode:
- tag, _ := resolve("", n.Value)
- return tag
- case 0:
- // Special case to make the zero value convenient.
- if n.IsZero() {
- return nullTag
- }
- }
- return ""
- }
- return shortTag(n.Tag)
-}
-
-func (n *Node) indicatedString() bool {
- return n.Kind == ScalarNode &&
- (shortTag(n.Tag) == strTag ||
- (n.Tag == "" || n.Tag == "!") && n.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0)
-}
-
-// SetString is a convenience function that sets the node to a string value
-// and defines its style in a pleasant way depending on its content.
-func (n *Node) SetString(s string) {
- n.Kind = ScalarNode
- if utf8.ValidString(s) {
- n.Value = s
- n.Tag = strTag
- } else {
- n.Value = encodeBase64(s)
- n.Tag = binaryTag
- }
- if strings.Contains(n.Value, "\n") {
- n.Style = LiteralStyle
- }
-}
-
-// --------------------------------------------------------------------------
-// Maintain a mapping of keys to structure field indexes
-
-// The code in this section was copied from mgo/bson.
-
-// structInfo holds details for the serialization of fields of
-// a given struct.
-type structInfo struct {
- FieldsMap map[string]fieldInfo
- FieldsList []fieldInfo
-
- // InlineMap is the number of the field in the struct that
- // contains an ,inline map, or -1 if there's none.
- InlineMap int
-
- // InlineUnmarshalers holds indexes to inlined fields that
- // contain unmarshaler values.
- InlineUnmarshalers [][]int
-}
-
-type fieldInfo struct {
- Key string
- Num int
- OmitEmpty bool
- Flow bool
- // Id holds the unique field identifier, so we can cheaply
- // check for field duplicates without maintaining an extra map.
- Id int
-
- // Inline holds the field index if the field is part of an inlined struct.
- Inline []int
-}
-
-var structMap = make(map[reflect.Type]*structInfo)
-var fieldMapMutex sync.RWMutex
-var unmarshalerType reflect.Type
-
-func init() {
- var v Unmarshaler
- unmarshalerType = reflect.ValueOf(&v).Elem().Type()
-}
-
-func getStructInfo(st reflect.Type) (*structInfo, error) {
- fieldMapMutex.RLock()
- sinfo, found := structMap[st]
- fieldMapMutex.RUnlock()
- if found {
- return sinfo, nil
- }
-
- n := st.NumField()
- fieldsMap := make(map[string]fieldInfo)
- fieldsList := make([]fieldInfo, 0, n)
- inlineMap := -1
- inlineUnmarshalers := [][]int(nil)
- for i := 0; i != n; i++ {
- field := st.Field(i)
- if field.PkgPath != "" && !field.Anonymous {
- continue // Private field
- }
-
- info := fieldInfo{Num: i}
-
- tag := field.Tag.Get("yaml")
- if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
- tag = string(field.Tag)
- }
- if tag == "-" {
- continue
- }
-
- inline := false
- fields := strings.Split(tag, ",")
- if len(fields) > 1 {
- for _, flag := range fields[1:] {
- switch flag {
- case "omitempty":
- info.OmitEmpty = true
- case "flow":
- info.Flow = true
- case "inline":
- inline = true
- default:
- return nil, errors.New(fmt.Sprintf("unsupported flag %q in tag %q of type %s", flag, tag, st))
- }
- }
- tag = fields[0]
- }
-
- if inline {
- switch field.Type.Kind() {
- case reflect.Map:
- if inlineMap >= 0 {
- return nil, errors.New("multiple ,inline maps in struct " + st.String())
- }
- if field.Type.Key() != reflect.TypeOf("") {
- return nil, errors.New("option ,inline needs a map with string keys in struct " + st.String())
- }
- inlineMap = info.Num
- case reflect.Struct, reflect.Ptr:
- ftype := field.Type
- for ftype.Kind() == reflect.Ptr {
- ftype = ftype.Elem()
- }
- if ftype.Kind() != reflect.Struct {
- return nil, errors.New("option ,inline may only be used on a struct or map field")
- }
- if reflect.PtrTo(ftype).Implements(unmarshalerType) {
- inlineUnmarshalers = append(inlineUnmarshalers, []int{i})
- } else {
- sinfo, err := getStructInfo(ftype)
- if err != nil {
- return nil, err
- }
- for _, index := range sinfo.InlineUnmarshalers {
- inlineUnmarshalers = append(inlineUnmarshalers, append([]int{i}, index...))
- }
- for _, finfo := range sinfo.FieldsList {
- if _, found := fieldsMap[finfo.Key]; found {
- msg := "duplicated key '" + finfo.Key + "' in struct " + st.String()
- return nil, errors.New(msg)
- }
- if finfo.Inline == nil {
- finfo.Inline = []int{i, finfo.Num}
- } else {
- finfo.Inline = append([]int{i}, finfo.Inline...)
- }
- finfo.Id = len(fieldsList)
- fieldsMap[finfo.Key] = finfo
- fieldsList = append(fieldsList, finfo)
- }
- }
- default:
- return nil, errors.New("option ,inline may only be used on a struct or map field")
- }
- continue
- }
-
- if tag != "" {
- info.Key = tag
- } else {
- info.Key = strings.ToLower(field.Name)
- }
-
- if _, found = fieldsMap[info.Key]; found {
- msg := "duplicated key '" + info.Key + "' in struct " + st.String()
- return nil, errors.New(msg)
- }
-
- info.Id = len(fieldsList)
- fieldsList = append(fieldsList, info)
- fieldsMap[info.Key] = info
- }
-
- sinfo = &structInfo{
- FieldsMap: fieldsMap,
- FieldsList: fieldsList,
- InlineMap: inlineMap,
- InlineUnmarshalers: inlineUnmarshalers,
- }
-
- fieldMapMutex.Lock()
- structMap[st] = sinfo
- fieldMapMutex.Unlock()
- return sinfo, nil
-}
-
-// IsZeroer is used to check whether an object is zero to
-// determine whether it should be omitted when marshaling
-// with the omitempty flag. One notable implementation
-// is time.Time.
-type IsZeroer interface {
- IsZero() bool
-}
-
-func isZero(v reflect.Value) bool {
- kind := v.Kind()
- if z, ok := v.Interface().(IsZeroer); ok {
- if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
- return true
- }
- return z.IsZero()
- }
- switch kind {
- case reflect.String:
- return len(v.String()) == 0
- case reflect.Interface, reflect.Ptr:
- return v.IsNil()
- case reflect.Slice:
- return v.Len() == 0
- case reflect.Map:
- return v.Len() == 0
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v.Int() == 0
- case reflect.Float32, reflect.Float64:
- return v.Float() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v.Uint() == 0
- case reflect.Bool:
- return !v.Bool()
- case reflect.Struct:
- vt := v.Type()
- for i := v.NumField() - 1; i >= 0; i-- {
- if vt.Field(i).PkgPath != "" {
- continue // Private field
- }
- if !isZero(v.Field(i)) {
- return false
- }
- }
- return true
- }
- return false
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlh.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlh.go
deleted file mode 100644
index 7c6d0077061933c97979f6c84cb659b17391e1a3..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlh.go
+++ /dev/null
@@ -1,807 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-import (
- "fmt"
- "io"
-)
-
-// The version directive data.
-type yaml_version_directive_t struct {
- major int8 // The major version number.
- minor int8 // The minor version number.
-}
-
-// The tag directive data.
-type yaml_tag_directive_t struct {
- handle []byte // The tag handle.
- prefix []byte // The tag prefix.
-}
-
-type yaml_encoding_t int
-
-// The stream encoding.
-const (
- // Let the parser choose the encoding.
- yaml_ANY_ENCODING yaml_encoding_t = iota
-
- yaml_UTF8_ENCODING // The default UTF-8 encoding.
- yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM.
- yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM.
-)
-
-type yaml_break_t int
-
-// Line break types.
-const (
- // Let the parser choose the break type.
- yaml_ANY_BREAK yaml_break_t = iota
-
- yaml_CR_BREAK // Use CR for line breaks (Mac style).
- yaml_LN_BREAK // Use LN for line breaks (Unix style).
- yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style).
-)
-
-type yaml_error_type_t int
-
-// Many bad things could happen with the parser and emitter.
-const (
- // No error is produced.
- yaml_NO_ERROR yaml_error_type_t = iota
-
- yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory.
- yaml_READER_ERROR // Cannot read or decode the input stream.
- yaml_SCANNER_ERROR // Cannot scan the input stream.
- yaml_PARSER_ERROR // Cannot parse the input stream.
- yaml_COMPOSER_ERROR // Cannot compose a YAML document.
- yaml_WRITER_ERROR // Cannot write to the output stream.
- yaml_EMITTER_ERROR // Cannot emit a YAML stream.
-)
-
-// The pointer position.
-type yaml_mark_t struct {
- index int // The position index.
- line int // The position line.
- column int // The position column.
-}
-
-// Node Styles
-
-type yaml_style_t int8
-
-type yaml_scalar_style_t yaml_style_t
-
-// Scalar styles.
-const (
- // Let the emitter choose the style.
- yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = 0
-
- yaml_PLAIN_SCALAR_STYLE yaml_scalar_style_t = 1 << iota // The plain scalar style.
- yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
- yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
- yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
- yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
-)
-
-type yaml_sequence_style_t yaml_style_t
-
-// Sequence styles.
-const (
- // Let the emitter choose the style.
- yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota
-
- yaml_BLOCK_SEQUENCE_STYLE // The block sequence style.
- yaml_FLOW_SEQUENCE_STYLE // The flow sequence style.
-)
-
-type yaml_mapping_style_t yaml_style_t
-
-// Mapping styles.
-const (
- // Let the emitter choose the style.
- yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota
-
- yaml_BLOCK_MAPPING_STYLE // The block mapping style.
- yaml_FLOW_MAPPING_STYLE // The flow mapping style.
-)
-
-// Tokens
-
-type yaml_token_type_t int
-
-// Token types.
-const (
- // An empty token.
- yaml_NO_TOKEN yaml_token_type_t = iota
-
- yaml_STREAM_START_TOKEN // A STREAM-START token.
- yaml_STREAM_END_TOKEN // A STREAM-END token.
-
- yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token.
- yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token.
- yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token.
- yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token.
-
- yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token.
- yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token.
- yaml_BLOCK_END_TOKEN // A BLOCK-END token.
-
- yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token.
- yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token.
- yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token.
- yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token.
-
- yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token.
- yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token.
- yaml_KEY_TOKEN // A KEY token.
- yaml_VALUE_TOKEN // A VALUE token.
-
- yaml_ALIAS_TOKEN // An ALIAS token.
- yaml_ANCHOR_TOKEN // An ANCHOR token.
- yaml_TAG_TOKEN // A TAG token.
- yaml_SCALAR_TOKEN // A SCALAR token.
-)
-
-func (tt yaml_token_type_t) String() string {
- switch tt {
- case yaml_NO_TOKEN:
- return "yaml_NO_TOKEN"
- case yaml_STREAM_START_TOKEN:
- return "yaml_STREAM_START_TOKEN"
- case yaml_STREAM_END_TOKEN:
- return "yaml_STREAM_END_TOKEN"
- case yaml_VERSION_DIRECTIVE_TOKEN:
- return "yaml_VERSION_DIRECTIVE_TOKEN"
- case yaml_TAG_DIRECTIVE_TOKEN:
- return "yaml_TAG_DIRECTIVE_TOKEN"
- case yaml_DOCUMENT_START_TOKEN:
- return "yaml_DOCUMENT_START_TOKEN"
- case yaml_DOCUMENT_END_TOKEN:
- return "yaml_DOCUMENT_END_TOKEN"
- case yaml_BLOCK_SEQUENCE_START_TOKEN:
- return "yaml_BLOCK_SEQUENCE_START_TOKEN"
- case yaml_BLOCK_MAPPING_START_TOKEN:
- return "yaml_BLOCK_MAPPING_START_TOKEN"
- case yaml_BLOCK_END_TOKEN:
- return "yaml_BLOCK_END_TOKEN"
- case yaml_FLOW_SEQUENCE_START_TOKEN:
- return "yaml_FLOW_SEQUENCE_START_TOKEN"
- case yaml_FLOW_SEQUENCE_END_TOKEN:
- return "yaml_FLOW_SEQUENCE_END_TOKEN"
- case yaml_FLOW_MAPPING_START_TOKEN:
- return "yaml_FLOW_MAPPING_START_TOKEN"
- case yaml_FLOW_MAPPING_END_TOKEN:
- return "yaml_FLOW_MAPPING_END_TOKEN"
- case yaml_BLOCK_ENTRY_TOKEN:
- return "yaml_BLOCK_ENTRY_TOKEN"
- case yaml_FLOW_ENTRY_TOKEN:
- return "yaml_FLOW_ENTRY_TOKEN"
- case yaml_KEY_TOKEN:
- return "yaml_KEY_TOKEN"
- case yaml_VALUE_TOKEN:
- return "yaml_VALUE_TOKEN"
- case yaml_ALIAS_TOKEN:
- return "yaml_ALIAS_TOKEN"
- case yaml_ANCHOR_TOKEN:
- return "yaml_ANCHOR_TOKEN"
- case yaml_TAG_TOKEN:
- return "yaml_TAG_TOKEN"
- case yaml_SCALAR_TOKEN:
- return "yaml_SCALAR_TOKEN"
- }
- return "<unknown token>"
-}
-
-// The token structure.
-type yaml_token_t struct {
- // The token type.
- typ yaml_token_type_t
-
- // The start/end of the token.
- start_mark, end_mark yaml_mark_t
-
- // The stream encoding (for yaml_STREAM_START_TOKEN).
- encoding yaml_encoding_t
-
- // The alias/anchor/scalar value or tag/tag directive handle
- // (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN).
- value []byte
-
- // The tag suffix (for yaml_TAG_TOKEN).
- suffix []byte
-
- // The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN).
- prefix []byte
-
- // The scalar style (for yaml_SCALAR_TOKEN).
- style yaml_scalar_style_t
-
- // The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN).
- major, minor int8
-}
-
-// Events
-
-type yaml_event_type_t int8
-
-// Event types.
-const (
- // An empty event.
- yaml_NO_EVENT yaml_event_type_t = iota
-
- yaml_STREAM_START_EVENT // A STREAM-START event.
- yaml_STREAM_END_EVENT // A STREAM-END event.
- yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event.
- yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event.
- yaml_ALIAS_EVENT // An ALIAS event.
- yaml_SCALAR_EVENT // A SCALAR event.
- yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event.
- yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
- yaml_MAPPING_START_EVENT // A MAPPING-START event.
- yaml_MAPPING_END_EVENT // A MAPPING-END event.
- yaml_TAIL_COMMENT_EVENT
-)
-
-var eventStrings = []string{
- yaml_NO_EVENT: "none",
- yaml_STREAM_START_EVENT: "stream start",
- yaml_STREAM_END_EVENT: "stream end",
- yaml_DOCUMENT_START_EVENT: "document start",
- yaml_DOCUMENT_END_EVENT: "document end",
- yaml_ALIAS_EVENT: "alias",
- yaml_SCALAR_EVENT: "scalar",
- yaml_SEQUENCE_START_EVENT: "sequence start",
- yaml_SEQUENCE_END_EVENT: "sequence end",
- yaml_MAPPING_START_EVENT: "mapping start",
- yaml_MAPPING_END_EVENT: "mapping end",
- yaml_TAIL_COMMENT_EVENT: "tail comment",
-}
-
-func (e yaml_event_type_t) String() string {
- if e < 0 || int(e) >= len(eventStrings) {
- return fmt.Sprintf("unknown event %d", e)
- }
- return eventStrings[e]
-}
-
-// The event structure.
-type yaml_event_t struct {
-
- // The event type.
- typ yaml_event_type_t
-
- // The start and end of the event.
- start_mark, end_mark yaml_mark_t
-
- // The document encoding (for yaml_STREAM_START_EVENT).
- encoding yaml_encoding_t
-
- // The version directive (for yaml_DOCUMENT_START_EVENT).
- version_directive *yaml_version_directive_t
-
- // The list of tag directives (for yaml_DOCUMENT_START_EVENT).
- tag_directives []yaml_tag_directive_t
-
- // The comments
- head_comment []byte
- line_comment []byte
- foot_comment []byte
- tail_comment []byte
-
- // The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
- anchor []byte
-
- // The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
- tag []byte
-
- // The scalar value (for yaml_SCALAR_EVENT).
- value []byte
-
- // Is the document start/end indicator implicit, or the tag optional?
- // (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT).
- implicit bool
-
- // Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT).
- quoted_implicit bool
-
- // The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
- style yaml_style_t
-}
-
-func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) }
-func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) }
-func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) }
-
-// Nodes
-
-const (
- yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null.
- yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false.
- yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values.
- yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values.
- yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values.
- yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values.
-
- yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
- yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
-
- // Not in original libyaml.
- yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
- yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
-
- yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
- yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
- yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map.
-)
-
-type yaml_node_type_t int
-
-// Node types.
-const (
- // An empty node.
- yaml_NO_NODE yaml_node_type_t = iota
-
- yaml_SCALAR_NODE // A scalar node.
- yaml_SEQUENCE_NODE // A sequence node.
- yaml_MAPPING_NODE // A mapping node.
-)
-
-// An element of a sequence node.
-type yaml_node_item_t int
-
-// An element of a mapping node.
-type yaml_node_pair_t struct {
- key int // The key of the element.
- value int // The value of the element.
-}
-
-// The node structure.
-type yaml_node_t struct {
- typ yaml_node_type_t // The node type.
- tag []byte // The node tag.
-
- // The node data.
-
- // The scalar parameters (for yaml_SCALAR_NODE).
- scalar struct {
- value []byte // The scalar value.
- length int // The length of the scalar value.
- style yaml_scalar_style_t // The scalar style.
- }
-
- // The sequence parameters (for YAML_SEQUENCE_NODE).
- sequence struct {
- items_data []yaml_node_item_t // The stack of sequence items.
- style yaml_sequence_style_t // The sequence style.
- }
-
- // The mapping parameters (for yaml_MAPPING_NODE).
- mapping struct {
- pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value).
- pairs_start *yaml_node_pair_t // The beginning of the stack.
- pairs_end *yaml_node_pair_t // The end of the stack.
- pairs_top *yaml_node_pair_t // The top of the stack.
- style yaml_mapping_style_t // The mapping style.
- }
-
- start_mark yaml_mark_t // The beginning of the node.
- end_mark yaml_mark_t // The end of the node.
-
-}
-
-// The document structure.
-type yaml_document_t struct {
-
- // The document nodes.
- nodes []yaml_node_t
-
- // The version directive.
- version_directive *yaml_version_directive_t
-
- // The list of tag directives.
- tag_directives_data []yaml_tag_directive_t
- tag_directives_start int // The beginning of the tag directives list.
- tag_directives_end int // The end of the tag directives list.
-
- start_implicit int // Is the document start indicator implicit?
- end_implicit int // Is the document end indicator implicit?
-
- // The start/end of the document.
- start_mark, end_mark yaml_mark_t
-}
-
-// The prototype of a read handler.
-//
-// The read handler is called when the parser needs to read more bytes from the
-// source. The handler should write not more than size bytes to the buffer.
-// The number of written bytes should be set to the size_read variable.
-//
-// [in,out] data A pointer to an application data specified by
-// yaml_parser_set_input().
-// [out] buffer The buffer to write the data from the source.
-// [in] size The size of the buffer.
-// [out] size_read The actual number of bytes read from the source.
-//
-// On success, the handler should return 1. If the handler failed,
-// the returned value should be 0. On EOF, the handler should set the
-// size_read to 0 and return 1.
-type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
-
-// This structure holds information about a potential simple key.
-type yaml_simple_key_t struct {
- possible bool // Is a simple key possible?
- required bool // Is a simple key required?
- token_number int // The number of the token.
- mark yaml_mark_t // The position mark.
-}
-
-// The states of the parser.
-type yaml_parser_state_t int
-
-const (
- yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota
-
- yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document.
- yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START.
- yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document.
- yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END.
- yaml_PARSE_BLOCK_NODE_STATE // Expect a block node.
- yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence.
- yaml_PARSE_FLOW_NODE_STATE // Expect a flow node.
- yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence.
- yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence.
- yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence.
- yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
- yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key.
- yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value.
- yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence.
- yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence.
- yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping.
- yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping.
- yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry.
- yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
- yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
- yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
- yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping.
- yaml_PARSE_END_STATE // Expect nothing.
-)
-
-func (ps yaml_parser_state_t) String() string {
- switch ps {
- case yaml_PARSE_STREAM_START_STATE:
- return "yaml_PARSE_STREAM_START_STATE"
- case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
- return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE"
- case yaml_PARSE_DOCUMENT_START_STATE:
- return "yaml_PARSE_DOCUMENT_START_STATE"
- case yaml_PARSE_DOCUMENT_CONTENT_STATE:
- return "yaml_PARSE_DOCUMENT_CONTENT_STATE"
- case yaml_PARSE_DOCUMENT_END_STATE:
- return "yaml_PARSE_DOCUMENT_END_STATE"
- case yaml_PARSE_BLOCK_NODE_STATE:
- return "yaml_PARSE_BLOCK_NODE_STATE"
- case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
- return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE"
- case yaml_PARSE_FLOW_NODE_STATE:
- return "yaml_PARSE_FLOW_NODE_STATE"
- case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
- return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE"
- case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
- return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE"
- case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
- return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE"
- case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
- return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE"
- case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
- return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE"
- case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
- return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE"
- case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
- return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE"
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
- return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE"
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
- return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE"
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
- return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE"
- case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
- return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE"
- case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
- return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE"
- case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
- return "yaml_PARSE_FLOW_MAPPING_KEY_STATE"
- case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
- return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE"
- case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
- return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE"
- case yaml_PARSE_END_STATE:
- return "yaml_PARSE_END_STATE"
- }
- return "<unknown parser state>"
-}
-
-// This structure holds aliases data.
-type yaml_alias_data_t struct {
- anchor []byte // The anchor.
- index int // The node id.
- mark yaml_mark_t // The anchor mark.
-}
-
-// The parser structure.
-//
-// All members are internal. Manage the structure using the
-// yaml_parser_ family of functions.
-type yaml_parser_t struct {
-
- // Error handling
-
- error yaml_error_type_t // Error type.
-
- problem string // Error description.
-
- // The byte about which the problem occurred.
- problem_offset int
- problem_value int
- problem_mark yaml_mark_t
-
- // The error context.
- context string
- context_mark yaml_mark_t
-
- // Reader stuff
-
- read_handler yaml_read_handler_t // Read handler.
-
- input_reader io.Reader // File input data.
- input []byte // String input data.
- input_pos int
-
- eof bool // EOF flag
-
- buffer []byte // The working buffer.
- buffer_pos int // The current position of the buffer.
-
- unread int // The number of unread characters in the buffer.
-
- newlines int // The number of line breaks since last non-break/non-blank character
-
- raw_buffer []byte // The raw buffer.
- raw_buffer_pos int // The current position of the buffer.
-
- encoding yaml_encoding_t // The input encoding.
-
- offset int // The offset of the current position (in bytes).
- mark yaml_mark_t // The mark of the current position.
-
- // Comments
-
- head_comment []byte // The current head comments
- line_comment []byte // The current line comments
- foot_comment []byte // The current foot comments
- tail_comment []byte // Foot comment that happens at the end of a block.
- stem_comment []byte // Comment in item preceding a nested structure (list inside list item, etc)
-
- comments []yaml_comment_t // The folded comments for all parsed tokens
- comments_head int
-
- // Scanner stuff
-
- stream_start_produced bool // Have we started to scan the input stream?
- stream_end_produced bool // Have we reached the end of the input stream?
-
- flow_level int // The number of unclosed '[' and '{' indicators.
-
- tokens []yaml_token_t // The tokens queue.
- tokens_head int // The head of the tokens queue.
- tokens_parsed int // The number of tokens fetched from the queue.
- token_available bool // Does the tokens queue contain a token ready for dequeueing.
-
- indent int // The current indentation level.
- indents []int // The indentation levels stack.
-
- simple_key_allowed bool // May a simple key occur at the current position?
- simple_keys []yaml_simple_key_t // The stack of simple keys.
- simple_keys_by_tok map[int]int // possible simple_key indexes indexed by token_number
-
- // Parser stuff
-
- state yaml_parser_state_t // The current parser state.
- states []yaml_parser_state_t // The parser states stack.
- marks []yaml_mark_t // The stack of marks.
- tag_directives []yaml_tag_directive_t // The list of TAG directives.
-
- // Dumper stuff
-
- aliases []yaml_alias_data_t // The alias data.
-
- document *yaml_document_t // The currently parsed document.
-}
-
-type yaml_comment_t struct {
-
- scan_mark yaml_mark_t // Position where scanning for comments started
- token_mark yaml_mark_t // Position after which tokens will be associated with this comment
- start_mark yaml_mark_t // Position of '#' comment mark
- end_mark yaml_mark_t // Position where comment terminated
-
- head []byte
- line []byte
- foot []byte
-}
-
-// Emitter Definitions
-
-// The prototype of a write handler.
-//
-// The write handler is called when the emitter needs to flush the accumulated
-// characters to the output. The handler should write @a size bytes of the
-// @a buffer to the output.
-//
-// @param[in,out] data A pointer to an application data specified by
-// yaml_emitter_set_output().
-// @param[in] buffer The buffer with bytes to be written.
-// @param[in] size The size of the buffer.
-//
-// @returns On success, the handler should return @c 1. If the handler failed,
-// the returned value should be @c 0.
-//
-type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
-
-type yaml_emitter_state_t int
-
-// The emitter states.
-const (
- // Expect STREAM-START.
- yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota
-
- yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END.
- yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END.
- yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
- yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
- yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
- yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE // Expect the next item of a flow sequence, with the comma already written out
- yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
- yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
- yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE // Expect the next key of a flow mapping, with the comma already written out
- yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
- yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
- yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
- yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence.
- yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence.
- yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
- yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping.
- yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping.
- yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping.
- yaml_EMIT_END_STATE // Expect nothing.
-)
-
-// The emitter structure.
-//
-// All members are internal. Manage the structure using the @c yaml_emitter_
-// family of functions.
-type yaml_emitter_t struct {
-
- // Error handling
-
- error yaml_error_type_t // Error type.
- problem string // Error description.
-
- // Writer stuff
-
- write_handler yaml_write_handler_t // Write handler.
-
- output_buffer *[]byte // String output data.
- output_writer io.Writer // File output data.
-
- buffer []byte // The working buffer.
- buffer_pos int // The current position of the buffer.
-
- raw_buffer []byte // The raw buffer.
- raw_buffer_pos int // The current position of the buffer.
-
- encoding yaml_encoding_t // The stream encoding.
-
- // Emitter stuff
-
- canonical bool // If the output is in the canonical style?
- best_indent int // The number of indentation spaces.
- best_width int // The preferred width of the output lines.
- unicode bool // Allow unescaped non-ASCII characters?
- line_break yaml_break_t // The preferred line break.
-
- state yaml_emitter_state_t // The current emitter state.
- states []yaml_emitter_state_t // The stack of states.
-
- events []yaml_event_t // The event queue.
- events_head int // The head of the event queue.
-
- indents []int // The stack of indentation levels.
-
- tag_directives []yaml_tag_directive_t // The list of tag directives.
-
- indent int // The current indentation level.
-
- flow_level int // The current flow level.
-
- root_context bool // Is it the document root context?
- sequence_context bool // Is it a sequence context?
- mapping_context bool // Is it a mapping context?
- simple_key_context bool // Is it a simple mapping key context?
-
- line int // The current line.
- column int // The current column.
- whitespace bool // If the last character was a whitespace?
- indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
- open_ended bool // If an explicit document end is required?
-
- space_above bool // Is there's an empty line above?
- foot_indent int // The indent used to write the foot comment above, or -1 if none.
-
- // Anchor analysis.
- anchor_data struct {
- anchor []byte // The anchor value.
- alias bool // Is it an alias?
- }
-
- // Tag analysis.
- tag_data struct {
- handle []byte // The tag handle.
- suffix []byte // The tag suffix.
- }
-
- // Scalar analysis.
- scalar_data struct {
- value []byte // The scalar value.
- multiline bool // Does the scalar contain line breaks?
- flow_plain_allowed bool // Can the scalar be expessed in the flow plain style?
- block_plain_allowed bool // Can the scalar be expressed in the block plain style?
- single_quoted_allowed bool // Can the scalar be expressed in the single quoted style?
- block_allowed bool // Can the scalar be expressed in the literal or folded styles?
- style yaml_scalar_style_t // The output style.
- }
-
- // Comments
- head_comment []byte
- line_comment []byte
- foot_comment []byte
- tail_comment []byte
-
- key_line_comment []byte
-
- // Dumper stuff
-
- opened bool // If the stream was already opened?
- closed bool // If the stream was already closed?
-
- // The information associated with the document nodes.
- anchors *struct {
- references int // The number of references.
- anchor int // The anchor id.
- serialized bool // If the node has been emitted?
- }
-
- last_anchor_id int // The last assigned anchor id.
-
- document *yaml_document_t // The currently emitted document.
-}
diff --git a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlprivateh.go b/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlprivateh.go
deleted file mode 100644
index e88f9c54aecb54ed42665b2a08b66a4f03d999bc..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/mod/gopkg.in/yaml.v3@v3.0.1/yamlprivateh.go
+++ /dev/null
@@ -1,198 +0,0 @@
-//
-// Copyright (c) 2011-2019 Canonical Ltd
-// Copyright (c) 2006-2010 Kirill Simonov
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
-// so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-package yaml
-
-const (
- // The size of the input raw buffer.
- input_raw_buffer_size = 512
-
- // The size of the input buffer.
- // It should be possible to decode the whole raw buffer.
- input_buffer_size = input_raw_buffer_size * 3
-
- // The size of the output buffer.
- output_buffer_size = 128
-
- // The size of the output raw buffer.
- // It should be possible to encode the whole output buffer.
- output_raw_buffer_size = (output_buffer_size*2 + 2)
-
- // The size of other stacks and queues.
- initial_stack_size = 16
- initial_queue_size = 16
- initial_string_size = 16
-)
-
-// Check if the character at the specified position is an alphabetical
-// character, a digit, '_', or '-'.
-func is_alpha(b []byte, i int) bool {
- return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
-}
-
-// Check if the character at the specified position is a digit.
-func is_digit(b []byte, i int) bool {
- return b[i] >= '0' && b[i] <= '9'
-}
-
-// Get the value of a digit.
-func as_digit(b []byte, i int) int {
- return int(b[i]) - '0'
-}
-
-// Check if the character at the specified position is a hex-digit.
-func is_hex(b []byte, i int) bool {
- return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
-}
-
-// Get the value of a hex-digit.
-func as_hex(b []byte, i int) int {
- bi := b[i]
- if bi >= 'A' && bi <= 'F' {
- return int(bi) - 'A' + 10
- }
- if bi >= 'a' && bi <= 'f' {
- return int(bi) - 'a' + 10
- }
- return int(bi) - '0'
-}
-
-// Check if the character is ASCII.
-func is_ascii(b []byte, i int) bool {
- return b[i] <= 0x7F
-}
-
-// Check if the character at the start of the buffer can be printed unescaped.
-func is_printable(b []byte, i int) bool {
- return ((b[i] == 0x0A) || // . == #x0A
- (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
- (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
- (b[i] > 0xC2 && b[i] < 0xED) ||
- (b[i] == 0xED && b[i+1] < 0xA0) ||
- (b[i] == 0xEE) ||
- (b[i] == 0xEF && // #xE000 <= . <= #xFFFD
- !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
- !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
-}
-
-// Check if the character at the specified position is NUL.
-func is_z(b []byte, i int) bool {
- return b[i] == 0x00
-}
-
-// Check if the beginning of the buffer is a BOM.
-func is_bom(b []byte, i int) bool {
- return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
-}
-
-// Check if the character at the specified position is space.
-func is_space(b []byte, i int) bool {
- return b[i] == ' '
-}
-
-// Check if the character at the specified position is tab.
-func is_tab(b []byte, i int) bool {
- return b[i] == '\t'
-}
-
-// Check if the character at the specified position is blank (space or tab).
-func is_blank(b []byte, i int) bool {
- //return is_space(b, i) || is_tab(b, i)
- return b[i] == ' ' || b[i] == '\t'
-}
-
-// Check if the character at the specified position is a line break.
-func is_break(b []byte, i int) bool {
- return (b[i] == '\r' || // CR (#xD)
- b[i] == '\n' || // LF (#xA)
- b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
-}
-
-func is_crlf(b []byte, i int) bool {
- return b[i] == '\r' && b[i+1] == '\n'
-}
-
-// Check if the character is a line break or NUL.
-func is_breakz(b []byte, i int) bool {
- //return is_break(b, i) || is_z(b, i)
- return (
- // is_break:
- b[i] == '\r' || // CR (#xD)
- b[i] == '\n' || // LF (#xA)
- b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
- // is_z:
- b[i] == 0)
-}
-
-// Check if the character is a line break, space, or NUL.
-func is_spacez(b []byte, i int) bool {
- //return is_space(b, i) || is_breakz(b, i)
- return (
- // is_space:
- b[i] == ' ' ||
- // is_breakz:
- b[i] == '\r' || // CR (#xD)
- b[i] == '\n' || // LF (#xA)
- b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
- b[i] == 0)
-}
-
-// Check if the character is a line break, space, tab, or NUL.
-func is_blankz(b []byte, i int) bool {
- //return is_blank(b, i) || is_breakz(b, i)
- return (
- // is_blank:
- b[i] == ' ' || b[i] == '\t' ||
- // is_breakz:
- b[i] == '\r' || // CR (#xD)
- b[i] == '\n' || // LF (#xA)
- b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
- b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
- b[i] == 0)
-}
-
-// Determine the width of the character.
-func width(b byte) int {
- // Don't replace these by a switch without first
- // confirming that it is being inlined.
- if b&0x80 == 0x00 {
- return 1
- }
- if b&0xE0 == 0xC0 {
- return 2
- }
- if b&0xF0 == 0xE0 {
- return 3
- }
- if b&0xF8 == 0xF0 {
- return 4
- }
- return 0
-
-}
diff --git a/.devenv/state/go/pkg/sumdb/sum.golang.org/latest b/.devenv/state/go/pkg/sumdb/sum.golang.org/latest
deleted file mode 100644
index eb4b0d74c7472bd4bb9db64709d8bd29691a6db1..0000000000000000000000000000000000000000
--- a/.devenv/state/go/pkg/sumdb/sum.golang.org/latest
+++ /dev/null
@@ -1,5 +0,0 @@
-go.sum database tree
-19632713
-+dFqIiCep9PFS2o8VBuGFtkBBGfUWWNR5ZdeHkgmu9k=
-
-— sum.golang.org Az3griAQL5WUYUZsThtGZu3lOLHLrxWK0YS6TDTBr7TJUTmogfpY1Hyrv21yIzVzvlSSsoq4A1vGmP1Se1EmBw8IcgQ=
diff --git a/.gitignore b/.gitignore
index c55f7d029ba6d56ff0080797e6bfd7a4f7b7867b..ddb7ceffb252b8956a75cfcd0f28ca4ce56856e1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -61,7 +61,7 @@ testdata/
# Gradle
.idea/**/gradle.xml
-.idea/**/libraries
+g.idea/**/libraries
# Gradle and Maven with auto-import
# When using Gradle or Maven with auto-import, you should exclude module files,
@@ -146,4 +146,7 @@ fabric.properties
# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
.idea/**/azureSettings.xml
-# End of https://www.toptal.com/developers/gitignore/api/intellij,go
\ No newline at end of file
+# End of https://www.toptal.com/developers/gitignore/api/intellij,go
+/.attach_pid*
+.devenv*
+devenv.local.nix
diff --git a/execute.go b/execute.go
index 68a06c612477211264501f11003dc5901308f6fd..b8569b1b134951dfc309afb6f650f3695393f205 100644
--- a/execute.go
+++ b/execute.go
@@ -11,6 +11,9 @@ import (
)
func (s *Settings[C]) Execute() *Settings[C] {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
if len(s.errors) > 0 {
return s
}
@@ -89,6 +92,8 @@ func callCmdFunctions[C any](settings *Settings[C], commands []*cmd[C]) bool {
// HelpRequested indicates if the help flag was set.
func (s *Settings[C]) HelpRequested() bool {
+ s.mu.Lock()
+ defer s.mu.Unlock()
for _, err := range s.errors {
if err == flag.ErrHelp {
@@ -99,8 +104,10 @@ func (s *Settings[C]) HelpRequested() bool {
return false
}
-// MissingCommandError is returned if no command was found.
+// MissingCommand returns true if the command was not found
func (s *Settings[C]) MissingCommand() bool {
+ s.mu.Lock()
+ defer s.mu.Unlock()
for _, err := range s.errors {
if err == MissingCommandError {
@@ -113,5 +120,8 @@ func (s *Settings[C]) MissingCommand() bool {
// WasExecuted returns true if the call function was executed
func (s *Settings[C]) WasExecuted() bool {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
return s.wasExecuted
}
diff --git a/go.mod b/go.mod
index b725f36639b179e5c2d116d2020012e5bc20b1b1..578f6bcecae095686926899f76bee52474670cef 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.19
require (
github.com/stretchr/testify v1.8.2
- gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.8.1
+ gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.9.1
)
require (
diff --git a/go.sum b/go.sum
index 83ee2b199d080a9595b46e37d34b1e579426b32e..9ee6019d372bc6d66e531f6822845731d1653743 100644
--- a/go.sum
+++ b/go.sum
@@ -26,6 +26,8 @@ gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.5.2 h1:R+dL2NJCM+AQN
gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.5.2/go.mod h1:UvdD4NAf3gLKYafabJD7e9ZCOetzM9JZ9y4GkZukPVU=
gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.8.1 h1:A3KvLvu4rV3OstgEn6xHulhQaXawVvzFzbafYHWHUfs=
gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.8.1/go.mod h1:MqCBFv7DXKoBE2rZDc51LGvl2QI7Kz0D+XkQ0izj+ws=
+gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.9.1 h1:WpM6PcFqQZWPBGDEuMILWHq98dPVBLAxi8ae9QMWWbM=
+gitlab.schukai.com/oss/libraries/go/utilities/pathfinder v0.9.1/go.mod h1:MqCBFv7DXKoBE2rZDc51LGvl2QI7Kz0D+XkQ0izj+ws=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/issue-7_test.go b/issue-7_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7593351e3b8f533fa613b4f27d9faea42cf7b7ff
--- /dev/null
+++ b/issue-7_test.go
@@ -0,0 +1,37 @@
+package xflags
+
+import (
+ "sync"
+ "testing"
+)
+
+type testI7 struct {
+}
+
+func TestRaceCondition(t *testing.T) {
+ var wg sync.WaitGroup
+ settings := &Settings[testI7]{}
+
+ for i := 0; i < 100; i++ {
+ wg.Add(4) // 4 Methoden werden in jeder Iteration aufgerufen
+
+ go func() {
+ settings.Execute()
+ wg.Done()
+ }()
+ go func() {
+ _ = settings.HelpRequested()
+ wg.Done()
+ }()
+ go func() {
+ _ = settings.MissingCommand()
+ wg.Done()
+ }()
+ go func() {
+ _ = settings.WasExecuted()
+ wg.Done()
+ }()
+ }
+
+ wg.Wait()
+}
diff --git a/setting.go b/setting.go
index 78e1acd9699969f52785296e4032a78536fccacb..6697cbf3b46e9babfa9e46ededfa6011fad31080 100644
--- a/setting.go
+++ b/setting.go
@@ -6,6 +6,7 @@ package xflags
import (
"flag"
"io"
+ "sync"
)
func (s *Settings[C]) initCommands(name string) {
@@ -19,6 +20,8 @@ type config struct {
// Settings[C] is the main struct for the xflags package.
type Settings[C any] struct {
+ mu sync.Mutex
+
definitions C
command *cmd[C]