OutputList outputs;
  CreateSwitchN(root.WithOpName("switchn"), value, constant_7, 3, &outputs);

  Output id_0 = ops::Identity(root.WithOpName("id_0"), outputs[0]);
  Output id_1 = ops::Identity(root.WithOpName("id_1"), outputs[1]);
  Output id_2 = ops::Identity(root.WithOpName("id_2"), outputs[2]);

  FixupSourceAndSinkEdges(root.graph());

  PredicateMapTy predicate_map;

        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")

        accessResult2.setSessionId("id2");
        accessResult2.setStatus(200);
        accessResult2.setUrl("http://www.id2.com/");

        dataService.store(accessResult2);

        final EsAccessResult accessResult3 = dataService.getAccessResult("id1", "http://www.id1.com/");
        final EsAccessResult accessResult4 = dataService.getAccessResult("id2", "http://www.id2.com/");
        assertNotNull(accessResult3);

        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

	var in2 int = -5
	var id1 int = +3
	var id2 int = -3

	if in1/id1 != q1 || in1%id1 != r1 {
		println("int-1", in1, id1, in1/id1, in1%id1)
		panic("fail")
	}
	if in2/id1 != q2 || in2%id1 != r2 {
		println("int-2", in2, id1, in2/id1, in2%id1)
		panic("fail")
	}
	if in1/id2 != q3 || in1%id2 != r3 {
		println("int-3", in1, id2, in1/id2, in1%id2)
		panic("fail")
	}
	if in2/id2 != q4 || in2%id2 != r4 {

            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),
        ]
    }

// Use accessor methods instead.

func (l Ledger[T, _]) ID() T               { return l.ID_ }
func (l Ledger[_, K]) Amounts() []K        { return l.Amounts_ }
func (l Ledger[_, K]) SumFn() func(...K) K { return l.SumFn_ }

func PrintLedger[
	T ~string,
	K Numeric,
	L interface {
		~struct {
			ID_      T
			Amounts_ []K
			SumFn_   func(...K) K
		}
		ID() T
		Amounts() []K
		SumFn() func(...K) K

        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
    }

    def "can compare with other instance (#projectPath)"() {
        expect:
        def id1 = newProjectId(':myProjectPath1')
        def id2 = newProjectId(projectPath)
        strictlyEquals(id1, id2) == equality
        (id1.hashCode() == id2.hashCode()) == hashCode
        (id1.toString() == id2.toString()) == stringRepresentation

        where:
        projectPath       | equality | hashCode | stringRepresentation

            extraInfo.asMap() == [(new QName(id1.namespace, id1.name)): "info1 value", (new QName(id2.namespace, id2.name)): "info2 value"]
        }
        capturedDescriptor2 instanceof IvyModuleDescriptor
        with(capturedDescriptor2) {
            extraInfo.asMap() == [(new QName(id1.namespace, id1.name)): "info1 value", (new QName(id2.namespace, id2.name)): "info2 value"]
        }
    }