Exemple #1
0
  private void checkoutTwoTrees() throws FileNotFoundException, IOException {
    for (String path : removed) {
      index.remove(root, new File(root, path));
    }

    for (java.util.Map.Entry<String, ObjectId> entry : updated.entrySet()) {
      Entry newEntry = index.addEntry(merge.findBlobMember(entry.getKey()));
      index.checkoutEntry(root, newEntry);
    }
  }
Exemple #2
0
  public void testCreateEmptyIndex() throws Exception {
    GitIndex index = new GitIndex(db);
    index.write();
    // native git doesn't like an empty index
    // assertEquals(0,system(trash,"git status"));

    GitIndex indexr = new GitIndex(db);
    indexr.read();
    assertEquals(0, indexr.getMembers().length);
  }
Exemple #3
0
  private GitIndex buildIndex(HashMap<String, String> indexEntries) throws IOException {
    GitIndex index = new GitIndex(db);

    if (indexEntries == null) return index;
    for (java.util.Map.Entry<String, String> e : indexEntries.entrySet()) {
      index.add(trash, writeTrashFile(e.getKey(), e.getValue())).forceRecheck();
    }

    return index;
  }
Exemple #4
0
  public void testCheckout() throws Exception {
    // Prepare tree, remote it and checkout
    GitIndex index = new GitIndex(db);
    File aslashb = writeTrashFile("a/b", "data:a/b");
    File acolonb = writeTrashFile("a:b", "data:a:b");
    File adotb = writeTrashFile("a.b", "data:a.b");
    index.add(trash, aslashb);
    index.add(trash, acolonb);
    index.add(trash, adotb);
    index.write();
    index.writeTree();
    delete(aslashb);
    delete(acolonb);
    delete(adotb);
    delete(aslashb.getParentFile());

    GitIndex index2 = new GitIndex(db);
    assertEquals(0, index2.getMembers().length);

    index2.readTree(db.mapTree(ObjectId.fromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));

    index2.checkout(trash);
    assertEquals("data:a/b", content(aslashb));
    assertEquals("data:a:b", content(acolonb));
    assertEquals("data:a.b", content(adotb));

    if (canrungitstatus) assertEquals(0, system(trash, "git status"));
  }
Exemple #5
0
 public void testUpdateSimpleSortTestIndex() throws Exception {
   GitIndex index = new GitIndex(db);
   writeTrashFile("a/b", "data:a/b");
   writeTrashFile("a:b", "data:a:b");
   writeTrashFile("a.b", "data:a.b");
   index.add(trash, new File(trash, "a/b"));
   index.add(trash, new File(trash, "a:b"));
   index.add(trash, new File(trash, "a.b"));
   writeTrashFile("a/b", "data:a/b modified");
   index.add(trash, new File(trash, "a/b"));
   index.write();
   if (canrungitstatus) assertEquals(0, system(trash, "git status"));
 }
Exemple #6
0
 WorkDirCheckout(Repository repo, File workDir, GitIndex oldIndex, GitIndex newIndex)
     throws IOException {
   this.repo = repo;
   this.root = workDir;
   this.index = oldIndex;
   this.merge = repo.mapTree(newIndex.writeTree());
 }
Exemple #7
0
  public void testDirectoryFileSimple() throws IOException {
    theIndex = new GitIndex(db);
    theIndex.add(trash, writeTrashFile("DF", "DF"));
    Tree treeDF = db.mapTree(theIndex.writeTree());

    recursiveDelete(new File(trash, "DF"));
    theIndex = new GitIndex(db);
    theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF"));
    Tree treeDFDF = db.mapTree(theIndex.writeTree());

    theIndex = new GitIndex(db);
    recursiveDelete(new File(trash, "DF"));

    theIndex.add(trash, writeTrashFile("DF", "DF"));
    theReadTree = getCheckoutImpl(treeDF, theIndex, treeDFDF);
    theReadTree.prescanTwoTrees();

    assertTrue(theReadTree.removed().contains("DF"));
    assertTrue(theReadTree.updated().containsKey("DF/DF"));

    recursiveDelete(new File(trash, "DF"));
    theIndex = new GitIndex(db);
    theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF"));

    theReadTree = getCheckoutImpl(treeDFDF, theIndex, treeDF);
    theReadTree.prescanTwoTrees();
    assertTrue(theReadTree.removed().contains("DF/DF"));
    assertTrue(theReadTree.updated().containsKey("DF"));
  }
