var unused int // ERROR "`unused` is unused"

func g(x int) { // ERROR "`g` is unused"
}

func MissedErrorCheck() {
	RetErr() // ERROR "Error return value is not checked"
}

func Gosimple(ss []string) {
	if ss != nil { // ERROR "S1031: unnecessary nil check around range"
		for _, s := range ss {
			log.Printf(s)
		}
	}
}

func _() {
	x := math.MinInt8
	for {
		_ = x
		x = 0 // ERROR "ineffectual assignment to x"
		x = 0
	}
}

type t struct {
	unusedField int // ERROR "`unusedField` is unused"
}

func fn1() {} // ERROR "func `fn1` is unused"

var v string // ERROR "`v` is unused"

type AsciicheckTеstStruct struct { // ERROR `identifier "AsciicheckTеstStruct" contain non-ASCII character: U\+0435 'е'`
	Date time.Time
}

func BodycloseNotClosed() {
	resp, _ := http.Get("https://google.com") // ERROR "response body must be closed"
	_, _ = ioutil.ReadAll(resp.Body)
}

func cyclopComplexFunc(s string) { // ERROR "calculated cyclomatic complexity for function cyclopComplexFunc is 22, max is 15"
	if s == "1" || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}
	if s == "1" || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}
	if s == "1" || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}
}

import (
	"compress/gzip" // ERROR "`compress/gzip` is in the blacklist"
	"log"           // ERROR "`log` is in the blacklist: don't use log"
)

