github.com/anthonyme00/gomarkdoc@v1.0.0/lang/func_test.go (about) 1 package lang_test 2 3 import ( 4 "errors" 5 "strings" 6 "testing" 7 8 "github.com/anthonyme00/gomarkdoc/lang" 9 "github.com/anthonyme00/gomarkdoc/logger" 10 "github.com/matryer/is" 11 ) 12 13 func TestFunc_Level_standalone(t *testing.T) { 14 is := is.New(t) 15 16 fn, err := loadFunc("../testData/lang/function", "Standalone") 17 is.NoErr(err) 18 19 is.Equal(fn.Level(), 2) 20 } 21 22 func TestFunc_Level_receiver(t *testing.T) { 23 is := is.New(t) 24 25 fn, err := loadFunc("../testData/lang/function", "WithReceiver") 26 is.NoErr(err) 27 28 is.Equal(fn.Level(), 3) 29 } 30 31 func TestFunc_Level_initializer(t *testing.T) { 32 is := is.New(t) 33 34 fn, err := loadFunc("../testData/lang/function", "New") 35 is.NoErr(err) 36 37 is.Equal(fn.Level(), 3) 38 } 39 40 func TestFunc_Name_standalone(t *testing.T) { 41 is := is.New(t) 42 43 fn, err := loadFunc("../testData/lang/function", "Standalone") 44 is.NoErr(err) 45 46 is.Equal(fn.Name(), "Standalone") 47 } 48 49 func TestFunc_Name_receiver(t *testing.T) { 50 is := is.New(t) 51 52 fn, err := loadFunc("../testData/lang/function", "WithReceiver") 53 is.NoErr(err) 54 55 is.Equal(fn.Name(), "WithReceiver") 56 } 57 58 func TestFunc_Receiver_standalone(t *testing.T) { 59 is := is.New(t) 60 61 fn, err := loadFunc("../testData/lang/function", "Standalone") 62 is.NoErr(err) 63 64 is.Equal(fn.Receiver(), "") 65 } 66 67 func TestFunc_Receiver_receiver(t *testing.T) { 68 is := is.New(t) 69 70 fn, err := loadFunc("../testData/lang/function", "WithReceiver") 71 is.NoErr(err) 72 73 is.Equal(fn.Receiver(), "Receiver") 74 } 75 76 func TestFunc_Location(t *testing.T) { 77 is := is.New(t) 78 79 fn, err := loadFunc("../testData/lang/function", "Standalone") 80 is.NoErr(err) 81 82 loc := fn.Location() 83 is.Equal(loc.Start.Line, 14) 84 is.Equal(loc.Start.Col, 1) 85 is.Equal(loc.End.Line, 14) 86 is.Equal(loc.End.Col, 48) 87 is.True(strings.HasSuffix(loc.Filepath, "func.go")) 88 } 89 90 func TestFunc_Examples_generic(t *testing.T) { 91 is := is.New(t) 92 fn, err := loadFunc("../testData/lang/function", "WithGenericReceiver") 93 is.NoErr(err) 94 95 examples := fn.Examples() 96 is.Equal(len(examples), 1) 97 98 ex := examples[0] 99 is.Equal(ex.Name(), "") 100 } 101 102 func TestFunc_stringsCompare(t *testing.T) { 103 is := is.New(t) 104 105 buildPkg, err := getBuildPackage("strings") 106 is.NoErr(err) 107 108 log := logger.New(logger.ErrorLevel) 109 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 110 is.NoErr(err) 111 112 var fn *lang.Func 113 for _, f := range pkg.Funcs() { 114 if f.Name() == "Compare" { 115 fn = f 116 break 117 } 118 } 119 120 is.True(fn != nil) // didn't find the function we were looking for 121 122 sig, err := fn.Signature() 123 is.NoErr(err) 124 125 is.Equal(fn.Name(), "Compare") 126 is.Equal(fn.Level(), 2) 127 is.Equal(fn.Title(), "func Compare") 128 is.Equal(fn.Summary(), "Compare returns an integer comparing two strings lexicographically.") 129 is.Equal(sig, "func Compare(a, b string) int") 130 is.Equal(len(fn.Examples()), 1) 131 } 132 133 func TestFunc_textScannerInit(t *testing.T) { 134 is := is.New(t) 135 136 buildPkg, err := getBuildPackage("text/scanner") 137 is.NoErr(err) 138 139 log := logger.New(logger.ErrorLevel) 140 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 141 is.NoErr(err) 142 143 var typ *lang.Type 144 for _, t := range pkg.Types() { 145 if t.Name() == "Scanner" { 146 typ = t 147 break 148 } 149 } 150 is.True(typ != nil) 151 152 var fn *lang.Func 153 for _, f := range typ.Methods() { 154 if f.Name() == "Init" { 155 fn = f 156 break 157 } 158 } 159 160 is.True(fn != nil) // didn't find the function we were looking for 161 162 sig, err := fn.Signature() 163 is.NoErr(err) 164 165 is.Equal(fn.Name(), "Init") 166 is.Equal(fn.Level(), 3) 167 is.Equal(fn.Title(), "func (*Scanner) Init") 168 is.Equal(fn.Summary(), "Init initializes a Scanner with a new source and returns s.") 169 is.Equal(sig, "func (s *Scanner) Init(src io.Reader) *Scanner") 170 is.Equal(len(fn.Examples()), 0) 171 } 172 173 func TestFunc_ioIoutilTempFile(t *testing.T) { 174 is := is.New(t) 175 176 buildPkg, err := getBuildPackage("io/ioutil") 177 is.NoErr(err) 178 179 log := logger.New(logger.ErrorLevel) 180 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 181 is.NoErr(err) 182 183 var fn *lang.Func 184 for _, f := range pkg.Funcs() { 185 if f.Name() == "TempFile" { 186 fn = f 187 break 188 } 189 } 190 191 is.True(fn != nil) // didn't find the function we were looking for 192 193 sig, err := fn.Signature() 194 is.NoErr(err) 195 196 is.Equal(fn.Name(), "TempFile") 197 is.Equal(fn.Level(), 2) 198 is.Equal(fn.Title(), "func TempFile") 199 is.Equal(fn.Summary(), "TempFile creates a new temporary file in the directory dir, opens the file for reading and writing, and returns the resulting *os.File.") 200 is.Equal(sig, "func TempFile(dir, pattern string) (f *os.File, err error)") 201 is.Equal(len(fn.Examples()), 2) 202 } 203 204 func loadFunc(dir, name string) (*lang.Func, error) { 205 buildPkg, err := getBuildPackage(dir) 206 if err != nil { 207 return nil, err 208 } 209 210 log := logger.New(logger.ErrorLevel) 211 pkg, err := lang.NewPackageFromBuild(log, buildPkg) 212 if err != nil { 213 return nil, err 214 } 215 216 for _, f := range pkg.Funcs() { 217 if f.Name() == name { 218 return f, nil 219 } 220 } 221 222 for _, t := range pkg.Types() { 223 for _, f := range t.Funcs() { 224 if f.Name() == name { 225 return f, nil 226 } 227 } 228 229 for _, f := range t.Methods() { 230 if f.Name() == name { 231 return f, nil 232 } 233 } 234 } 235 236 return nil, errors.New("func not found") 237 }