Go

Take Screenshots with Selenium in Go

Take Screenshots with Selenium in Go package main import ( "fmt" log "github.com/sirupsen/logrus" "github.com/tebeka/selenium" "io/ioutil" ) const ( chromeDriverPath = "/usr/local/bin/chromedriver" port = 9515 ) func main() { var opts []selenium.ServiceOption selenium.SetDebug(false) service, err := selenium.NewChromeDriverService(chromeDriverPath, port, opts...) if err != nil { panic(err) // panic is used only as an example and is not otherwise recommended. } defer service.Stop() caps := selenium.Capabilities{"browserName": "chrome"} // Full-page screenshot // Get page width/height, resize the browser window, then take a screenshot. // Note: only headless mode allows arbitrary window sizes; otherwise the max height cannot exceed your screen resolution. // chromeCaps := chrome.Capabilities{ // Path: "", // Args: []string{ // "--headless", // }, // } // caps.AddChrome(chromeCaps) wd, err := selenium.NewRemote(caps, fmt.Sprintf("http://localhost:%d/wd/hub", port)) if err != nil { panic(err) } defer wd.Quit() // ExecuteScript can run JavaScript. The return value is interface{}, so assert to float then convert to int. // height, _ := wd.ExecuteScript("return document.body.parentNode.scrollHeight", nil) // var realHeight = int(height.(float64)) // Then set the window size. // wd.ResizeWindow("", 1920, realHeight) if err := wd.Get("https://github.com/tgbot-collection/archiver"); err != nil { panic(err) } screenshot, err := wd.Screenshot() if err != nil { log.Errorln(err) } ioutil.WriteFile("screenshot.png", screenshot, 0644) } Full-page screenshot Get the page width/height, resize the browser window accordingly, and then take the screenshot. Note that only headless mode allows arbitrary window sizes; otherwise the maximum height cannot exceed your display resolution.

Friday, December 2, 2022 Read

Use Go Fuzzing to Write More Complete Unit Tests

Use Go Fuzzing to Write More Complete Unit Tests func Pow(base uint, exponent uint) uint { if exponent == 0 { return 1 } return base * Pow(base, exponent-1) } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) assert.Equal(Pow(x, 0), uint(1)) assert.Equal(Pow(x, 1), x) assert.Equal(Pow(x, 2), x*x) if x > 0 && y > 0 { assert.Equal(Pow(x, y)/x, Pow(x, y-1)) } }) } go test -fuzz=Fuzz -fuzztime 20s When a fuzz test fails, Go records the input in testcase/ You will find that when x=6 and y=30, the assert fails, i.e., pow(6, 30)/6 is not equal to pow(6, 29). That seems odd, but after testing you will see it is because pow(6, 30) overflows. The max.MaxUint in Go is about 18 * 10^¹⁸, while 6^²⁹ is about 7 * 10^¹⁸. If you multiply 6^²⁹ by 6, it overflows and yields 8 * 10^¹⁸. It is like running two laps and ending up near the starting point. var ErrOverflow = fmt.Errorf("overflow") func Pow(base uint, exponent uint) (uint, error) { if exponent == 0 { return 1 } prevResult, err := Pow(base, exponent-1) if math.MaxUint/base < prevResult { return 0, ErrOverflow } return base * prevResult, nil } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) if result, err := Pow(x, 1); err != ErrOverflow { assert.Equal(result, x) } if result, err := Pow(x, y); x > 0 && y > 0 && err != ErrOverflow { resultDivX, _ := Pow(x, y-1) assert.Equal(result/x, resultDivX) } }) }

Thursday, November 3, 2022 Read

Go string format

