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

    try {
      getList().add(0, e0());
      fail("add(n, present) should throw");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_supportedNotPresent() {
    getList().add(0, e3());
    expectAdded(0, e3());
  }

  @CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)

        when:
        dependency.add(dep)

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

    def "fails for other types"() {
        when:
        dependency.add(12)
        dependency.getDependencies(task)

        then:
        def e = thrown(TaskDependencyResolveException)

  @Test fun addParsing() {
    val headers =
      Headers.Builder()
        .add("foo: bar")
        .add(" foo: baz") // Name leading whitespace is trimmed.
        .add("foo : bak") // Name trailing whitespace is trimmed.
        .add("\tkey\t:\tvalue\t") // '\t' also counts as whitespace
        .add("ping:  pong  ") // Value whitespace is trimmed.
        .add("kit:kat") // Space after colon is not required.
        .build()

mkdir pkg
echo 'package pkg'
cp stdout pkg/p.go
git add pkg/p.go
git commit -m 'pkg: add'

at 2018-02-19T17:30:23-05:00
env GIT_AUTHOR_DATE=2018-02-19T17:24:48-05:00
echo 'module "github.com/vgotest1/v2"'
cp stdout go.mod
git add go.mod
git commit -m 'add go.mod'

at 2018-02-19T17:30:45-05:00
echo 'module "github.com/vgotest1"'
cp stdout go.mod
git add go.mod
git commit -m 'bad mod path'

        0 * _._

        when:
        walker.add(1)
        def values = walker.findValues()

        then:
        values == ['1', '2', '3', '4'] as Set

        when:
        walker.add(2)
        values = walker.findValues()

        then:
        values == ['1', '2', '3', '4'] as Set

        when:
        walker.add(3)
        values = walker.findValues()

        then:

        1 * dependencyConstraintFactory.createDependencyConstraint("someOther") >> constraint2
        1 * dependencyConstraintSet.add(constraint1)
        1 * dependencyConstraintSet.add(constraint2)
    }

    void "can use dynamic method to add multiple dependency constraint from nested lists"() {
        def constraint1 = Mock(DependencyConstraint)
        def constraint2 = Mock(DependencyConstraint)