*
     * @param dependencyNotation notation for the dependency to be added.
     * @return The dependency.
     *
     * @see [DependencyHandler.add]
     */
    fun DependencyHandler.`api`(dependencyNotation: Any): Dependency? =
        add("api", dependencyNotation)


    /**
     * Adds a dependency to the 'api' configuration.
     *
     * @param dependencyNotation notation for the dependency to be added.

	t3 := new(fiat.P256Element).Add(p1.x, p1.y)  // t3 := X1 + Y1
	t4 := new(fiat.P256Element).Add(p2.x, p2.y)  // t4 := X2 + Y2
	t3.Mul(t3, t4)                               // t3 := t3 * t4
	t4.Add(t0, t1)                               // t4 := t0 + t1
	t3.Sub(t3, t4)                               // t3 := t3 - t4
	t4.Add(p1.y, p1.z)                           // t4 := Y1 + Z1

            registration.add(ConfigurationCacheInjectedClasspathInstrumentationStrategy::class.java)
            registration.add(ConfigurationCacheEnvironmentChangeTracker::class.java)
            registration.add(DefaultConfigurationCacheProblemsListener::class.java)
            registration.add(DefaultProblemFactory::class.java)
            registration.add(ConfigurationCacheProblems::class.java)

        cmdList.add(sessionId);
        cmdList.add("--numOfThreads");
        cmdList.add(Integer.toString(numOfThreads));
        if (cleanup) {
            cmdList.add("--cleanup");
        }

        final File propFile = ComponentUtil.getSystemHelper().createTempFile(getExecuteType() + "_", ".properties");
        try {
            cmdList.add("-p");
            cmdList.add(propFile.getAbsolutePath());

	ADD	X21, X29, X13	// z_lo[1] = x[1] * y + z[1] + c
	SLTU	X21, X13, X22
	ADD	X12, X22, X29	// next c

	MULHU	X14, X6, X15	// z_hi[2] = x[2] * y
	MUL	X14, X6, X14	// z_lo[2] = x[2] * y
	ADD	X14, X16, X21	// z_lo[2] = x[2] * y + z[2]
	SLTU	X14, X21, X22
	ADD	X15, X22, X15	// z_hi[2] = x[2] * y + z[2]
	ADD	X21, X29, X16	// z_lo[2] = x[2] * y + z[2] + c
	SLTU	X21, X16, X22
	ADD	X15, X22, X29	// next c

        TestListener listener2 = Mock()
        TestListener listener3 = Mock()
        broadcast.add(listener1)
        broadcast.add(listener2)

        when:
        broadcast.source.event1("event")

        then:
        1 * listener1.event1("event") >> { args ->
            broadcast.add(listener3)
        }
        1 * listener2.event1("event")
        0 * _._

        when:

git branch --set-upstream-to=origin/master

git add pkg/pkg.go
at 2017-09-22T11:41:28-04:00
git commit -a -m 'add pkg'

git log --oneline --decorate=short
cmp stdout ../.git-log

cd ..
svn add git-README-only
svn commit -m 'add modified git-README-only'
svn propset svn:author rsc --revprop -r1
svn propset svn:date 2017-09-22T15:41:54.145716Z --revprop -r1

svn add pkg.go
svn commit -m 'use git-README-only/pkg'

		}
		prevNum = num
	}
}

// Tests Heap.Add and ensures that heap invariant is preserved after adding items.
func TestHeap_Add(t *testing.T) {
	h := New(testHeapObjectKeyFunc, compareInts)
	h.Add(mkHeapObj("foo", 10))
	h.Add(mkHeapObj("bar", 1))
	h.Add(mkHeapObj("baz", 11))
	h.Add(mkHeapObj("zab", 30))
	h.Add(mkHeapObj("foo", 13)) // This updates "foo".

	item, err := h.Pop()

	now = func() time.Time {
		if delay > 0 {
			delay--
		} else {
			current = current.Add(time.Millisecond)
		}
		t.Logf("time %d", current.UnixNano())
		return current
	}
	evictor := NewRateLimitedTimedQueue(flowcontrol.NewFakeAlwaysRateLimiter())
	evictor.Add("first", "11111")
	evictor.Add("second", "22222")
	evictor.Add("third", "33333")

	order := []string{}
	count := 0
	hasQueued := false

      ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator);
      builder.add(BEFORE_FIRST);
      builder.add(BEFORE_FIRST_2);
      builder.add(elements);
      builder.add(AFTER_LAST);
      builder.add(AFTER_LAST_2);
      return builder
          .build()
          .subSet(BEFORE_FIRST_2, AFTER_LAST_2)
          .asList()