Exemple #8
0
  void prescanTwoTrees() throws IOException {
    new IndexTreeWalker(
            index,
            head,
            merge,
            root,
            new AbstractIndexTreeVisitor() {
              public void visitEntry(
                  TreeEntry treeEntry, TreeEntry auxEntry, Entry indexEntry, File file)
                  throws IOException {
                if (treeEntry instanceof Tree || auxEntry instanceof Tree) {
                  throw new IllegalArgumentException(JGitText.get().cantPassMeATree);
                }
                processEntry(treeEntry, auxEntry, indexEntry);
              }

              @Override
              public void finishVisitTree(Tree tree, Tree auxTree, String curDir)
                  throws IOException {
                if (curDir.length() == 0) return;

                if (auxTree != null) {
                  if (index.getEntry(curDir) != null) removed.add(curDir);
                }
              }
            })
        .walk();

    // if there's a conflict, don't list it under
    // to-be-removed, since that messed up our next
    // section
    removed.removeAll(conflicts);

    for (String path : updated.keySet()) {
      if (index.getEntry(path) == null) {
        File file = new File(root, path);
        if (file.isFile()) conflicts.add(path);
        else if (file.isDirectory()) {
          checkConflictsWithFile(file);
        }
      }
    }

    conflicts.removeAll(removed);
  }
