MOVD    table8+8(FP), R4   // *Table
	MOVD    p+16(FP), R5
	MOVD    p_len+24(FP), R6 // p len

	CMP     $0,R6           // len == 0?
	BNE     start
	MOVW    R3,ret+40(FP)   // return crc
	RET

start:
	NOR     R3,R3,R7        // ^crc
	MOVWZ	R7,R7		// 32 bits
	CMP	R6,$16
	MOVD	R6,CTR
	BLT	short
	SRAD    $3,R6,R8        // 8 byte chunks
	MOVD    R8,CTR

loop:
	MOVWZ	0(R5),R8	// 0-3 bytes of p ?Endian?

/**
 * A source Kotlin DSL program can be:
 * - empty
 * - a single buildscript block
 * - a single plugins block
 * - a buildscript block followed by a plugins block
 * - a script with neither a buildscript nor a plugins block
 * - a script preceded by a buildscript or plugins block or both
 *
 * The evaluation of a Kotlin DSL program happens, in the general case, in
 * [two stages](https://en.wikipedia.org/wiki/Multi-stage_programming):

    }
    Range<C> span = span().canonical(domain);
    if (!span.hasLowerBound()) {
      // according to the spec of canonical, neither this ImmutableRangeSet nor
      // the range have a lower bound
      throw new IllegalArgumentException(
          "Neither the DiscreteDomain nor this range set are bounded below");
    } else if (!span.hasUpperBound()) {
      try {
        domain.maxValue();
      } catch (NoSuchElementException e) {

# (and a requirement on "c" v2):
#
# a --- b
# |
# + --- c
#
# And "b" adds an import of "a/sub" (in module "a"):
#
# b --- a/sub
#
# At v3, "a" no longer imports (nor requires) "c":
#
# a --- b

# So upgrading to a3 adds a dependency on b2,
# b2 adds a dependency on a2 (for "a/sub"),
# and a2 (but not a3) would add a dependency on c2.

			wsstream.IsWebSocketRequestWithStreamCloseProtocol)
		translatingHandler.ServeHTTP(nil, req)
		if !delegate.served && !translator.served {
			t.Errorf("unexpected neither translator nor delegate served")
			continue
		}
		if test.expectTranslator {
			if !translator.served {
				t.Errorf("%s: expected translator served, got delegate served", name)
			}
		} else if !delegate.served {

func (f *FakeIPVS) AddRealServer(serv *utilipvs.VirtualServer, dest *utilipvs.RealServer) error {
	if serv == nil || dest == nil {
		return fmt.Errorf("failed to add destination for service, neither service nor destination shouldn't be nil")
	}
	key := toServiceKey(serv)
	if _, ok := f.Services[key]; !ok {
		return fmt.Errorf("failed to add destination for service %v, service not found", key.String())
	}

        classFile.isFile()
        testClassFile.isFile()
        testResults.isDirectory()

        and:
        assertTestsExecuted("ThingTest", "ok")
    }

    def "build on Groovy project without sources nor groovy dependency"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        buildFile << """
            plugins { id 'groovy' }
        """

        when:

     * When this method returns, all user code will have completed, including 'build finished' hooks.
     *
     * <p>This method may or may nor configure the build. When a cached task graph is available, this may be used instead of configuring the build.
     */
    void scheduleAndRunTasks();

    /**

    }

    def "nothing should be reported if no changes"() {
        expect:
        noViolation(rule)
    }

    def "nothing should be reported if new interface is neither internal nor incubating"() {
        when:
        newBase.addInterface(stablePublicInterface)

        then:
        noViolation(rule)
    }

    def 'adding an #type interface can be reported'() {
        given:

env GOMODCACHE=
env GOPATH=${:}$WORK/this/is/ignored

go env GOMODCACHE
stdout '^$'
! stdout .
! stderr .

! go mod download rsc.io/quote@v1.0.0
stderr '^go: module cache not found: neither GOMODCACHE nor GOPATH is set$'

# If GOMODCACHE isn't set and GOPATH has multiple elements only the first is used.
env GOMODCACHE=
env GOPATH=$WORK/first/path${:}$WORK/this/is/ignored
go env GOMODCACHE