Java Status类代码示例

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void shouldShowSuccessWhenPushSucceeds() throws Exception {
  XulMessageBox message = spy( new XulMessageBoxMock( XulDialogCallback.Status.ACCEPT ) );
  when( document.createElement( MESSAGEBOX ) ).thenReturn( message );
  doReturn( true ).when( uiGit ).hasRemote();
  PushResult result = mock( PushResult.class );
  doReturn( new URIish( "https://test.example.com" ) ).when( result ).getURI();
  RemoteRefUpdate update = mock( RemoteRefUpdate.class );
  when( update.getStatus() ).thenReturn( Status.OK );
  when( result.getRemoteUpdates() ).thenReturn( Arrays.asList( update ) );

  controller.push();
  controller.push( IVCS.TYPE_BRANCH );

  verify( uiGit ).push( "default" );
  verify( uiGit ).push( IVCS.TYPE_BRANCH );
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void testPullConflicts() throws Exception {
	pushOneFileToRemote();

	gitAccess.setRepository(SECOND_LOCAL_TEST_REPOSITORY);
	OptionsManager.getInstance().saveSelectedRepository(SECOND_LOCAL_TEST_REPOSITORY);
	File file = new File(SECOND_LOCAL_TEST_REPOSITORY + "/test.txt");
	file.createNewFile();
	
	PrintWriter out = new PrintWriter(LOCAL_TEST_REPOSITPRY + "/test.txt");
	out.println("teeeeeest");
	out.close();
	
	gitAccess.add(new FileStatus(GitChangeType.ADD, "test.txt"));
	gitAccess.commit("conflict");
	PushResponse pushResponse = gitAccess.push("", "");
	Status pushActual = pushResponse.getStatus();
	Status pushExpected = Status.REJECTED_NONFASTFORWARD;
	assertEquals(pushExpected, pushActual);
	
	PullResponse pullResponse = gitAccess.pull("", "");
	PullStatus pullActual = pullResponse.getStatus();
	PullStatus pullExpected = PullStatus.CONFLICTS;
	assertEquals(pullExpected, pullActual);
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void testVisualDiff() throws Exception {
  XulMessageBox message = spy( new XulMessageBoxMock( XulDialogCallback.Status.ACCEPT ) );
  when( document.createElement( MESSAGEBOX ) ).thenReturn( message );
  UIFile file = new UIFile( "test.txt", ChangeType.MODIFY, true );
  doReturn( Collections.singletonList( file ) ).when( controller ).getSelectedChangedFiles();
  controller.visualdiff();
  verify( message ).setTitle( BaseMessages.getString( PKG, "Dialog.Error" ) );

  // .ktr
  file = new UIFile( "test.ktr", ChangeType.MODIFY, true );
  doReturn( Collections.singletonList( file ) ).when( controller ).getSelectedChangedFiles();
  doReturn( new FileInputStream( new File( "src/test/resources/r1.ktr" ) ) ).when( uiGit ).open( "test.ktr", Constants.HEAD );
  doReturn( new FileInputStream( new File( "src/test/resources/r2.ktr" ) ) ).when( uiGit ).open( "test.ktr", IVCS.WORKINGTREE );
  controller.visualdiff();
  verify( uiGit ).open( "test.ktr", Constants.HEAD );
  verify( uiGit ).open( "test.ktr", IVCS.WORKINGTREE );
  verify( controller ).loadMainPerspective();

  // conflicted ktr
  file = new UIFile( "test.kjb.ours", ChangeType.ADD, false );
  File dir = File.createTempFile( "git_test_", "_controller" );
  dir.delete();
  dir.mkdir();
  File ours = new File( dir.getPath(), "test.kjb.ours" );
  File theirs = new File( dir.getPath(), "test.kjb.theirs" );
  FileUtils.copyFile( new File( "src/test/resources/r1.kjb" ), ours );
  FileUtils.copyFile( new File( "src/test/resources/r2.kjb" ), theirs );
  doReturn( dir.getPath() ).when( uiGit ).getDirectory();
  doReturn( Collections.singletonList( file ) ).when( controller ).getSelectedChangedFiles();
  doReturn( new FileInputStream( ours ) ).when( uiGit ).open( "test.kjb.ours", IVCS.WORKINGTREE );
  doReturn( new FileInputStream( theirs ) ).when( uiGit ).open( "test.kjb.theirs", IVCS.WORKINGTREE );
  controller.visualdiff();
  FileUtils.deleteDirectory( dir );
  verify( uiGit ).open( "test.kjb.ours", IVCS.WORKINGTREE );
  verify( uiGit ).open( "test.kjb.theirs", IVCS.WORKINGTREE );
  verify( controller, times( 2 ) ).loadMainPerspective();
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
public void assertChange(
    Change.Status expectedStatus,
    String expectedTopic,
    List<TestAccount> expectedReviewers,
    List<TestAccount> expectedCcs)
    throws OrmException {
  Change c = getChange().change();
  assertThat(c.getSubject()).isEqualTo(resSubj);
  assertThat(c.getStatus()).isEqualTo(expectedStatus);
  assertThat(Strings.emptyToNull(c.getTopic())).isEqualTo(expectedTopic);
  if (notesMigration.readChanges()) {
    assertReviewers(c, ReviewerStateInternal.REVIEWER, expectedReviewers);
    assertReviewers(c, ReviewerStateInternal.CC, expectedCcs);
  } else {
    assertReviewers(
        c,
        ReviewerStateInternal.REVIEWER,
        Stream.concat(expectedReviewers.stream(), expectedCcs.stream()).collect(toList()));
  }
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
protected ObjectId pushChangeTo(
    TestRepository<?> repo, String ref, String file, String content, String message, String topic)
    throws Exception {
  ObjectId ret =
      repo.branch("HEAD").commit().insertChangeId().message(message).add(file, content).create();

  String pushedRef = ref;
  if (!topic.isEmpty()) {
    pushedRef += "/" + name(topic);
  }
  String refspec = "HEAD:" + pushedRef;

  Iterable<PushResult> res =
      repo.git().push().setRemote("origin").setRefSpecs(new RefSpec(refspec)).call();

  RemoteRefUpdate u = Iterables.getOnlyElement(res).getRemoteUpdate(pushedRef);
  assertThat(u).isNotNull();
  assertThat(u.getStatus()).isEqualTo(Status.OK);
  assertThat(u.getNewObjectId()).isEqualTo(ret);

  return ret;
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
protected ObjectId pushChangesTo(TestRepository<?> repo, String branch, int numChanges)
    throws Exception {
  for (int i = 0; i < numChanges; i++) {
    repo.branch("HEAD")
        .commit()
        .insertChangeId()
        .message("Message " + i)
        .add(name("file"), "content" + i)
        .create();
  }
  String remoteBranch = "refs/heads/" + branch;
  Iterable<PushResult> res =
      repo.git()
          .push()
          .setRemote("origin")
          .setRefSpecs(new RefSpec("HEAD:" + remoteBranch))
          .call();
  List<Status> status =
      StreamSupport.stream(res.spliterator(), false)
          .map(r -> r.getRemoteUpdate(remoteBranch).getStatus())
          .collect(toList());
  assertThat(status).containsExactly(Status.OK);
  return Iterables.getLast(res).getRemoteUpdate(remoteBranch).getNewObjectId();
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void createAndDeleteBranchByPush() throws Exception {
  grant(project, "refs/*", Permission.PUSH, true);
  projectIndexedCounter.clear();

  assertThat(getRemoteHead(project.get(), "foo")).isNull();

  PushOneCommit.Result r = pushTo("refs/heads/foo");
  r.assertOkStatus();
  assertThat(getRemoteHead(project.get(), "foo")).isEqualTo(r.getCommit());
  projectIndexedCounter.assertNoReindex();

  PushResult r2 = GitUtil.pushOne(testRepo, null, "refs/heads/foo", false, true, null);
  assertThat(r2.getRemoteUpdate("refs/heads/foo").getStatus()).isEqualTo(Status.OK);
  assertThat(getRemoteHead(project.get(), "foo")).isNull();
  projectIndexedCounter.assertNoReindex();
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void fastForward() throws Exception {
  allowTagCreation();
  String tagName = pushTagForExistingCommit(Status.OK);

  fastForwardTagToExistingCommit(tagName, Status.REJECTED_OTHER_REASON);
  fastForwardTagToNewCommit(tagName, Status.REJECTED_OTHER_REASON);

  allowTagDeletion();
  fastForwardTagToExistingCommit(tagName, Status.REJECTED_OTHER_REASON);
  fastForwardTagToNewCommit(tagName, Status.REJECTED_OTHER_REASON);

  allowPushOnRefsTags();
  Status expectedStatus = tagType == ANNOTATED ? Status.REJECTED_OTHER_REASON : Status.OK;
  fastForwardTagToExistingCommit(tagName, expectedStatus);
  fastForwardTagToNewCommit(tagName, expectedStatus);

  allowForcePushOnRefsTags();
  fastForwardTagToExistingCommit(tagName, Status.OK);
  fastForwardTagToNewCommit(tagName, Status.OK);

  removePushFromRefsTags();
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void forceUpdate() throws Exception {
  allowTagCreation();
  String tagName = pushTagForExistingCommit(Status.OK);

  forceUpdateTagToExistingCommit(tagName, Status.REJECTED_OTHER_REASON);
  forceUpdateTagToNewCommit(tagName, Status.REJECTED_OTHER_REASON);

  allowPushOnRefsTags();
  forceUpdateTagToExistingCommit(tagName, Status.REJECTED_OTHER_REASON);
  forceUpdateTagToNewCommit(tagName, Status.REJECTED_OTHER_REASON);

  allowTagDeletion();
  forceUpdateTagToExistingCommit(tagName, Status.REJECTED_OTHER_REASON);
  forceUpdateTagToNewCommit(tagName, Status.REJECTED_OTHER_REASON);

  allowForcePushOnRefsTags();
  forceUpdateTagToExistingCommit(tagName, Status.OK);
  forceUpdateTagToNewCommit(tagName, Status.OK);

  removePushFromRefsTags();
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void delete() throws Exception {
  allowTagCreation();
  String tagName = pushTagForExistingCommit(Status.OK);

  pushTagDeletion(tagName, Status.REJECTED_OTHER_REASON);

  allowPushOnRefsTags();
  pushTagDeletion(tagName, Status.REJECTED_OTHER_REASON);

  allowForcePushOnRefsTags();
  tagName = pushTagForExistingCommit(Status.OK);
  pushTagDeletion(tagName, Status.OK);

  removePushFromRefsTags();
  allowTagDeletion();
  tagName = pushTagForExistingCommit(Status.OK);
  pushTagDeletion(tagName, Status.OK);
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void pushToExternalIdsBranch() throws Exception {
  TestRepository<InMemoryRepository> allUsersRepo = cloneProject(allUsers);
  fetch(allUsersRepo, RefNames.REFS_EXTERNAL_IDS + ":" + RefNames.REFS_EXTERNAL_IDS);
  allUsersRepo.reset(RefNames.REFS_EXTERNAL_IDS);

  // different case email is allowed
  ExternalId newExtId = createExternalIdWithOtherCaseEmail("foo:bar");
  addExtId(allUsersRepo, newExtId);
  allUsersRepo.reset(RefNames.REFS_EXTERNAL_IDS);

  List<AccountExternalIdInfo> extIdsBefore = gApi.accounts().self().getExternalIds();

  allowPushOfExternalIds();
  PushResult r = pushHead(allUsersRepo, RefNames.REFS_EXTERNAL_IDS);
  assertThat(r.getRemoteUpdate(RefNames.REFS_EXTERNAL_IDS).getStatus()).isEqualTo(Status.OK);

  List<AccountExternalIdInfo> extIdsAfter = gApi.accounts().self().getExternalIds();
  assertThat(extIdsAfter)
      .containsExactlyElementsIn(
          Iterables.concat(extIdsBefore, ImmutableSet.of(toExternalIdInfo(newExtId))));
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void shouldInitializeGitOnAccept() throws Exception {
  XulConfirmBox confirm = new XulConfirmBoxMock( XulDialogCallback.Status.ACCEPT );
  when( document.createElement( CONFIRMBOX ) ).thenReturn( confirm );
  XulMessageBox message = new XulMessageBoxMock( XulDialogCallback.Status.ACCEPT );
  when( document.createElement( MESSAGEBOX ) ).thenReturn( message );

  controller.initGit( "random-path" );

  verify( uiGit ).initRepo( anyString() );
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void shouldNotInitializeGitOnCencel() throws Exception {
  XulConfirmBox confirm = new XulConfirmBoxMock( XulDialogCallback.Status.CANCEL );
  when( document.createElement( CONFIRMBOX ) ).thenReturn( confirm );

  controller.initGit( "random-path" );

  verify( uiGit, never() ).initRepo( anyString() );
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void shouldNotCommitWhenNoStagedObjects() throws Exception {
  XulMessageBox message = new XulMessageBoxMock( XulDialogCallback.Status.ACCEPT );
  when( document.createElement( MESSAGEBOX ) ).thenReturn( message );
  doReturn( false ).when( uiGit ).hasStagedFiles();

  controller.commit();

  verify( uiGit, never() ).commit( any(), anyString() );
}
 

import org.eclipse.jgit.transport.RemoteRefUpdate.Status; //导入依赖的package包/类
@Test
public void shouldCommit() throws Exception {
  XulMessageBox message = new XulMessageBoxMock( XulDialogCallback.Status.ACCEPT );
  when( document.getElementById( MESSAGEBOX ) ).thenReturn( message );
  doReturn( true ).when( uiGit ).hasStagedFiles();

  controller.commit();

  verify( uiGit ).commit( any(), anyString() );
}