Exemple #9
0
  public void testWriteTree() throws Exception {
    GitIndex index = new GitIndex(db);
    writeTrashFile("a/b", "data:a/b");
    writeTrashFile("a:b", "data:a:b");
    writeTrashFile("a.b", "data:a.b");
    index.add(trash, new File(trash, "a/b"));
    index.add(trash, new File(trash, "a:b"));
    index.add(trash, new File(trash, "a.b"));
    index.write();

    ObjectId id = index.writeTree();
    assertEquals("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.name());

    writeTrashFile("a/b", "data:a/b");
    index.add(trash, new File(trash, "a/b"));

    if (canrungitstatus) assertEquals(0, system(trash, "git status"));
  }
Exemple #10
0
  public void test031_executeBit_coreModeFalse()
      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, Error,
          Exception {
    try {
      // coremode true is the default, typically set to false
      // by git init (but not jgit!)
      Method canExecute = File.class.getMethod("canExecute", (Class[]) null);
      Method setExecute = File.class.getMethod("setExecutable", new Class[] {Boolean.TYPE});
      File execFile = writeTrashFile("exec", "exec");
      if (!((Boolean) setExecute.invoke(execFile, new Object[] {Boolean.TRUE})).booleanValue())
        throw new Error("could not set execute bit on " + execFile.getAbsolutePath() + "for test");
      File nonexecFile = writeTrashFile("nonexec", "nonexec");
      if (!((Boolean) setExecute.invoke(nonexecFile, new Object[] {Boolean.FALSE})).booleanValue())
        throw new Error(
            "could not clear execute bit on " + nonexecFile.getAbsolutePath() + "for test");

      GitIndex index = new GitIndex(db);
      index.filemode = Boolean.FALSE; // TODO: we need a way to set this using config
      index.add(trash, execFile);
      index.add(trash, nonexecFile);
      Tree tree = db.mapTree(index.writeTree());
      assertEquals(FileMode.REGULAR_FILE, tree.findBlobMember(execFile.getName()).getMode());
      assertEquals(FileMode.REGULAR_FILE, tree.findBlobMember(nonexecFile.getName()).getMode());

      index.write();

      if (!execFile.delete())
        throw new Error("Problem in test, cannot delete test file " + execFile.getAbsolutePath());
      if (!nonexecFile.delete())
        throw new Error(
            "Problem in test, cannot delete test file " + nonexecFile.getAbsolutePath());
      GitIndex index2 = new GitIndex(db);
      index2.filemode = Boolean.FALSE; // TODO: we need a way to set this using config
      index2.read();
      index2.checkout(trash);
      assertFalse(((Boolean) canExecute.invoke(execFile, (Object[]) null)).booleanValue());
      assertFalse(((Boolean) canExecute.invoke(nonexecFile, (Object[]) null)).booleanValue());

      assertFalse(index2.getEntry(execFile.getName()).isModified(trash));
      assertFalse(index2.getEntry(nonexecFile.getName()).isModified(trash));

      if (!((Boolean) setExecute.invoke(execFile, new Object[] {Boolean.FALSE})).booleanValue())
        throw new Error(
            "could not clear set execute bit on " + execFile.getAbsolutePath() + "for test");
      if (!((Boolean) setExecute.invoke(nonexecFile, new Object[] {Boolean.TRUE})).booleanValue())
        throw new Error("could set execute bit on " + nonexecFile.getAbsolutePath() + "for test");

      // no change since we ignore the execute bit
      assertFalse(index2.getEntry(execFile.getName()).isModified(trash));
      assertFalse(index2.getEntry(nonexecFile.getName()).isModified(trash));

    } catch (NoSuchMethodException e) {
      System.err.println("Test ignored when running under JDK < 1.6");
      return;
    }
  }
Exemple #11
0
  public void testDelete() throws Exception {
    GitIndex index = new GitIndex(db);
    writeTrashFile("a/b", "data:a/b");
    writeTrashFile("a:b", "data:a:b");
    writeTrashFile("a.b", "data:a.b");
    index.add(trash, new File(trash, "a/b"));
    index.add(trash, new File(trash, "a:b"));
    index.add(trash, new File(trash, "a.b"));
    index.write();
    index.writeTree();
    index.remove(trash, new File(trash, "a:b"));
    index.write();
    assertEquals("a.b", index.getMembers()[0].getName());
    assertEquals("a/b", index.getMembers()[1].getName());

    GitIndex indexr = new GitIndex(db);
    indexr.read();
    assertEquals("a.b", indexr.getMembers()[0].getName());
    assertEquals("a/b", indexr.getMembers()[1].getName());

    if (canrungitstatus) assertEquals(0, system(trash, "git status"));
  }
Exemple #12
0
  public void testReadTree2() throws Exception {
    // Prepare a larger tree to test some odd cases in tree writing
    GitIndex index = new GitIndex(db);
    File f1 = writeTrashFile("a/a/a/a", "data:a/a/a/a");
    File f2 = writeTrashFile("a/c/c", "data:a/c/c");
    File f3 = writeTrashFile("a/b", "data:a/b");
    File f4 = writeTrashFile("a:b", "data:a:b");
    File f5 = writeTrashFile("a/d", "data:a/d");
    File f6 = writeTrashFile("a.b", "data:a.b");
    index.add(trash, f1);
    index.add(trash, f2);
    index.add(trash, f3);
    index.add(trash, f4);
    index.add(trash, f5);
    index.add(trash, f6);
    index.write();
    ObjectId id = index.writeTree();
    System.out.println("wrote id " + id);
    assertEquals("ba78e065e2c261d4f7b8f42107588051e87e18e9", id.name());
    GitIndex index2 = new GitIndex(db);

    index2.readTree(db.mapTree(ObjectId.fromString("ba78e065e2c261d4f7b8f42107588051e87e18e9")));
    Entry[] members = index2.getMembers();
    assertEquals(6, members.length);
    assertEquals("a.b", members[0].getName());
    assertEquals("a/a/a/a", members[1].getName());
    assertEquals("a/b", members[2].getName());
    assertEquals("a/c/c", members[3].getName());
    assertEquals("a/d", members[4].getName());
    assertEquals("a:b", members[5].getName());

    // reread and test
    GitIndex indexr = new GitIndex(db);
    indexr.read();
    Entry[] membersr = indexr.getMembers();
    assertEquals(6, membersr.length);
    assertEquals("a.b", membersr[0].getName());
    assertEquals("a/a/a/a", membersr[1].getName());
    assertEquals("a/b", membersr[2].getName());
    assertEquals("a/c/c", membersr[3].getName());
    assertEquals("a/d", membersr[4].getName());
    assertEquals("a:b", membersr[5].getName());
  }
Exemple #13
0
  public void testReadTree() throws Exception {
    // Prepare tree
    GitIndex index = new GitIndex(db);
    writeTrashFile("a/b", "data:a/b");
    writeTrashFile("a:b", "data:a:b");
    writeTrashFile("a.b", "data:a.b");
    index.add(trash, new File(trash, "a/b"));
    index.add(trash, new File(trash, "a:b"));
    index.add(trash, new File(trash, "a.b"));
    index.write();

    ObjectId id = index.writeTree();
    System.out.println("wrote id " + id);
    assertEquals("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.name());
    GitIndex index2 = new GitIndex(db);

    index2.readTree(db.mapTree(ObjectId.fromString("c696abc3ab8e091c665f49d00eb8919690b3aec3")));
    Entry[] members = index2.getMembers();
    assertEquals(3, members.length);
    assertEquals("a.b", members[0].getName());
    assertEquals("a/b", members[1].getName());
    assertEquals("a:b", members[2].getName());
    assertEquals(3, members.length);

    GitIndex indexr = new GitIndex(db);
    indexr.read();
    Entry[] membersr = indexr.getMembers();
    assertEquals(3, membersr.length);
    assertEquals("a.b", membersr[0].getName());
    assertEquals("a/b", membersr[1].getName());
    assertEquals("a:b", membersr[2].getName());
    assertEquals(3, membersr.length);

    if (canrungitstatus) assertEquals(0, system(trash, "git status"));
  }
Exemple #14
0
  public void testCreateSimpleSortTestIndex() throws Exception {
    GitIndex index = new GitIndex(db);
    writeTrashFile("a/b", "data:a/b");
    writeTrashFile("a:b", "data:a:b");
    writeTrashFile("a.b", "data:a.b");
    index.add(trash, new File(trash, "a/b"));
    index.add(trash, new File(trash, "a:b"));
    index.add(trash, new File(trash, "a.b"));
    index.write();

    assertEquals("a/b", index.getEntry("a/b").getName());
    assertEquals("a:b", index.getEntry("a:b").getName());
    assertEquals("a.b", index.getEntry("a.b").getName());
    assertNull(index.getEntry("a*b"));

    // Repeat test for re-read index
    GitIndex indexr = new GitIndex(db);
    indexr.read();
    assertEquals("a/b", indexr.getEntry("a/b").getName());
    assertEquals("a:b", indexr.getEntry("a:b").getName());
    assertEquals("a.b", indexr.getEntry("a.b").getName());
    assertNull(indexr.getEntry("a*b"));

    if (canrungitstatus) assertEquals(0, system(trash, "git status"));
  }
Exemple #15
0
 public void testReadWithNoIndex() throws Exception {
   GitIndex index = new GitIndex(db);
   index.read();
   assertEquals(0, index.getMembers().length);
 }
Exemple #16
0
  // for these rules, they all have clean yes/no options
  // but it doesn't matter if the entry is clean or not
  // so we can just ignore the state in the filesystem entirely
  public void testRules4thru13_IndexEntryNotInHead() throws IOException {
    // rules 4 and 5
    HashMap<String, String> idxMap;

    idxMap = new HashMap<String, String>();
    idxMap.put("foo", "foo");
    setupCase(null, null, idxMap);
    theReadTree = go();

    assertTrue(theReadTree.updated().isEmpty());
    assertTrue(theReadTree.removed().isEmpty());
    assertTrue(theReadTree.conflicts().isEmpty());

    // rules 6 and 7
    idxMap = new HashMap<String, String>();
    idxMap.put("foo", "foo");
    setupCase(null, idxMap, idxMap);
    theReadTree = go();

    assertAllEmpty();

    // rules 8 and 9
    HashMap<String, String> mergeMap;
    mergeMap = new HashMap<String, String>();

    mergeMap.put("foo", "merge");
    setupCase(null, mergeMap, idxMap);
    go();

    assertTrue(theReadTree.updated().isEmpty());
    assertTrue(theReadTree.removed().isEmpty());
    assertTrue(theReadTree.conflicts().contains("foo"));

    // rule 10

    HashMap<String, String> headMap = new HashMap<String, String>();
    headMap.put("foo", "foo");
    setupCase(headMap, null, idxMap);
    go();

    assertTrue(theReadTree.removed().contains("foo"));
    assertTrue(theReadTree.updated().isEmpty());
    assertTrue(theReadTree.conflicts().isEmpty());

    // rule 11
    setupCase(headMap, null, idxMap);
    new File(trash, "foo").delete();
    writeTrashFile("foo", "bar");
    theIndex.getMembers()[0].forceRecheck();
    go();

    assertTrue(theReadTree.removed().isEmpty());
    assertTrue(theReadTree.updated().isEmpty());
    assertTrue(theReadTree.conflicts().contains("foo"));

    // rule 12 & 13
    headMap.put("foo", "head");
    setupCase(headMap, null, idxMap);
    go();

    assertTrue(theReadTree.removed().isEmpty());
    assertTrue(theReadTree.updated().isEmpty());
    assertTrue(theReadTree.conflicts().contains("foo"));

    // rules 14 & 15
    setupCase(headMap, headMap, idxMap);
    go();

    assertAllEmpty();

    // rules 16 & 17
    setupCase(headMap, mergeMap, idxMap);
    go();
    assertTrue(theReadTree.conflicts().contains("foo"));

    // rules 18 & 19
    setupCase(headMap, idxMap, idxMap);
    go();
    assertAllEmpty();

    // rule 20
    setupCase(idxMap, mergeMap, idxMap);
    go();
    assertTrue(theReadTree.updated().containsKey("foo"));

    // rules 21
    setupCase(idxMap, mergeMap, idxMap);
    new File(trash, "foo").delete();
    writeTrashFile("foo", "bar");
    theIndex.getMembers()[0].forceRecheck();
    go();
    assertTrue(theReadTree.conflicts().contains("foo"));
  }