expectedErr                 bool
	}{
		{
			name:        "subnet mask 24",
			svcSubnet:   "10.96.0.12/24",
			expectedIP:  "10.96.0.1",
			expectedErr: false,
		},
		{
			name:        "subnet mask 12",
			svcSubnet:   "10.96.0.0/12",
			expectedIP:  "10.96.0.1",
			expectedErr: false,
		},
		{
			name:        "subnet mask 26",
			svcSubnet:   "10.87.116.64/26",
			expectedIP:  "10.87.116.65",

        result.assertNotOutput("task2")

        when:
        run("task1")

        then:
        outputContains("Received :other")
        outputContains("Create :task1")
        outputContains("Configure :task1")
        outputContains("Configure again :task1")
        outputContains("Received :task1")
        result.assertNotOutput("task2")
        result.assertNotOutput("task3")
    }

	var ifat []Addr
	for _, a := range as {
		var ip IP
		var mask IPMask
		switch a := a.(type) {
		case *lif.Inet4Addr:
			ip = IPv4(a.IP[0], a.IP[1], a.IP[2], a.IP[3])
			mask = CIDRMask(a.PrefixLen, 8*IPv4len)
		case *lif.Inet6Addr:
			ip = make(IP, IPv6len)
			copy(ip, a.IP[:])
			mask = CIDRMask(a.PrefixLen, 8*IPv6len)
		}
		ifat = append(ifat, &IPNet{IP: ip, Mask: mask})
	}
	return ifat, nil
}

static void segvHandler(int signo, siginfo_t* info, void* ctxt) {
	sigset_t mask;
	int i;

	// Call an arbitrary function that requires the stack to be properly aligned.
	callWithVarargs("dummy arg", 3.1415);

	if (sigemptyset(&mask) < 0) {
		die("sigemptyset");
	}
	if (sigaddset(&mask, SIGSEGV) < 0) {
		die("sigaddset");
	}
	i = sigprocmask(SIG_UNBLOCK, &mask, NULL);
	if (i != 0) {

	// Since golden is a newly allocated image, we don't have to check if the
	// input source and mask images and the output golden image overlap.
	b := dst.Bounds()
	sb := src.Bounds()
	mb := image.Rect(-1e9, -1e9, 1e9, 1e9)
	if mask != nil {
		mb = mask.Bounds()
	}

        decorator.classifier = "<classifier>"
        decorator.builtBy(task2)

        then:
        decorator.name == "<name>"
        decorator.extension == "<ext>"
        decorator.type == "<type>"
        decorator.classifier == "<classifier>"
        decorator.buildDependencies.getDependencies(null) == [task, task2] as Set

        when:
        decorator.classifier = null

        then:

	if maskSize < goarch.PtrSize {
		maskSize = goarch.PtrSize
	}
	if maskSize > len(mask) {
		maskSize = len(mask)
	}

	if cpuset_getaffinity(_CPU_LEVEL_WHICH, _CPU_WHICH_PID, _CPU_CURRENT_PID,
		maskSize, (*byte)(unsafe.Pointer(&mask[0]))) != 0 {
		return 1
	}
	n := int32(0)
	for _, v := range mask[:maskSize] {
		for v != 0 {
			n += int32(v & 1)
			v >>= 1
		}
	}
	if n == 0 {

        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
    }

    TYPE_DISALLOWED -> TYPE_DISALLOWED

    else -> error("unexpected type: $type")
  }
}

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

	S3                Metadata          `json:"s3"`
	Source            Source            `json:"source"`
	Type              madmin.TraceType  `json:"-"`
}

// Mask returns the type as mask.
func (e Event) Mask() uint64 {
	return e.EventName.Mask()
}

// Log represents event information for some event targets.
type Log struct {
	EventName Name
	Key       string
	Records   []Event