X-Git-Url: https://git.josue.xyz/?a=blobdiff_plain;f=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.1.0%2Fgodoc%2Fgodoc_test.go;fp=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.1.0%2Fgodoc%2Fgodoc_test.go;h=33dbe3f619b1731fee9a029b5d207ae44dca0a67;hb=3c06164f15bd10aed7d66b6314764a2961a14762;hp=0000000000000000000000000000000000000000;hpb=0e9c3ceb40901f4d44981c1376cb9e23a248e006;p=dotfiles%2F.git diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/godoc/godoc_test.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/godoc/godoc_test.go new file mode 100644 index 00000000..33dbe3f6 --- /dev/null +++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/godoc/godoc_test.go @@ -0,0 +1,370 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package godoc + +import ( + "bytes" + "go/parser" + "go/token" + "strings" + "testing" +) + +func TestPkgLinkFunc(t *testing.T) { + for _, tc := range []struct { + path string + want string + }{ + {"/src/fmt", "pkg/fmt"}, + {"src/fmt", "pkg/fmt"}, + {"/fmt", "pkg/fmt"}, + {"fmt", "pkg/fmt"}, + } { + if got := pkgLinkFunc(tc.path); got != tc.want { + t.Errorf("pkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want) + } + } +} + +func TestSrcPosLinkFunc(t *testing.T) { + for _, tc := range []struct { + src string + line int + low int + high int + want string + }{ + {"/src/fmt/print.go", 42, 30, 50, "/src/fmt/print.go?s=30:50#L32"}, + {"/src/fmt/print.go", 2, 1, 5, "/src/fmt/print.go?s=1:5#L1"}, + {"/src/fmt/print.go", 2, 0, 0, "/src/fmt/print.go#L2"}, + {"/src/fmt/print.go", 0, 0, 0, "/src/fmt/print.go"}, + {"/src/fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"}, + {"fmt/print.go", 0, 0, 0, "/src/fmt/print.go"}, + {"fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"}, + } { + if got := srcPosLinkFunc(tc.src, tc.line, tc.low, tc.high); got != tc.want { + t.Errorf("srcLinkFunc(%v, %v, %v, %v) = %v; want %v", tc.src, tc.line, tc.low, tc.high, got, tc.want) + } + } +} + +func TestSrcLinkFunc(t *testing.T) { + for _, tc := range []struct { + src string + want string + }{ + {"/src/fmt/print.go", "/src/fmt/print.go"}, + {"src/fmt/print.go", "/src/fmt/print.go"}, + {"/fmt/print.go", "/src/fmt/print.go"}, + {"fmt/print.go", "/src/fmt/print.go"}, + } { + if got := srcLinkFunc(tc.src); got != tc.want { + t.Errorf("srcLinkFunc(%v) = %v; want %v", tc.src, got, tc.want) + } + } +} + +func TestQueryLinkFunc(t *testing.T) { + for _, tc := range []struct { + src string + query string + line int + want string + }{ + {"/src/fmt/print.go", "Sprintf", 33, "/src/fmt/print.go?h=Sprintf#L33"}, + {"/src/fmt/print.go", "Sprintf", 0, "/src/fmt/print.go?h=Sprintf"}, + {"src/fmt/print.go", "EOF", 33, "/src/fmt/print.go?h=EOF#L33"}, + {"src/fmt/print.go", "a%3f+%26b", 1, "/src/fmt/print.go?h=a%3f+%26b#L1"}, + } { + if got := queryLinkFunc(tc.src, tc.query, tc.line); got != tc.want { + t.Errorf("queryLinkFunc(%v, %v, %v) = %v; want %v", tc.src, tc.query, tc.line, got, tc.want) + } + } +} + +func TestDocLinkFunc(t *testing.T) { + for _, tc := range []struct { + src string + ident string + want string + }{ + {"fmt", "Sprintf", "/pkg/fmt/#Sprintf"}, + {"fmt", "EOF", "/pkg/fmt/#EOF"}, + } { + if got := docLinkFunc(tc.src, tc.ident); got != tc.want { + t.Errorf("docLinkFunc(%v, %v) = %v; want %v", tc.src, tc.ident, got, tc.want) + } + } +} + +func TestSanitizeFunc(t *testing.T) { + for _, tc := range []struct { + src string + want string + }{ + {}, + {"foo", "foo"}, + {"func f()", "func f()"}, + {"func f(a int,)", "func f(a int)"}, + {"func f(a int,\n)", "func f(a int)"}, + {"func f(\n\ta int,\n\tb int,\n\tc int,\n)", "func f(a int, b int, c int)"}, + {" ( a, b, c ) ", "(a, b, c)"}, + {"( a, b, c int, foo bar , )", "(a, b, c int, foo bar)"}, + {"{ a, b}", "{a, b}"}, + {"[ a, b]", "[a, b]"}, + } { + if got := sanitizeFunc(tc.src); got != tc.want { + t.Errorf("sanitizeFunc(%v) = %v; want %v", tc.src, got, tc.want) + } + } +} + +// Test that we add elements +// to the HTML of struct fields. +func TestStructFieldsIDAttributes(t *testing.T) { + got := linkifySource(t, []byte(` +package foo + +type T struct { + NoDoc string + + // Doc has a comment. + Doc string + + // Opt, if non-nil, is an option. + Opt *int + + // Опция - другое поле. + Опция bool +} +`)) + want := `type T struct { +NoDoc string + +// Doc has a comment. +Doc string + +// Opt, if non-nil, is an option. +Opt *int + +// Опция - другое поле. +Опция bool +}` + if got != want { + t.Errorf("got: %s\n\nwant: %s\n", got, want) + } +} + +// Test that we add elements to the HTML +// of definitions in const and var specs. +func TestValueSpecIDAttributes(t *testing.T) { + got := linkifySource(t, []byte(` +package foo + +const ( + NoDoc string = "NoDoc" + + // Doc has a comment + Doc = "Doc" + + NoVal +)`)) + want := `const ( +NoDoc string = "NoDoc" + +// Doc has a comment +Doc = "Doc" + +NoVal +)` + if got != want { + t.Errorf("got: %s\n\nwant: %s\n", got, want) + } +} + +func TestCompositeLitLinkFields(t *testing.T) { + got := linkifySource(t, []byte(` +package foo + +type T struct { + X int +} + +var S T = T{X: 12}`)) + want := `type T struct { +X int +} +var S T = T{X: 12}` + if got != want { + t.Errorf("got: %s\n\nwant: %s\n", got, want) + } +} + +func TestFuncDeclNotLink(t *testing.T) { + // Function. + got := linkifySource(t, []byte(` +package http + +func Get(url string) (resp *Response, err error)`)) + want := `func Get(url string) (resp *Response, err error)` + if got != want { + t.Errorf("got: %s\n\nwant: %s\n", got, want) + } + + // Method. + got = linkifySource(t, []byte(` +package http + +func (h Header) Get(key string) string`)) + want = `func (h Header) Get(key string) string` + if got != want { + t.Errorf("got: %s\n\nwant: %s\n", got, want) + } +} + +func linkifySource(t *testing.T, src []byte) string { + p := &Presentation{ + DeclLinks: true, + } + fset := token.NewFileSet() + af, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments) + if err != nil { + t.Fatal(err) + } + var buf bytes.Buffer + pi := &PageInfo{ + FSet: fset, + } + sep := "" + for _, decl := range af.Decls { + buf.WriteString(sep) + sep = "\n" + buf.WriteString(p.node_htmlFunc(pi, decl, true)) + } + return buf.String() +} + +func TestScanIdentifier(t *testing.T) { + tests := []struct { + in, want string + }{ + {"foo bar", "foo"}, + {"foo/bar", "foo"}, + {" foo", ""}, + {"фоо", "фоо"}, + {"f123", "f123"}, + {"123f", ""}, + } + for _, tt := range tests { + got := scanIdentifier([]byte(tt.in)) + if string(got) != tt.want { + t.Errorf("scanIdentifier(%q) = %q; want %q", tt.in, got, tt.want) + } + } +} + +func TestReplaceLeadingIndentation(t *testing.T) { + oldIndent := strings.Repeat(" ", 2) + newIndent := strings.Repeat(" ", 4) + tests := []struct { + src, want string + }{ + {" foo\n bar\n baz", " foo\n bar\n baz"}, + {" '`'\n '`'\n", " '`'\n '`'\n"}, + {" '\\''\n '`'\n", " '\\''\n '`'\n"}, + {" \"`\"\n \"`\"\n", " \"`\"\n \"`\"\n"}, + {" `foo\n bar`", " `foo\n bar`"}, + {" `foo\\`\n bar", " `foo\\`\n bar"}, + {" '\\`'`foo\n bar", " '\\`'`foo\n bar"}, + { + " if true {\n foo := `One\n \tTwo\nThree`\n }\n", + " if true {\n foo := `One\n \tTwo\n Three`\n }\n", + }, + } + for _, tc := range tests { + if got := replaceLeadingIndentation(tc.src, oldIndent, newIndent); got != tc.want { + t.Errorf("replaceLeadingIndentation:\n%v\n---\nhave:\n%v\n---\nwant:\n%v\n", + tc.src, got, tc.want) + } + } +} + +func TestSrcBreadcrumbFunc(t *testing.T) { + for _, tc := range []struct { + path string + want string + }{ + {"src/", `src/`}, + {"src/fmt/", `src/fmt/`}, + {"src/fmt/print.go", `src/fmt/print.go`}, + } { + if got := srcBreadcrumbFunc(tc.path); got != tc.want { + t.Errorf("srcBreadcrumbFunc(%v) = %v; want %v", tc.path, got, tc.want) + } + } +} + +func TestSrcToPkgLinkFunc(t *testing.T) { + for _, tc := range []struct { + path string + want string + }{ + {"src/", `Index`}, + {"src/fmt/", `fmt`}, + {"pkg/", `Index`}, + {"pkg/LICENSE", `Index`}, + } { + if got := srcToPkgLinkFunc(tc.path); got != tc.want { + t.Errorf("srcToPkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want) + } + } +} + +func TestFilterOutBuildAnnotations(t *testing.T) { + // TODO: simplify this by using a multiline string once we stop + // using go vet from 1.10 on the build dashboard. + // https://golang.org/issue/26627 + src := []byte("// +build !foo\n" + + "// +build !anothertag\n" + + "\n" + + "// non-tag comment\n" + + "\n" + + "package foo\n" + + "\n" + + "func bar() int {\n" + + " return 42\n" + + "}\n") + + fset := token.NewFileSet() + af, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments) + if err != nil { + t.Fatal(err) + } + + var found bool + for _, cg := range af.Comments { + if strings.HasPrefix(cg.Text(), "+build ") { + found = true + break + } + } + if !found { + t.Errorf("TestFilterOutBuildAnnotations is broken: missing build tag in test input") + } + + found = false + for _, cg := range filterOutBuildAnnotations(af.Comments) { + if strings.HasPrefix(cg.Text(), "+build ") { + t.Errorf("filterOutBuildAnnotations failed to filter build tag") + } + + if strings.Contains(cg.Text(), "non-tag comment") { + found = true + } + } + if !found { + t.Errorf("filterOutBuildAnnotations should not remove non-build tag comment") + } +}