Submit tests: Rename variables

Some of the variables used in the test are badly named, for example
"change2" as the first created change.

Rename them to reduce confusion.

Change-Id: If370b7341cad7655b33e3214f037840d0e6885e4

gerrit-acceptance-tests/src/test/java/com/google/gerrit/acceptance/rest/change/SubmitByCherryPickIT.java

@@ -207,28 +207,28 @@ public class SubmitByCherryPickIT extends AbstractSubmit {
     RevCommit initialHead = getRemoteHead();
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b");
+    PushOneCommit.Result change = createChange("Change 1", "b", "b");
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change3 = createChange("Change 3", "c", "c");
+    PushOneCommit.Result change2 = createChange("Change 2", "c", "c");
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change4 = createChange("Change 4", "d", "d");
+    PushOneCommit.Result change3 = createChange("Change 3", "d", "d");
 
+    approve(change.getChangeId());
     approve(change2.getChangeId());
-    approve(change3.getChangeId());
-    submit(change4.getChangeId());
+    submit(change3.getChangeId());
 
     List<RevCommit> log = getRemoteLog();
     assertThat(log.get(0).getShortMessage()).isEqualTo(
-        change4.getCommit().getShortMessage());
+        change3.getCommit().getShortMessage());
     assertThat(log.get(1).getId()).isEqualTo(initialHead.getId());
 
+    assertNew(change.getChangeId());
     assertNew(change2.getChangeId());
-    assertNew(change3.getChangeId());
 
     assertRefUpdatedEvents(initialHead, log.get(0));
-    assertChangeMergedEvents(change4.getChangeId(), log.get(0).name());
+    assertChangeMergedEvents(change3.getChangeId(), log.get(0).name());
   }
 
   @Test
@@ -236,34 +236,34 @@ public class SubmitByCherryPickIT extends AbstractSubmit {
     RevCommit initialHead = getRemoteHead();
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b");
-    PushOneCommit.Result change3 = createChange("Change 3", "c", "c");
-    assertThat(change3.getCommit().getParent(0)).isEqualTo(change2.getCommit());
+    PushOneCommit.Result change = createChange("Change 1", "b", "b");
+    PushOneCommit.Result change2 = createChange("Change 2", "c", "c");
+    assertThat(change2.getCommit().getParent(0)).isEqualTo(change.getCommit());
 
-    // Submit succeeds; change3 is successfully cherry-picked onto head.
-    submit(change3.getChangeId());
-    RevCommit headAfterFirstSubmit = getRemoteHead();
-    // Submit succeeds; change2 is successfully cherry-picked onto head
-    // (which was change3's cherry-pick).
+    // Submit succeeds; change2 is successfully cherry-picked onto head.
     submit(change2.getChangeId());
+    RevCommit headAfterFirstSubmit = getRemoteHead();
+    // Submit succeeds; change is successfully cherry-picked onto head
+    // (which was change2's cherry-pick).
+    submit(change.getChangeId());
     RevCommit headAfterSecondSubmit = getRemoteHead();
 
-    // change2 is the new tip.
+    // change is the new tip.
     List<RevCommit> log = getRemoteLog();
     assertThat(log.get(0).getShortMessage()).isEqualTo(
-        change2.getCommit().getShortMessage());
+        change.getCommit().getShortMessage());
     assertThat(log.get(0).getParent(0)).isEqualTo(log.get(1));
 
     assertThat(log.get(1).getShortMessage()).isEqualTo(
-        change3.getCommit().getShortMessage());
+        change2.getCommit().getShortMessage());
     assertThat(log.get(1).getParent(0)).isEqualTo(log.get(2));
 
     assertThat(log.get(2).getId()).isEqualTo(initialHead.getId());
 
     assertRefUpdatedEvents(initialHead, headAfterFirstSubmit,
         headAfterFirstSubmit, headAfterSecondSubmit);
-    assertChangeMergedEvents(change3.getChangeId(), headAfterFirstSubmit.name(),
-        change2.getChangeId(), headAfterSecondSubmit.name());
+    assertChangeMergedEvents(change2.getChangeId(), headAfterFirstSubmit.name(),
+        change.getChangeId(), headAfterSecondSubmit.name());
   }
 
   @Test
