@Test
  public void testReadIndex_DirCacheTree() throws Exception {
    final Map<String, CGitIndexRecord> cList = readLsFiles();
    final Map<String, CGitLsTreeRecord> cTree = readLsTree();
    final DirCache dc = new DirCache(index, FS.DETECTED);
    assertEquals(0, dc.getEntryCount());
    dc.read();
    assertEquals(cList.size(), dc.getEntryCount());

    final DirCacheTree jTree = dc.getCacheTree(false);
    assertNotNull(jTree);
    assertEquals("", jTree.getNameString());
    assertEquals("", jTree.getPathString());
    assertTrue(jTree.isValid());
    assertEquals(
        ObjectId.fromString("698dd0b8d0c299f080559a1cffc7fe029479a408"), jTree.getObjectId());
    assertEquals(cList.size(), jTree.getEntrySpan());

    final ArrayList<CGitLsTreeRecord> subtrees = new ArrayList<CGitLsTreeRecord>();
    for (final CGitLsTreeRecord r : cTree.values()) {
      if (FileMode.TREE.equals(r.mode)) subtrees.add(r);
    }
    assertEquals(subtrees.size(), jTree.getChildCount());

    for (int i = 0; i < jTree.getChildCount(); i++) {
      final DirCacheTree sj = jTree.getChild(i);
      final CGitLsTreeRecord sc = subtrees.get(i);
      assertEquals(sc.path, sj.getNameString());
      assertEquals(sc.path + "/", sj.getPathString());
      assertTrue(sj.isValid());
      assertEquals(sc.id, sj.getObjectId());
    }
  }
 @Test
 public void testReadIndex_LsFiles() throws Exception {
   final Map<String, CGitIndexRecord> ls = readLsFiles();
   final DirCache dc = new DirCache(index, FS.DETECTED);
   assertEquals(0, dc.getEntryCount());
   dc.read();
   assertEquals(ls.size(), dc.getEntryCount());
   {
     final Iterator<CGitIndexRecord> rItr = ls.values().iterator();
     for (int i = 0; rItr.hasNext(); i++) assertEqual(rItr.next(), dc.getEntry(i));
   }
 }
예제 #3
0
  public void testNoPostOrder() throws Exception {
    final DirCache tree = db.readDirCache();
    {
      final DirCacheBuilder b = tree.builder();

      b.add(makeFile("a"));
      b.add(makeFile("b/c"));
      b.add(makeFile("b/d"));
      b.add(makeFile("q"));

      b.finish();
      assertEquals(4, tree.getEntryCount());
    }

    final TreeWalk tw = new TreeWalk(db);
    tw.reset();
    tw.setPostOrderTraversal(false);
    tw.addTree(new DirCacheIterator(tree));

    assertModes("a", REGULAR_FILE, tw);
    assertModes("b", TREE, tw);
    assertTrue(tw.isSubtree());
    assertFalse(tw.isPostChildren());
    tw.enterSubtree();
    assertModes("b/c", REGULAR_FILE, tw);
    assertModes("b/d", REGULAR_FILE, tw);
    assertModes("q", REGULAR_FILE, tw);
  }
 @Test
 public void testUnsupportedOptionalExtension() throws Exception {
   final DirCache dc = new DirCache(pathOf("gitgit.index.ZZZZ"), FS.DETECTED);
   dc.read();
   assertEquals(1, dc.getEntryCount());
   assertEquals("A", dc.getEntry(0).getPathString());
 }
예제 #5
0
  @Test
  public void testReadMissing_TempIndex() throws Exception {
    final File idx = new File(db.getDirectory(), "tmp_index");
    assertFalse(idx.exists());

    final DirCache dc = DirCache.read(idx, db.getFS());
    assertNotNull(dc);
    assertEquals(0, dc.getEntryCount());
  }