Go string format Go 语言 fmt.Printf 使用指南 The verb at the end defines the type and the interpretation of its corresponding argument. d - decimal integer o - octal integer O - octal integer with 0o prefix b - binary integer x - hexadecimal integer lowercase X - hexadecimal integer uppercase f - decimal floating point, lowercase F - decimal floating point, uppercase e - scientific notation (mantissa/exponent), lowercase E - scientific notation (mantissa/exponent), uppercase g - the shortest representation of %e or %f G - the shortest representation of %E or %F c - a character represented by the corresponding Unicode code point q - a quoted character U - Unicode escape sequence t - the word true or false s - a string v - default format #v - Go-syntax representation of the value T - a Go-syntax representation of the type of the value p - pointer address % - a double %% prints a single % Go string format indexing package main import ( "fmt" ) func main() { n1 := 2 n2 := 3 n3 := 4 res := fmt.Sprintf("There are %d oranges %d apples %d plums", n1, n2, n3) fmt.Println(res) // There are 2 oranges 3 apples 4 plums res2 := fmt.Sprintf("There are %[2]d oranges %d apples %[1]d plums", n1, n2, n3) fmt.Println(res2) // There are 3 oranges 4 apples 2 plums } Go string format precision package main import ( "fmt" ) func main() { fmt.Printf("%0.f\n", 16.540) // 17 fmt.Printf("%0.2f\n", 16.540) // 16.54 fmt.Printf("%0.3f\n", 16.540) // 16.540 fmt.Printf("%0.5f\n", 16.540) // 16.54000 } Go string format flags package main import ( "fmt" ) func main() { fmt.Printf("%+d\n", 1691) // +1691 fmt.Printf("%#x\n", 1691) // 0x69b fmt.Printf("%#X\n", 1691) // 0X69B fmt.Printf("%#b\n", 1691) // 0b11010011011 fmt.Printf("%10d\n", 1691) // 1691 fmt.Printf("%-10d\n", 1691) // 1691 fmt.Printf("%010d\n", 1691) // 0000001691 } Go string format width package main import ( "fmt" ) func main() { w := "falcon" n := 122 h := 455.67 fmt.Printf("%s\n", w) // falcon fmt.Printf("%10s\n", w) // falcon fmt.Printf("%d\n", n). // 122 fmt.Printf("%7d\n", n) // 122 fmt.Printf("%07d\n", n) // 0000122 fmt.Printf("%10f\n", h) // 455.670000 fmt.Printf("%11f\n", h) // 455.670000 fmt.Printf("%12f\n", h) // 455.670000 }

Thursday, September 8, 2022 Read

Build a Lightweight Docker Image for Your Go App? | IT Man

Build a Lightweight Docker Image for Your Go App? | IT Man go build # default $ go build -o test1 main.go $ du -sh test1 14M test1 # You can add `-ldflags "-s -w"` during compilation to reduce the binary size by stripping some link and debug info. Details: # -a: force rebuilding all dependencies # -s: drop symbol table info; stack traces in panic will lose file/line info # -w: drop DWARF debug info; you cannot debug with gdb # If you don't need the symbol table, you can just use "-s" # Note: it is not recommended to use -w and -s together $ go build -ldflags "-s -w" -o test2 main.go $ du -sh test2 11M test2 upx(brew/yum install upx) $ upx test2 Ultimate Packer for eXecutables Copyright (C) 1996 - 2020 UPX 3.96 Markus Oberhumer, Laszlo Molnar & John Reiser Jan 23rd 2020 File size Ratio Format Name -------------------- ------ ----------- ----------- 11490768 -> 4063248 35.36% macho/amd64 test2 Packed 1 file. $ upx --brute test2 $ du -sh test2 4.6M test2 UPX compression options

Monday, July 25, 2022 Read

[Golang] Use build tags for different build configs

[Golang] Use build tags for different build configs Go build -ldflags package main import ( "fmt" ) var flagString string func main() { fmt.Println("This build with ldflag:", flagString) } $ go build -ldflags '-X main.flagString "test"' $ ./main This build with ldflag: test Go build -tags debug_config.go //+build debug package main var TestString string = "test debug" var TestString2 string = " and it will run every module with debug tag." func GetConfigString() string { return "it is debug....." } //+build debug needs a blank line before and after it (unless it is on the first line). release_config.go //+build !debug package main var TestString string = "test release" var TestString2 string = " and it will run every module as no debug tag." func GetConfigString() string { return "it is release....." } main package main import ( "fmt" ) func main() { fmt.Println("This build is ", TestString, TestString2, GetConfigString()) } $ go build -tags debug . $ ./main This build is test debug and it will run every module with debug tag. it is debug..... $ go build . $ ./main This build is test release and it will run every module as no debug tag. it is release.....

Monday, July 18, 2022 Read

A Concise Go embed Tutorial

A Concise Go embed Tutorial Embedding For a single file, you can embed it as string or []byte For multiple files and directories, you can embed them as a new filesystem (FS) Import the “embed” package even if it is not explicitly used The go:embed directive is used for embedding and must be followed by the target variable name Only string, []byte, and embed.FS are supported. Aliases and named types (e.g., type S string) are not allowed Uses relative paths string/[]byte package main import ( _ "embed" "fmt" ) //go:embed hello.txt var s string //go:embed hello.txt var b []byte func main() { fmt.Println(s) fmt.Println(b) } embed.FS package main import ( "embed" "fmt" ) //go:embed hello.txt hello2.txt //go:embed "p/he llo.txt" //go:embed `p/hello-2.txt` //go:embed dir var f embed.FS func main() { data, _ := f.ReadFile("hello.txt") fmt.Println(string(data)) data, _ = f.ReadFile("hello2.txt") fmt.Println(string(data)) data, _ := f.ReadFile("p/he llo.txt") fmt.Println(string(data)) data, _ = f.ReadFile("p/hello-2.txt") fmt.Println(string(data)) } Matching patterns go:embed can take just a directory name. All files and directories inside, except those starting with . and _, are embedded. Subdirectories are embedded recursively to form a filesystem for that directory.

