C# DirCacheEntry.getPathString方法代码示例

        public void testCreate_ByStringPathAndStage()
        {
            DirCacheEntry e;

            e = new DirCacheEntry("a", 0);
            Assert.AreEqual("a", e.getPathString());
            Assert.AreEqual(0, e.getStage());

            e = new DirCacheEntry("a/b", 1);
            Assert.AreEqual("a/b", e.getPathString());
            Assert.AreEqual(1, e.getStage());

            e = new DirCacheEntry("a/c", 2);
            Assert.AreEqual("a/c", e.getPathString());
            Assert.AreEqual(2, e.getStage());

            e = new DirCacheEntry("a/d", 3);
            Assert.AreEqual("a/d", e.getPathString());
            Assert.AreEqual(3, e.getStage());

            try
            {
                new DirCacheEntry("/a", 1);
                Assert.Fail("Incorrectly created DirCacheEntry");
            }
            catch (ArgumentException err)
            {
                Assert.AreEqual("Invalid path: /a", err.Message);
            }

            try
            {
                new DirCacheEntry("a", -11);
                Assert.Fail("Incorrectly created DirCacheEntry");
            }
            catch (ArgumentException err)
            {
                Assert.AreEqual("Invalid stage -11 for path a", err.Message);
            }

            try
            {
                new DirCacheEntry("a", 4);
                Assert.Fail("Incorrectly created DirCacheEntry");
            }
            catch (ArgumentException err)
            {
                Assert.AreEqual("Invalid stage 4 for path a", err.Message);
            }
        }

        public void testFindSingleFile()
        {
            string path = "a-File-path";
            DirCache dc = DirCache.read(db);
            DirCacheBuilder b = dc.builder();
            Assert.IsNotNull(b);

            DirCacheEntry entOrig = new DirCacheEntry(path);
            Assert.AreNotSame(path, entOrig.getPathString());
            Assert.AreEqual(path, entOrig.getPathString());
            b.add(entOrig);
            b.finish();

            Assert.AreEqual(1, dc.getEntryCount());
            Assert.AreSame(entOrig, dc.getEntry(0));
            Assert.AreEqual(0, dc.findEntry(path));

            Assert.AreEqual(-1, dc.findEntry("@@-before"));
            Assert.AreEqual(0, real(dc.findEntry("@@-before")));

            Assert.AreEqual(-2, dc.findEntry("a-zoo"));
            Assert.AreEqual(1, real(dc.findEntry("a-zoo")));

            Assert.AreSame(entOrig, dc.getEntry(path));
        }

        public void testBuildOneFile_FinishWriteCommit()
        {
            string path = "a-File-path";
            var mode = GitSharp.Core.FileMode.RegularFile;
            long lastModified = 1218123387057L;
            int Length = 1342;
            DirCacheEntry entOrig;

            DirCache dc = DirCache.Lock(db);
            DirCacheBuilder b = dc.builder();
            Assert.IsNotNull(b);

            entOrig = new DirCacheEntry(path);
            entOrig.setFileMode(mode);
            entOrig.setLastModified(lastModified);
            entOrig.setLength(Length);

            Assert.AreNotSame(path, entOrig.getPathString());
            Assert.AreEqual(path, entOrig.getPathString());
            Assert.AreEqual(ObjectId.ZeroId, entOrig.getObjectId());
            Assert.AreEqual(mode.Bits, entOrig.getRawMode());
            Assert.AreEqual(0, entOrig.getStage());
            Assert.AreEqual(lastModified, entOrig.getLastModified());
            Assert.AreEqual(Length, entOrig.getLength());
            Assert.IsFalse(entOrig.isAssumeValid());
            b.add(entOrig);

            b.finish();
            Assert.AreEqual(1, dc.getEntryCount());
            Assert.AreSame(entOrig, dc.getEntry(0));

            dc.write();
            Assert.IsTrue(dc.commit());

            dc = DirCache.read(db);
            Assert.AreEqual(1, dc.getEntryCount());

            DirCacheEntry entRead = dc.getEntry(0);
            Assert.AreNotSame(entOrig, entRead);
            Assert.AreEqual(path, entRead.getPathString());
            Assert.AreEqual(ObjectId.ZeroId, entOrig.getObjectId());
            Assert.AreEqual(mode.Bits, entOrig.getRawMode());
            Assert.AreEqual(0, entOrig.getStage());
            Assert.AreEqual(lastModified, entOrig.getLastModified());
            Assert.AreEqual(Length, entOrig.getLength());
            Assert.IsFalse(entOrig.isAssumeValid());
        }

 /// <summary>
 /// Create a new unmerged path exception.
 /// </summary>
 /// <param name="entry">The first non-zero stage of the unmerged path.</param>
 /// <param name="inner">Inner Exception.</param>
 public UnmergedPathException(DirCacheEntry entry, Exception inner)
     : base("Unmerged path: " + entry.getPathString(), inner)
 {
     _entry = entry;
 }

        private static void AssertAreEqual(CGitIndexRecord c, DirCacheEntry j)
        {
            Assert.IsNotNull(c);
            Assert.IsNotNull(j);

            Assert.AreEqual(c.Path, j.getPathString());
            Assert.AreEqual(c.Id, j.getObjectId());
            Assert.AreEqual(c.Mode, j.getRawMode());
            Assert.AreEqual(c.Stage, j.getStage());
        }

 private static InvalidOperationException Bad(DirCacheEntry a, string msg)
 {
     return new InvalidOperationException(msg + ": " + a.getStage() + " " + a.getPathString());
 }

        /// <summary>
        /// Append one entry into the resulting entry list.
        /// <para />
        /// The entry is placed at the end of the entry list. If the entry causes the
        /// list to now be incorrectly sorted a final sorting phase will be
        /// automatically enabled within <seealso cref="finish()"/>.
        /// <para />
        /// The internal entry table is automatically expanded if there is
        /// insufficient space for the new addition.
        /// </summary>
        /// <param name="newEntry">the new entry to add.</param>
        public void add(DirCacheEntry newEntry)
        {
            if (newEntry.getRawMode() == 0)
            {
                throw new ArgumentException("FileMode not set for path "
                    + newEntry.getPathString());
            }

            BeforeAdd(newEntry);
            FastAdd(newEntry);
        }

    private void ApplyEdits()
    {
        _edits.Sort(EditComparison);

            int maxIdx = Cache.getEntryCount();
            int lastIdx = 0;
            foreach (PathEdit e in _edits)
            {
                int eIdx = Cache.findEntry(e.Path, e.Path.Length);
                bool missing = eIdx < 0;
                if (eIdx < 0)
                {
                    eIdx = -(eIdx + 1);
                }
                int cnt = Math.Min(eIdx, maxIdx) - lastIdx;
                if (cnt > 0)
                {
                    FastKeep(lastIdx, cnt);
                }
                lastIdx = missing ? eIdx : Cache.nextEntry(eIdx);

                if (e is DeletePath) continue;
                if (e is DeleteTree)
                {
                    lastIdx = Cache.nextEntry(e.Path, e.Path.Length, eIdx);
                    continue;
                }

                DirCacheEntry ent;
                if (missing)
                {
                    ent = new DirCacheEntry(e.Path);
                    e.Apply(ent);
                    if (ent.getRawMode() == 0)
                        throw new ArgumentException("FileMode not set"
                                + " for path " + ent.getPathString());
                }
                else
                {
                    ent = Cache.getEntry(eIdx);
                    e.Apply(ent);
                }
                FastAdd(ent);
            }

            int count = maxIdx - lastIdx;
            if (count > 0)
            {
                FastKeep(lastIdx, count);
            }
    }

        private void testLongPath(int len)
        {
            string longPath = makeLongPath(len);
            string shortPath = "~~~ shorter-path";

            DirCacheEntry longEnt = new DirCacheEntry(longPath);
            DirCacheEntry shortEnt = new DirCacheEntry(shortPath);

            longEnt.setFileMode(FileMode.RegularFile);
            shortEnt.setFileMode(FileMode.RegularFile);

            Assert.AreEqual(longPath, longEnt.getPathString());
            Assert.AreEqual(shortPath, shortEnt.getPathString());

            DirCache dc1 = DirCache.Lock(db);
            DirCacheBuilder b = dc1.builder();
            b.add(longEnt);
            b.add(shortEnt);
            Assert.IsTrue(b.commit());
            Assert.AreEqual(2, dc1.getEntryCount());
            Assert.AreSame(longEnt, dc1.getEntry(0));
            Assert.AreSame(shortEnt, dc1.getEntry(1));

            DirCache dc2 = DirCache.read(db);
            Assert.AreEqual(2, dc2.getEntryCount());
            Assert.AreNotSame(longEnt, dc2.getEntry(0));
            Assert.AreEqual(longPath, dc2.getEntry(0).getPathString());
            Assert.AreNotSame(shortEnt, dc2.getEntry(1));
            Assert.AreEqual(shortPath, dc2.getEntry(1).getPathString());
        }