예제 #6
0
  @Test
  public void testBuildThenClear() throws Exception {
    final DirCache dc = db.readDirCache();

    final String[] paths = {"a-", "a.b", "a/b", "a0b"};
    final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
    for (int i = 0; i < paths.length; i++) {
      ents[i] = new DirCacheEntry(paths[i]);
      ents[i].setFileMode(FileMode.REGULAR_FILE);
    }

    final DirCacheBuilder b = dc.builder();
    for (int i = 0; i < ents.length; i++) b.add(ents[i]);
    b.finish();
    assertFalse(dc.hasUnmergedPaths());

    assertEquals(paths.length, dc.getEntryCount());
    dc.clear();
    assertEquals(0, dc.getEntryCount());
    assertFalse(dc.hasUnmergedPaths());
  }
  @Test
  public void testTreeWalk_LsFiles() throws Exception {
    final Repository db = createBareRepository();
    final Map<String, CGitIndexRecord> ls = readLsFiles();
    final DirCache dc = new DirCache(index, db.getFS());
    assertEquals(0, dc.getEntryCount());
    dc.read();
    assertEquals(ls.size(), dc.getEntryCount());
    {
      final Iterator<CGitIndexRecord> rItr = ls.values().iterator();
      final TreeWalk tw = new TreeWalk(db);
      tw.setRecursive(true);
      tw.addTree(new DirCacheIterator(dc));
      while (rItr.hasNext()) {
        final DirCacheIterator dcItr;

        assertTrue(tw.next());
        dcItr = tw.getTree(0, DirCacheIterator.class);
        assertNotNull(dcItr);

        assertEqual(rItr.next(), dcItr.getDirCacheEntry());
      }
    }
  }
  @Test
  public void testEntriesWithin() throws Exception {
    final DirCache dc = db.readDirCache();

    final String[] paths = {"a.", "a/b", "a/c", "a/d", "a0b"};
    final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
    for (int i = 0; i < paths.length; i++) {
      ents[i] = new DirCacheEntry(paths[i]);
      ents[i].setFileMode(FileMode.REGULAR_FILE);
    }
    final int aFirst = 1;
    final int aLast = 3;

    final DirCacheBuilder b = dc.builder();
    for (int i = 0; i < ents.length; i++) b.add(ents[i]);
    b.finish();

    assertEquals(paths.length, dc.getEntryCount());
    for (int i = 0; i < ents.length; i++) assertSame(ents[i], dc.getEntry(i));

    {
      final DirCacheEntry[] aContents = dc.getEntriesWithin("a");
      assertNotNull(aContents);
      assertEquals(aLast - aFirst + 1, aContents.length);
      for (int i = aFirst, j = 0; i <= aLast; i++, j++) assertSame(ents[i], aContents[j]);
    }
    {
      final DirCacheEntry[] aContents = dc.getEntriesWithin("a/");
      assertNotNull(aContents);
      assertEquals(aLast - aFirst + 1, aContents.length);
      for (int i = aFirst, j = 0; i <= aLast; i++, j++) assertSame(ents[i], aContents[j]);
    }
    {
      final DirCacheEntry[] aContents = dc.getEntriesWithin("");
      assertNotNull(aContents);
      assertEquals(ents.length, aContents.length);
      for (int i = 0; i < ents.length; i++) assertSame(ents[i], aContents[i]);
    }

    assertNotNull(dc.getEntriesWithin("a."));
    assertEquals(0, dc.getEntriesWithin("a.").length);

    assertNotNull(dc.getEntriesWithin("a0b"));
    assertEquals(0, dc.getEntriesWithin("a0b.").length);

    assertNotNull(dc.getEntriesWithin("zoo"));
    assertEquals(0, dc.getEntriesWithin("zoo.").length);
  }
예제 #9
0
  @Test
  public void testLockMissing_RealIndex() throws Exception {
    final File idx = new File(db.getDirectory(), "index");
    final File lck = new File(db.getDirectory(), "index.lock");
    assertFalse(idx.exists());
    assertFalse(lck.exists());

    final DirCache dc = db.lockDirCache();
    assertNotNull(dc);
    assertFalse(idx.exists());
    assertTrue(lck.exists());
    assertEquals(0, dc.getEntryCount());

    dc.unlock();
    assertFalse(idx.exists());
    assertFalse(lck.exists());
  }
예제 #10
0
 @Test
 public void testWriteEmptyReadEmpty_RealIndex() throws Exception {
   final File idx = new File(db.getDirectory(), "index");
   final File lck = new File(db.getDirectory(), "index.lock");
   assertFalse(idx.exists());
   assertFalse(lck.exists());
   {
     final DirCache dc = db.lockDirCache();
     dc.write();
     assertTrue(dc.commit());
     assertTrue(idx.exists());
   }
   {
     final DirCache dc = db.readDirCache();
     assertEquals(0, dc.getEntryCount());
   }
 }
  @Test
  public void testReadWriteV3() throws Exception {
    final File file = pathOf("gitgit.index.v3");
    final DirCache dc = new DirCache(file, FS.DETECTED);
    dc.read();

    assertEquals(10, dc.getEntryCount());
    assertV3TreeEntry(0, "dir1/file1.txt", false, false, dc);
    assertV3TreeEntry(1, "dir2/file2.txt", true, false, dc);
    assertV3TreeEntry(2, "dir3/file3.txt", false, false, dc);
    assertV3TreeEntry(3, "dir3/file3a.txt", true, false, dc);
    assertV3TreeEntry(4, "dir4/file4.txt", true, false, dc);
    assertV3TreeEntry(5, "dir4/file4a.txt", false, false, dc);
    assertV3TreeEntry(6, "file.txt", true, false, dc);
    assertV3TreeEntry(7, "newdir1/newfile1.txt", false, true, dc);
    assertV3TreeEntry(8, "newdir1/newfile2.txt", false, true, dc);
    assertV3TreeEntry(9, "newfile.txt", false, true, dc);

    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    dc.writeTo(bos);
    final byte[] indexBytes = bos.toByteArray();
    final byte[] expectedBytes = IO.readFully(file);
    assertArrayEquals(expectedBytes, indexBytes);
  }