Tuesday, July 12, 2022 Read

Go pprof in Practice

Go pprof in Practice Bomb program package main import ( // omitted _ "net/http/pprof" // auto-register handlers to the HTTP server for profiling via HTTP // omitted ) func main() { // omitted runtime.GOMAXPROCS(1) // limit CPU usage to avoid overload runtime.SetMutexProfileFraction(1) // enable lock contention profiling runtime.SetBlockProfileRate(1) // enable blocking operation profiling go func() { // start an HTTP server; pprof handlers have already been registered // /debug/pprof/ if err := http.ListenAndServe(":6060", nil); err != nil { log.Fatal(err) } os.Exit(0) }() // omitted } http://localhost:6060/debug/pprof/ Type Description Notes allocs Samples of memory allocations Can open in a browser, but readability is low blocks Samples of blocking operations Can open in a browser, but readability is low cmdline Show program startup command/args Can open in a browser; shows ./go-pprof-practice goroutine Stacks of all current goroutines Can open in a browser, but readability is low heap Samples of heap memory usage Can open in a browser, but readability is low mutex Samples of lock contention Can open in a browser, but readability is low profile Samples of CPU usage Opening in a browser downloads a file threadcreate Samples of system thread creation Can open in a browser, but readability is low trace Program execution traces Opening in a browser downloads a file; not covered here, see Go trace Investigate high CPU usage

Wednesday, June 22, 2022 Read

Go code refactoring : the 23x performance hunt

Go code refactoring : the 23x performance hunt $ go test -bench=. -cpuprofile cpu.prof $ go tool pprof -svg cpu.prof > cpu.svg $ go test -bench=. -trace trace.out $ go tool trace trace.out

Tuesday, June 7, 2022 Read

Dockertest: A Fast Way to Set Up Integration Test Environments

Dockertest: A Fast Way to Set Up Integration Test Environments dockertest

Thursday, May 12, 2022 Read

Go High-Performance Programming Handbook (Long Read)

Go High-Performance Programming Handbook (Long Read) Common data structures Reflection is nice, but don’t overuse it Prefer strconv over fmt A small amount of repetition is not worse than reflection Use binary.Read and binary.Write with caution binary.Read and binary.Write use reflection and are slow. If you need these two functions, implement the required logic manually instead of using them directly. Avoid repeated conversions from string to byte slice Specify container (slice/map) capacity

Friday, April 22, 2022 Read

How to Choose a Go File Reading Approach

How to Choose a Go File Reading Approach Go provides one-shot methods for reading file content: os.ReadFile and ioutil.ReadFile. Starting from Go 1.16, ioutil.ReadFile is equivalent to os.ReadFile. The pros and cons of loading a file in one shot are obvious: it reduces IO operations, but it loads the entire file into memory. For large files, this risks running out of memory. Read line by line In Go, the bufio.Reader type provides ReadLine(), but in practice we more often use ReadBytes(’\n’) or ReadString(’\n’).

Tuesday, March 29, 2022 Read

Struct Tricks Every Gopher Should Know

Struct Tricks Every Gopher Should Know NoCopy $ go vet aaa.go # command-line-arguments ./aaa.go:7:14: test passes lock by value: sync.WaitGroup contains sync.noCopy ./aaa.go:15:10: call of test copies lock value: sync.WaitGroup contains sync.noCopy type noCopy struct{} type WaitGroup struct { noCopy noCopy // 64-bit value: high 32 bits are counter, low 32 bits are waiter count. // 64-bit atomic operations require 64-bit alignment, but 32-bit // compilers only guarantee that 64-bit fields are 32-bit aligned. // For this reason on 32 bit architectures we need to check in state() // if state1 is aligned or not, and dynamically "swap" the field order if // needed. state1 uint64 state2 uint32 } noCopy is very simple: an empty struct. It has zero size and takes no space (as long as it is not the last field of a struct; otherwise there is still an 8-byte space overhead).

Monday, January 3, 2022 Read