# a clear error in module mode.

! go list cmd/unknown
stderr '^package cmd/unknown is not in std \('$GOROOT'[/\\]src[/\\]cmd[/\\]unknown\)$'

go list -f '{{range .DepsErrors}}{{.Err}}{{end}}' x.go
stdout '^package cmd/unknown is not in std \('$GOROOT'[/\\]src[/\\]cmd[/\\]unknown\)$'

-- x.go --
package x

	for _, animal := range zoo {
		census[animal] += 1
	}

	fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",
		census[Gopher], census[Zebra], census[Unknown])

	// Output:
	// Zoo Census:
	// * Gophers: 3
	// * Zebras:  2
	// * Unknown: 3

	for _, animal := range zoo.Animals {
		census[animal] += 1
	}

	fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",
		census[Gopher], census[Zebra], census[Unknown])

	// Output:
	// Zoo Census:
	// * Gophers: 3
	// * Zebras:  2
	// * Unknown: 3

var _ = http.Server{DoneChan: nil}  // ERROR "unknown field DoneChan in struct literal of type http.Server$|unknown field .?DoneChan.? in .?http.Server"

type foo struct {
	bar int
}

        VersionNumber.parse("-") == VersionNumber.UNKNOWN
        VersionNumber.parse(".1") == VersionNumber.UNKNOWN
        VersionNumber.parse("a.1") == VersionNumber.UNKNOWN
        VersionNumber.parse("1_2") == VersionNumber.UNKNOWN
        VersionNumber.parse("1_2_2") == VersionNumber.UNKNOWN
        VersionNumber.parse("1.2.3_4") == VersionNumber.UNKNOWN
    }

    def "accessors"() {

    def "does not schedule garbage collection check when GC strategy is unknown" () {
        when:
        new DefaultGarbageCollectionMonitor(GarbageCollectorMonitoringStrategy.UNKNOWN, scheduledExecutorService)

        then:
        0 * scheduledExecutorService.scheduleAtFixedRate(_, _, _, _)
    }

    def "heap stats defaults to empty given unknown garbage collector"() {
        given:

			return ip.String()
		}
	}
	return "unknown"
}

// lazyAccept implements String() string and it will
// calls http.Request Header.Get() lazily only when required.
type lazyAccept struct {
	req *http.Request
}

func (lazy *lazyAccept) String() string {
	if lazy.req != nil {
		accept := lazy.req.Header.Get("Accept")
		return accept
	}

	return "unknown"
}

		case RecognizingDecoder:
			ok, unknown, err := t.RecognizesData(data)
			if err != nil {
				lastErr = err
				continue
			}
			if unknown {
				skipped = append(skipped, t)
				continue
			}
			if !ok {
				continue
			}
			return r.Decode(data, gvk, into)
		default:
			skipped = append(skipped, t)
		}
	}

	// try recognizers that returned unknown or didn't recognize their data

        when:
        runner('helloWorld', '--unknown').build()

        then:
        def t = thrown UnexpectedBuildFailure
        t.message.contains("Unknown command-line option '--unknown'.")
        t.message.contains('Problem configuring task :helloWorld from command line.')
        def result = t.buildResult
        result.output.contains('BUILD FAILED')
        result.output.contains("Unknown command-line option '--unknown'.")

        null               | [Usage.JAVA_API, "unknown", Usage.JAVA_RUNTIME] | true
        null               | [Usage.JAVA_API, "unknown"]                     | false
        Usage.JAVA_API     | [Usage.JAVA_API, "unknown", Usage.JAVA_RUNTIME] | false
        Usage.JAVA_RUNTIME | [Usage.JAVA_API, "unknown", Usage.JAVA_RUNTIME] | false
        "unknown"          | [Usage.JAVA_API, "unknown", Usage.JAVA_RUNTIME] | false