return
				}
			} else if mask0, ok := mask.(*image.Alpha); ok {
				switch src0 := src.(type) {
				case *image.Uniform:
					drawGlyphOver(dst0, r, src0, mask0, mp)
					return
				case *image.RGBA:
					drawRGBAMaskOver(dst0, r, src0, sp, mask0, mp)
					return
				case *image.Gray:
					drawGrayMaskOver(dst0, r, src0, sp, mask0, mp)
					return

                    }
                }
            }
            project(':b') {
                task task1 {
                    doLast {
                        ${callFromBuild('task1')}
                    }
                }
                task task2 {
                    dependsOn task1
                    doLast {
                        ${callFromBuild('task2')}
                    }
                }

			// check if resource is masked by *.group rule
			anyResourceInGroup := schema.GroupResource{Group: gr.Group, Resource: "*"}
			if _, masked := resourceToPrefixTransformer[anyResourceInGroup]; masked {
				// an earlier rule already configured a transformer for *.group, masking this rule
				// return error since this is not allowed

                task someTask(type: SomeTask)
            }
            task task1 //extra stress
            task task2

            ${taskWithMultipleOptions()}
        """

        when:
        run 'someTask'

        then:
        output.contains 'first=false,second=null'

        when:
        run 'task1', 'someTask', '--first', '--second', 'hey buddy', 'task2'

        then:

	maskUpdatedChan = make(chan struct{})
	disableSigChan = make(chan uint32)
	enableSigChan = make(chan uint32)
	go func() {
		// Signal masks are per-thread, so make sure this goroutine stays on one
		// thread.
		LockOSThread()
		defer UnlockOSThread()
		// The sigBlocked mask contains the signals not active for os/signal,
		// initially all signals except the essential. When signal.Notify()/Stop is called,

    def "zip tracks task dependencies"() {
        def task1 = Stub(Task)
        def a = withProducer(Integer, task1, 5)
        def task2 = Stub(Task)
        def b = withProducer(String, task2, "Hello")

        when:
        def zipped = providerFactory.zip(a, b) { i, s -> s.length() == i } as ProviderInternal<Boolean>

        then:
        assertHasProducer(zipped, task1, task2)
        zipped.get() == true
    }

  static int getHashPrefix(int value, int mask) {
    return value & ~mask;
  }

  /** Returns the index, or 0 if the entry is "null". */
  static int getNext(int entry, int mask) {
    return entry & mask;
  }

  /** Returns a new value combining the prefix and suffix using the given mask. */
  static int maskCombine(int prefix, int suffix, int mask) {
    return (prefix & ~mask) | (suffix & mask);
  }

  static int remove(

#include <time.h>
#include <unistd.h>

extern void IntoGoAndBack();

int CheckBlocked() {
	sigset_t mask;
	sigprocmask(SIG_BLOCK, NULL, &mask);
	return sigismember(&mask, SIGIO);
}

static void* sigthreadfunc(void* unused) {
	sigset_t mask;
	sigemptyset(&mask);
	sigaddset(&mask, SIGIO);
	sigprocmask(SIG_BLOCK, &mask, NULL);
	IntoGoAndBack();
	return NULL;
}

int RunSigThread() {
	int tries;
	pthread_t thread;

//go:nosplit
//go:nowritebarrierrec
func sigaddset(mask *sigset, i int) {
	(*mask)[(i-1)/64] |= 1 << ((uint32(i) - 1) & 63)
}

func sigdelset(mask *sigset, i int) {
	(*mask)[(i-1)/64] &^= 1 << ((uint32(i) - 1) & 63)
}

//go:nosplit
func sigfillset(mask *[2]uint64) {
	(*mask)[0], (*mask)[1] = ^uint64(0), ^uint64(0)

env GO111MODULE=off

[short] skip
[GODEBUG:gocacheverify=1] skip
[compiler:gccgo] skip  # gccgo has no standard packages

# Start with a clean build cache:
# test failures may be masked if the cache has just the right entries already.
env GOCACHE=$WORK/cache

# Run 'go vet os/user' once to warm up the cache.
go vet os/user

# Check that second vet reuses cgo-derived inputs.
# The first command could be build instead of vet,