@@ -271,25 +271,25 @@ public class SubmitByCherryPickIT extends AbstractSubmit {
     RevCommit initialHead = getRemoteHead();
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b1");
-    PushOneCommit.Result change3 = createChange("Change 3", "b", "b2");
-    assertThat(change3.getCommit().getParent(0)).isEqualTo(change2.getCommit());
+    PushOneCommit.Result change = createChange("Change 1", "b", "b1");
+    PushOneCommit.Result change2 = createChange("Change 2", "b", "b2");
+    assertThat(change2.getCommit().getParent(0)).isEqualTo(change.getCommit());
 
-    // Submit fails; change3 contains the delta "b1" -> "b2", which cannot be
+    // Submit fails; change2 contains the delta "b1" -> "b2", which cannot be
     // applied against tip.
-    submitWithConflict(change3.getChangeId(),
+    submitWithConflict(change2.getChangeId(),
         "Failed to submit 1 change due to the following problems:\n" +
-        "Change " + change3.getChange().getId() + ": Change could not be " +
+        "Change " + change2.getChange().getId() + ": Change could not be " +
         "merged due to a path conflict. Please rebase the change locally and " +
         "upload the rebased commit for review.");
 
-    ChangeInfo info3 = get(change3.getChangeId(), ListChangesOption.MESSAGES);
+    ChangeInfo info3 = get(change2.getChangeId(), ListChangesOption.MESSAGES);
     assertThat(info3.status).isEqualTo(ChangeStatus.NEW);
 
     // Tip has not changed.
     List<RevCommit> log = getRemoteLog();
     assertThat(log.get(0)).isEqualTo(initialHead.getId());
-    assertNoSubmitter(change3.getChangeId(), 1);
+    assertNoSubmitter(change2.getChangeId(), 1);
 
     assertRefUpdatedEvents();
     assertChangeMergedEvents();
@@ -300,21 +300,21 @@ public class SubmitByCherryPickIT extends AbstractSubmit {
     RevCommit initialHead = getRemoteHead();
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b");
-    PushOneCommit.Result change3 = createChange("Change 3", "c", "c");
-    PushOneCommit.Result change4 = createChange("Change 5", "e", "e");
+    PushOneCommit.Result change = createChange("Change 1", "b", "b");
+    PushOneCommit.Result change2 = createChange("Change 2", "c", "c");
+    PushOneCommit.Result change3 = createChange("Change 3", "e", "e");
 
-    // Out of the above, only submit 4. 2,3 are not related to 4
-    // by topic or ancestor (due to cherrypicking!)
-    approve(change3.getChangeId());
-    submit(change4.getChangeId());
+    // Out of the above, only submit change 3. Changes 1 and 2 are not
+    // related to change 3 by topic or ancestor (due to cherrypicking!)
+    approve(change2.getChangeId());
+    submit(change3.getChangeId());
     RevCommit newHead = getRemoteHead();
 
+    assertNew(change.getChangeId());
     assertNew(change2.getChangeId());
-    assertNew(change3.getChangeId());
 
     assertRefUpdatedEvents(initialHead, newHead);
-    assertChangeMergedEvents(change4.getChangeId(), newHead.name());
+    assertChangeMergedEvents(change3.getChangeId(), newHead.name());
   }
 
   @Test

gerrit-acceptance-tests/src/test/java/com/google/gerrit/acceptance/rest/change/SubmitByMergeAlwaysIT.java

@@ -51,33 +51,33 @@ public class SubmitByMergeAlwaysIT extends AbstractSubmitByMerge {
     RevCommit initialHead = getRemoteHead();
 
     // Submit a change so that the remote head advances
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b");
-    submit(change2.getChangeId());
+    PushOneCommit.Result change = createChange("Change 1", "b", "b");
+    submit(change.getChangeId());
 
     // The remote head should now be a merge of the previous head
-    // and "Change 2"
+    // and "Change 1"
     RevCommit headAfterFirstSubmit = getRemoteLog().get(0);
     assertThat(headAfterFirstSubmit.getParent(1).getShortMessage()).isEqualTo(
-        change2.getCommit().getShortMessage());
+        change.getCommit().getShortMessage());
     assertThat(headAfterFirstSubmit.getParent(0).getShortMessage()).isEqualTo(
         initialHead.getShortMessage());
     assertThat(headAfterFirstSubmit.getParent(0).getId()).isEqualTo(
         initialHead.getId());
 
     // Submit two changes at the same time
-    PushOneCommit.Result change3 = createChange("Change 3", "c", "c");
-    PushOneCommit.Result change4 = createChange("Change 4", "d", "d");
-    approve(change3.getChangeId());
-    submit(change4.getChangeId());
+    PushOneCommit.Result change2 = createChange("Change 2", "c", "c");
+    PushOneCommit.Result change3 = createChange("Change 3", "d", "d");
+    approve(change2.getChangeId());
+    submit(change3.getChangeId());
 
-    // Submitting change 4 should result in change 3 also being submitted
-    assertMerged(change3.getChangeId());
+    // Submitting change 3 should result in change 2 also being submitted
+    assertMerged(change2.getChangeId());
 
     // The remote head should now be a merge of the new head after
-    // the previous submit, and "Change 4".
+    // the previous submit, and "Change 3".
     RevCommit headAfterSecondSubmit = getRemoteLog().get(0);
     assertThat(headAfterSecondSubmit.getParent(1).getShortMessage()).isEqualTo(
-        change4.getCommit().getShortMessage());
+        change3.getCommit().getShortMessage());
     assertThat(headAfterSecondSubmit.getParent(0).getShortMessage()).isEqualTo(
         headAfterFirstSubmit.getShortMessage());
     assertThat(headAfterSecondSubmit.getParent(0).getId()).isEqualTo(
@@ -89,8 +89,8 @@ public class SubmitByMergeAlwaysIT extends AbstractSubmitByMerge {
     assertRefUpdatedEvents(initialHead, headAfterFirstSubmit,
         headAfterFirstSubmit, headAfterSecondSubmit);
     //TODO(dpursehouse) why are change-merged events in reverse order?
-    assertChangeMergedEvents(change2.getChangeId(), headAfterFirstSubmit.name(),
-        change4.getChangeId(), headAfterSecondSubmit.name(),
-        change3.getChangeId(), headAfterSecondSubmit.name());
+    assertChangeMergedEvents(change.getChangeId(), headAfterFirstSubmit.name(),
+        change3.getChangeId(), headAfterSecondSubmit.name(),
+        change2.getChangeId(), headAfterSecondSubmit.name());
   }
 }

gerrit-acceptance-tests/src/test/java/com/google/gerrit/acceptance/rest/change/SubmitByMergeIfNecessaryIT.java

@@ -49,51 +49,51 @@ public class SubmitByMergeIfNecessaryIT extends AbstractSubmitByMerge {
     RevCommit initialHead = getRemoteHead();
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change2 = createChange("Change 2", "b", "b");
+    PushOneCommit.Result change = createChange("Change 1", "b", "b");
 
     testRepo.reset(initialHead);
-    PushOneCommit.Result change3 = createChange("Change 3", "c", "c");
+    PushOneCommit.Result change2 = createChange("Change 2", "c", "c");
 
     testRepo.reset(initialHead);
+    PushOneCommit.Result change3 = createChange("Change 3", "d", "d");
     PushOneCommit.Result change4 = createChange("Change 4", "d", "d");
-    PushOneCommit.Result change5 = createChange("Change 5", "d", "d");
 
-    // Change 2 stays untouched.
-    approve(change2.getChangeId());
-    // Change 3 is a fast-forward, no need to merge.
-    submit(change3.getChangeId());
+    // First change stays untouched.
+    approve(change.getChangeId());
+    // Change 2 is a fast-forward, no need to merge.
+    submit(change2.getChangeId());
 
     RevCommit headAfterFirstSubmit = getRemoteLog().get(0);
     assertThat(headAfterFirstSubmit.getShortMessage()).isEqualTo(
-        change3.getCommit().getShortMessage());
+        change2.getCommit().getShortMessage());
     assertThat(headAfterFirstSubmit.getParent(0).getId()).isEqualTo(
         initialHead.getId());
     assertPersonEquals(admin.getIdent(), headAfterFirstSubmit.getAuthorIdent());
     assertPersonEquals(admin.getIdent(), headAfterFirstSubmit.getCommitterIdent());
 
-    // We need to merge changes 4 and 5.
-    approve(change4.getChangeId());
-    submit(change5.getChangeId());
+    // We need to merge changes 3 and 4.
+    approve(change3.getChangeId());
+    submit(change4.getChangeId());
 
     RevCommit headAfterSecondSubmit = getRemoteLog().get(0);
     assertThat(headAfterSecondSubmit.getParent(1).getShortMessage()).isEqualTo(
-        change5.getCommit().getShortMessage());
+        change4.getCommit().getShortMessage());
     assertThat(headAfterSecondSubmit.getParent(0).getShortMessage()).isEqualTo(
-        change3.getCommit().getShortMessage());
+        change2.getCommit().getShortMessage());
 
     assertPersonEquals(admin.getIdent(), headAfterSecondSubmit.getAuthorIdent());
     assertPersonEquals(serverIdent.get(), headAfterSecondSubmit.getCommitterIdent());
 
