def id2 = new ChannelIdentifier("channel2")

        expect:
        def channelQueue = queue.getChannel(id1)
        channelQueue == queue.getChannel(id1)
        channelQueue != queue.getChannel(id2)
    }

    def "adds channel queue when channel message added"() {
        def id1 = new ChannelIdentifier("channel1")
        def id2 = new ChannelIdentifier("channel2")

        anyOf(ivy("org", "mod", artifact("mod"), "exact"), ivy("org", "mod2", artifact("mod"), "exact"))               | group("org")                                                                           | allOf(anyOf(ivy("org", "mod", artifact("mod"), "exact"), ivy("org", "mod2", artifact("mod"), "exact")), group("org"))

            start("2", id1),
            start("3", id1),
            start("1", id2),
            start("2", id2),
            start("3", id2),
            finished("3", id1),
            finished("2", id1),
            finished("1", id1),
            finished("3", id2),
            finished("2", id2),
            finished("1", id2),
        ]
    }

}

// Copy creates a duplicate of security identifier sid.
func (sid *SID) Copy() (*SID, error) {
	b := make([]byte, sid.Len())
	sid2 := (*SID)(unsafe.Pointer(&b[0]))
	e := CopySid(uint32(len(b)), sid2, sid)
	if e != nil {
		return nil, e
	}
	return sid2, nil
}

// LookupAccount retrieves the name of the account for this sid
// and the name of the first domain on which this sid is found.

        where:
        requested                                            | forcedVersion
        newSelector(mid("org", "module2"), "0.9")            | "2.0"
        newSelector(mid("org", "module2"), "2.1")            | "2.0"
        newSelector(mid("org", "module:with:colon"), "2.0")  | "3.0"
        newSelector(mid("org:with:colon", "module2"), "5.0") | "4.0"
    }

    def "does not force modules if they dont match"() {

        mod1.pom.expectGet()
        mod1.artifact.expectGet()

        // Build 2 should download module 2 and reuse cached module 1 state
        mod2.pom.expectGet()
        mod2.artifact.expectGet()

        // Start build 1 then wait until it has run task 'a'.
        executer.withTasks("a", "block1", "b")
        executer.withArgument("--info")
        def build1 = executer.start()

        def id = generator.generateId()
        def id2 = other.generateId()

        then:
        id != id2

        and:
        2 * target.generateId() >> 12
    }

    def compositeIdsAreEqualWhenOriginalIdsAreEqual() {
        when:
        def id = generator.generateId()
        def id2 = generator.generateId()

        then:
        id == id2

        and:
        2 * target.generateId() >> 12

		if a > 0 && !{{Less "data" "a-1" "pivot"}} {
			mid := partitionEqual{{.FuncSuffix}}(data, a, b, pivot {{.ExtraArg}})
			a = mid
			continue
		}

		mid, alreadyPartitioned := partition{{.FuncSuffix}}(data, a, b, pivot {{.ExtraArg}})
		wasPartitioned = alreadyPartitioned

		leftLen, rightLen := mid-a, b-mid
		balanceThreshold := length / 8
		if leftLen < rightLen {

	// Without the CPUID bit the kernel will not trap the instruction and the
	// process will be terminated with SIGILL.
	if ARM64.HasCPUID {
		midr := getMIDR()
		part_num := uint16((midr >> 4) & 0xfff)
		implementer := byte((midr >> 24) & 0xff)

		// d0c - NeoverseN1
		// d40 - NeoverseV1
		// d49 - NeoverseN2
		// d4f - NeoverseV2
		if implementer == 'A' && (part_num == 0xd0c || part_num == 0xd40 ||

        cache.get(id1, classPath("c2"), root, null)
        cache.get(id2, classPath("c2"), root, null)

        then:
        cache.size() == 1 // both are the same

        when:
        cache.remove(id1)

        then:
        cache.size() == 1 // still used by id2

        when:
        cache.remove(id2)

        then:
        cache.size() == 0
    }