linters-settings:
  depguard:
    include-go-root: true
    packages: 
      - compress/*
    packages-with-error-message:
      log: "don't use log"

func Dogsled() {
	_ = ret1()
	_, _ = ret2()
	_, _, _ = ret3()    // ERROR "declaration has 3 blank identifiers"
	_, _, _, _ = ret4() // ERROR "declaration has 4 blank identifiers"
}

func (logger *DuplLogger) First(args ...interface{}) { // ERROR "14-23 lines are duplicate of `.*dupl.go:25-34`"
	if logger.level() >= 0 {
		logger.Debug(args...)
		logger.Debug(args...)
		logger.Debug(args...)
		logger.Debug(args...)
		logger.Debug(args...)
		logger.Debug(args...)
	}
}

func (logger *DuplLogger) Second(args ...interface{}) { // ERROR "25-34 lines are duplicate of `.*dupl.go:14-23`"
	if logger.level() >= 1 {
		logger.Info(args...)
		logger.Info(args...)
		logger.Info(args...)
		logger.Info(args...)
		logger.Info(args...)
		logger.Info(args...)
	}
}

func durationcheckCase05() {
	someDuration := 2 * time.Second
	timeToWait := someDuration * time.Second // ERROR "Multiplication of durations: `someDuration \\* time.Second`"
	time.Sleep(timeToWait)
}

func errorLintAll() {
	err := func() error { return nil }()
	if err == errLintFoo { // ERROR "comparing with == will fail on wrapped errors. Use errors.Is to check for a specific error"
		log.Println("errCompare")
	}

	err = errors.New("oops")
	fmt.Errorf("error: %v", err) // ERROR "non-wrapping format verb for fmt.Errorf. Use `%w` to format errors"

	switch err.(type) { // ERROR "type switch on error will fail on wrapped errors. Use errors.As to check for specific errors"
	case *errLintBar:
		log.Println("errLintBar")
	}
}

type Direction int

const (
	North Direction = iota
	East
	South
	West
)

func processDirection(d Direction) {
	switch d { // ERROR "missing cases in switch of type Direction: East, West"
	case North, South:
	}
}

type Test struct {
	A string
	B int
	c bool // private field inside the same package are not ignored
	D float64
	E time.Time
}

var failPrivate = Test{ // ERROR "c is missing in Test"
	A: "a",
	B: 0,
	D: 1.0,
	E: time.Now(),
}

func dummyFunction() {
	var array [4]*int
	var slice []*int
	var ref *int
	var str struct{ x *int }

	fmt.Println("loop expecting 10, 11, 12, 13")
	for i, p := range []int{10, 11, 12, 13} {
		printp(&p)
		slice = append(slice, &p) // ERROR "exporting a pointer for the loop variable p"
		array[i] = &p             // ERROR "exporting a pointer for the loop variable p"
		if i%2 == 0 {
			ref = &p   // ERROR "exporting a pointer for the loop variable p"
			str.x = &p // ERROR "exporting a pointer for the loop variable p"
		}
		var vStr struct{ x *int }
		var vArray [4]*int
		var v *int
		if i%2 == 0 {
			v = &p
			vArray[1] = &p
			vStr.x = &p
		}
		_ = v
	}

	fmt.Println(`slice expecting "10, 11, 12, 13" but "13, 13, 13, 13"`)
	for _, p := range slice {
		printp(p)
	}
	fmt.Println(`array expecting "10, 11, 12, 13" but "13, 13, 13, 13"`)
	for _, p := range array {
		printp(p)
	}
	fmt.Println(`captured value expecting "12" but "13"`)
	printp(ref)
}

func printp(p *int) {
	fmt.Println(*p)
}

func Forbidigo() {
	fmt.Printf("too noisy!!!") // ERROR "use of `fmt\\.Printf` forbidden by pattern `fmt\\\\.Print\\.\\*`"
}

linters-settings:
  forbidigo:
    forbid:
      - fmt\.Print.*

func forcetypeassertInvalid() {
	var a interface{}
	_ = a.(int) // ERROR "type assertion must be checked"

	var b interface{}
	bi := b.(int) // ERROR "type assertion must be checked"
	fmt.Println(bi)
}

func TooManyLines() { // ERROR `Function 'TooManyLines' is too long \(22 > 20\)`
	t := struct {
		A string
		B string
		C string
		D string
		E string
		F string
		G string
		H string
		I string
	}{
		`a`,
		`b`,
		`c`,
		`d`,
		`e`,
		`f`,
		`g`,
		`h`,
		`i`,
	}
	_ = t
}

func TooManyStatements() { // ERROR `Function 'TooManyStatements' has too many statements \(11 > 10\)`
	a := 1
	b := a
	c := b
	d := c
	e := d
	f := e
	g := f
	h := g
	i := h
	j := i
	_ = j
}

package main
import (
  "golang.org/x/tools"

  "fmt"

  "github.com/daixiang0/gci"
)

package main
import (
  "fmt"

  "golang.org/x/tools"

  "github.com/daixiang0/gci"
)

var noGlobalsVar int // ERROR "noGlobalsVar is a global variable"
var ErrSomeType = errors.New("test that global erorrs aren't warned")

var (
	OnlyDigites = regexp.MustCompile(`^\d+$`)
	BadNamedErr = errors.New("this is bad") // ERROR "BadNamedErr is a global variable"
)

func init() { // ERROR "don't use `init` function"
	fmt.Println()
}

// 設定値は2になっています
func GoCognit_CC3_Fact(n int) int { // ERROR "cognitive complexity 3 of func .* is high .*"
	if n <= 1 { // +1
		return 1
	} else { // +1
		return n + GoCognit_CC3_Fact(n-1) // +1
	}
} // total complexity = 3

func GoconstA() {
	a := "needconst" // ERROR "string `needconst` has 5 occurrences, make it a constant"
	fmt.Print(a)
	b := "needconst"
	fmt.Print(b)
	c := "needconst"
	fmt.Print(c)
}

func GoconstB() {
	a := "needconst"
	fmt.Print(a)
	b := "needconst"
	fmt.Print(b)
}

const AlreadyHasConst = "alreadyhasconst"

func GoconstC() {
	a := "alreadyhasconst" // ERROR "string `alreadyhasconst` has 3 occurrences, but such constant `AlreadyHasConst` already exists"
	fmt.Print(a)
	b := "alreadyhasconst"
	fmt.Print(b)
	c := "alreadyhasconst"
	fmt.Print(c)
	fmt.Print("alreadyhasconst")
}

func GocycloBigComplexity(s string) { // ERROR "cyclomatic complexity .* of func .* is high .*"
	if s == http.MethodGet || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}

	if s == "1" || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}

	if s == "1" || s == "2" || s == "3" || s == "4" || s == "5" || s == "6" || s == "7" {
		return
	}
}

func SimpleEqual(e1, e2 error) bool {
	return e1 == e2 // ERROR `err113: do not compare errors directly "e1 == e2", use "errors.Is\(e1, e2\)" instead`
}

func SimpleNotEqual(e1, e2 error) bool {
	return e1 != e2 // ERROR `err113: do not compare errors directly "e1 != e2", use "!errors.Is\(e1, e2\)" instead`
}

func UseMagicNumber() {
	c := &http.Client{
		Timeout: 2 * time.Second, // ERROR "Magic number: 2, in <assign> detected"
	}

	res, err := c.Get("http://www.google.com")
	if err != nil {
		log.Fatal(err)
	}
	if res.StatusCode != 200 { // ERROR "Magic number: 200, in <condition> detected"
		log.Println("Something went wrong")
	}
}

import (
	"log"

	"golang.org/x/mod/modfile"
	"gopkg.in/yaml.v3" // ERROR "import of package `gopkg.in/yaml.v3` is blocked because the module is in the blocked modules list. `github.com/kylelemons/go-gypsy` is a recommended module. This is an example of recommendations."
)

func PrintfLikeFuncWithBadName(format string, args ...interface{}) { // ERROR "printf-like formatting function 'PrintfLikeFuncWithBadName' should be named 'PrintfLikeFuncWithBadNamef'"
}

err := otherFunc1() // ERROR "variable 'err' is only used in the if-statement .*"
if err != nil {
	otherFunc2(err)
}

if err := otherFunc1(); err != nil {
		otherFunc2(err)
}

import (
	wrong_alias "fmt" // ERROR `import "fmt" imported as "wrong_alias" but must be "fff" according to config`
	"os"
	wrong_alias_again "os" // ERROR `import "os" imported as "wrong_alias_again" but must be "std_os" according to config`

	wrong "github.com/pkg/errors" // ERROR `import "github.com/pkg/errors" imported as "wrong" but must be "pkgerr" according to config`
)

linters-settings:
  importas:
    alias:
      - pkg: fmt
        alias: fff
      - pkg: os
        alias: std_os
      - pkg: github.com/pkg/errors
        alias: pkgerr

func Lll() {
	// In my experience, long lines are the lines with comments, not the code. So this is a long comment // ERROR "line is 138 characters"
}

func Makezero() []int {
	x := make([]int, math.MaxInt8)
	return append(x, 1) // ERROR "append to slice `x` with non-zero initialized length"
}

func NakedretIssue() (a int, b string) {
	if a > 0 {
		return
	}

	if b == "" {
		return 0, "0"
	}

	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...
	// ...

	// len of this function is 31
	return // ERROR "naked return in func `NakedretIssue` with 31 lines of code"
}

if b1 { // ERROR "`if b1` is deeply nested \\(complexity: 5\\)"
	if b2 { // +1
	} else if b3 { // +1
		if b4 { // +2
		}
	} else { // +1
	}
}

err := nilErrDo()
if err != nil {
	return nil // ERROR `error is not nil \(line 25\) but it returns nil`
}

_ = a
return nil　// ERROR "return with no blank line before"

http.Get(url) // ERROR `net/http\.Get must not be called`

func TestFunctionMissingCallToParallel(t *testing.T) {} // ERROR "Function TestFunctionMissingCallToParallel missing the call to method parallel"

var dest []int // ERROR "Consider preallocating `dest`"
for _, v := range source {
	dest = append(dest, v)
}

dest := make([]int, 0, len(source))
for _, v := range source {
	dest = append(dest, v)
}

func recover() {} // ERROR "function recover has same name as predeclared identifier"

_ = promauto.NewCounterVec(
	prometheus.CounterOpts{ // ERROR `Metric: test_metric_name Error: counter metrics should have "_total" suffix`
		Name: "test_metric_name",
		Help: "test help text",
	}, []string{},
)

_ = promauto.NewCounterVec(
	prometheus.CounterOpts{ // ERROR "Metric: test_metric_total Error: no help text"
		Name: "test_metric_total",
	}, []string{},
)

type TglFoo struct {
	ID     string        `json:"ID"`     // ERROR `json\(camel\): got 'ID' want 'id'`
	UserID string        `json:"UserID"` // ERROR `json\(camel\): got 'UserID' want 'userId'`
	Name   string        `json:"name"`
	Value  time.Duration `json:"value,omitempty"`
	Bar    TglBar        `json:"bar"`
	Bur    `json:"bur"`
}

func Unconvert() {
	a := 1
	b := int(a) // ERROR "unnecessary conversion"
	log.Print(b)
}

func unparamUnused(a, b uint) uint { // ERROR "`unparamUnused` - `b` is unused"
	a++
	return a
}

func f() int {
	a := 0 
        b := 0
        fmt.Print(a)
        fmt.Print(b)
        a = 1  // ここより後にaの値が使用されることはないのでここでの代入は不要です。

        b = 1  // この次の行ですぐに数値が書き換えられているのでここでの代入は不要です。
        b = 2
        fmt.Print(b)
        
	return 1 + 2
}

func do() error {
	_, err := json.Marshal(struct{}{})
	if err != nil {
		return err // ERROR "error returned from external package is unwrapped"
	}

	return nil
}

func do() error {
	_, err := json.Marshal(struct{}{})
	if err != nil {
		return fmt.Errorf("json marchal: %w", err) // ERROR "error returned from external package is unwrapped"
	}

	return nil
}