-    assertNew(change2.getChangeId());
+    assertNew(change.getChangeId());
 
     // The two submit operations should have resulted in two ref-update events
     // and three change-merged events.
     assertRefUpdatedEvents(initialHead, headAfterFirstSubmit,
         headAfterFirstSubmit, headAfterSecondSubmit);
     //TODO(dpursehouse) why are change-merged events in reverse order?
-    assertChangeMergedEvents(change3.getChangeId(), headAfterFirstSubmit.name(),
-        change5.getChangeId(), headAfterSecondSubmit.name(),
-        change4.getChangeId(), headAfterSecondSubmit.name());
+    assertChangeMergedEvents(change2.getChangeId(), headAfterFirstSubmit.name(),
+        change4.getChangeId(), headAfterSecondSubmit.name(),
+        change3.getChangeId(), headAfterSecondSubmit.name());
   }
 
   @Test
@@ -429,10 +429,10 @@ public class SubmitByMergeIfNecessaryIT extends AbstractSubmitByMerge {
         .create(new BranchInput());
 
     // Propose a change for master, but leave it open for master!
-    PushOneCommit change2 =
+    PushOneCommit change =
         pushFactory.create(db, user.getIdent(), testRepo,
             "small fix", "a.txt", "2");
-    PushOneCommit.Result change2result = change2.to("refs/for/master");
+    PushOneCommit.Result change2result = change.to("refs/for/master");
 
     // Now cherry pick to stable
     CherryPickInput in = new CherryPickInput();

gerrit-acceptance-tests/src/test/java/com/google/gerrit/acceptance/rest/change/SubmitByRebaseIfNecessaryIT.java

@@ -316,18 +316,18 @@ public class SubmitByRebaseIfNecessaryIT extends AbstractSubmit {
     PushOneCommit.Result change = createChange();
     approve(change.getChangeId());
 
-    PushOneCommit.Result change2nd = createChange();
-    approve(change2nd.getChangeId());
-    Project.NameKey project = change2nd.getChange().change().getProject();
+    PushOneCommit.Result change2 = createChange();
+    approve(change2.getChangeId());
+    Project.NameKey project = change2.getChange().change().getProject();
     Branch.NameKey branch = new Branch.NameKey(project, "branch");
-    createBranchWithRevision(branch, change2nd.getCommit().getName());
-    gApi.changes().id(change2nd.getChangeId()).current().submit();
-    assertMerged(change2nd.getChangeId());
+    createBranchWithRevision(branch, change2.getCommit().getName());
+    gApi.changes().id(change2.getChangeId()).current().submit();
+    assertMerged(change2.getChangeId());
     assertMerged(change.getChangeId());
 
     RevCommit newHead = getRemoteHead();
     assertRefUpdatedEvents(initialHead, newHead);
     assertChangeMergedEvents(change.getChangeId(), newHead.name(),
-        change2nd.getChangeId(), newHead.name());
+        change2.getChangeId(), newHead.name());
   }
 }