← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/ngit/NGit.Test/NGit.Storage.File/RefDirectoryTest.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/ngit/NGit.Test/NGit.Storage.File/RefDirectoryTest.cs
57
57
        {
58
58
                private Repository diskRepo;
59
59
 
60
 
                private TestRepository repo;
 
60
                private TestRepository<Repository> repo;
61
61
 
62
62
                private RefDirectory refdir;
63
63
 
324
324
 
325
325
                /// <exception cref="System.IO.IOException"></exception>
326
326
                [NUnit.Framework.Test]
 
327
                public virtual void TestReadNotExistingBranchConfig()
 
328
                {
 
329
                        NUnit.Framework.Assert.IsNull(refdir.GetRef("config"), "find branch config");
 
330
                        NUnit.Framework.Assert.IsNull(refdir.GetRef("refs/heads/config"), "find branch config"
 
331
                                );
 
332
                }
 
333
 
 
334
                /// <exception cref="System.IO.IOException"></exception>
 
335
                [NUnit.Framework.Test]
 
336
                public virtual void TestReadBranchConfig()
 
337
                {
 
338
                        WriteLooseRef("refs/heads/config", A);
 
339
                        NUnit.Framework.Assert.IsNotNull(refdir.GetRef("config"), "find branch config");
 
340
                }
 
341
 
 
342
                /// <exception cref="System.IO.IOException"></exception>
 
343
                [NUnit.Framework.Test]
327
344
                public virtual void TestGetRefs_HeadsOnly_AllLoose()
328
345
                {
329
346
                        IDictionary<string, Ref> heads;
436
453
                        WriteLooseRef("refs/heads/my/a/b/c", B);
437
454
                        int[] count = new int[1];
438
455
                        ListenerHandle listener = Repository.GetGlobalListenerList().AddRefsChangedListener
439
 
                                (new _RefsChangedListener_481(count));
 
456
                                (new _RefsChangedListener_498(count));
440
457
                        refs = refdir.GetRefs(RefDatabase.ALL);
441
458
                        refs = refdir.GetRefs(RefDatabase.ALL);
442
459
                        listener.Remove();
447
464
                        NUnit.Framework.Assert.AreEqual(B, refs.Get("refs/heads/my/a/b/c").GetObjectId());
448
465
                }
449
466
 
450
 
                private sealed class _RefsChangedListener_481 : RefsChangedListener
 
467
                private sealed class _RefsChangedListener_498 : RefsChangedListener
451
468
                {
452
 
                        public _RefsChangedListener_481(int[] count)
 
469
                        public _RefsChangedListener_498(int[] count)
453
470
                        {
454
471
                                this.count = count;
455
472
                        }
833
850
                        NUnit.Framework.Assert.AreEqual(v1_0.GetObject(), tag.GetPeeledObjectId());
834
851
                }
835
852
 
 
853
                /// <exception cref="System.Exception"></exception>
 
854
                [NUnit.Framework.Test]
 
855
                public virtual void Test_repack()
 
856
                {
 
857
                        IDictionary<string, Ref> all;
 
858
                        WritePackedRefs("# pack-refs with: peeled \n" + A.Name + " refs/heads/master\n" +
 
859
                                 B.Name + " refs/heads/other\n" + v1_0.Name + " refs/tags/v1.0\n" + "^" + v1_0.GetObject
 
860
                                ().Name + "\n");
 
861
                        //
 
862
                        //
 
863
                        //
 
864
                        //
 
865
                        all = refdir.GetRefs(RefDatabase.ALL);
 
866
                        NUnit.Framework.Assert.AreEqual(4, all.Count);
 
867
                        NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, all.Get(Constants.HEAD).GetStorage
 
868
                                ());
 
869
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/heads/master").GetStorage
 
870
                                ());
 
871
                        NUnit.Framework.Assert.AreEqual(A.Id, all.Get("refs/heads/master").GetObjectId());
 
872
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/heads/other").GetStorage
 
873
                                ());
 
874
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/tags/v1.0").GetStorage
 
875
                                ());
 
876
                        repo.Update("refs/heads/master", B.Id);
 
877
                        RevTag v0_1 = repo.Tag("v0.1", A);
 
878
                        repo.Update("refs/tags/v0.1", v0_1);
 
879
                        all = refdir.GetRefs(RefDatabase.ALL);
 
880
                        NUnit.Framework.Assert.AreEqual(5, all.Count);
 
881
                        NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, all.Get(Constants.HEAD).GetStorage
 
882
                                ());
 
883
                        // Why isn't the next ref LOOSE_PACKED?
 
884
                        NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, all.Get("refs/heads/master").GetStorage
 
885
                                ());
 
886
                        NUnit.Framework.Assert.AreEqual(B.Id, all.Get("refs/heads/master").GetObjectId());
 
887
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/heads/other").GetStorage
 
888
                                ());
 
889
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/tags/v1.0").GetStorage
 
890
                                ());
 
891
                        NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, all.Get("refs/tags/v0.1").GetStorage
 
892
                                ());
 
893
                        NUnit.Framework.Assert.AreEqual(v0_1.Id, all.Get("refs/tags/v0.1").GetObjectId());
 
894
                        all = refdir.GetRefs(RefDatabase.ALL);
 
895
                        refdir.Pack(new AList<string>(all.Keys));
 
896
                        all = refdir.GetRefs(RefDatabase.ALL);
 
897
                        NUnit.Framework.Assert.AreEqual(5, all.Count);
 
898
                        NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, all.Get(Constants.HEAD).GetStorage
 
899
                                ());
 
900
                        // Why isn't the next ref LOOSE_PACKED?
 
901
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/heads/master").GetStorage
 
902
                                ());
 
903
                        NUnit.Framework.Assert.AreEqual(B.Id, all.Get("refs/heads/master").GetObjectId());
 
904
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/heads/other").GetStorage
 
905
                                ());
 
906
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/tags/v1.0").GetStorage
 
907
                                ());
 
908
                        NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, all.Get("refs/tags/v0.1").GetStorage
 
909
                                ());
 
910
                        NUnit.Framework.Assert.AreEqual(v0_1.Id, all.Get("refs/tags/v0.1").GetObjectId());
 
911
                }
 
912
 
836
913
                /// <exception cref="System.IO.IOException"></exception>
837
914
                [NUnit.Framework.Test]
838
915
                public virtual void TestGetRef_EmptyDatabase()
1027
1104
                        NUnit.Framework.Assert.AreSame(master_p2, refdir.Peel(master_p2));
1028
1105
                }
1029
1106
 
 
1107
                /// <exception cref="System.Exception"></exception>
 
1108
                [NUnit.Framework.Test]
 
1109
                public virtual void TestRefsChangedStackOverflow()
 
1110
                {
 
1111
                        FileRepository newRepo = CreateBareRepository();
 
1112
                        RefDatabase refDb = newRepo.RefDatabase;
 
1113
                        FilePath packedRefs = new FilePath(newRepo.Directory, "packed-refs");
 
1114
                        NUnit.Framework.Assert.IsTrue(packedRefs.CreateNewFile());
 
1115
                        AtomicReference<StackOverflowError> error = new AtomicReference<StackOverflowError
 
1116
                                >();
 
1117
                        AtomicReference<IOException> exception = new AtomicReference<IOException>();
 
1118
                        AtomicInteger changeCount = new AtomicInteger();
 
1119
                        newRepo.Listeners.AddRefsChangedListener(new _RefsChangedListener_1156(refDb, changeCount
 
1120
                                , error, exception));
 
1121
                        refDb.GetRefs("ref");
 
1122
                        refDb.GetRefs("ref");
 
1123
                        NUnit.Framework.Assert.IsNull(error.Get());
 
1124
                        NUnit.Framework.Assert.IsNull(exception.Get());
 
1125
                        NUnit.Framework.Assert.AreEqual(1, changeCount.Get());
 
1126
                }
 
1127
 
 
1128
                private sealed class _RefsChangedListener_1156 : RefsChangedListener
 
1129
                {
 
1130
                        public _RefsChangedListener_1156(RefDatabase refDb, AtomicInteger changeCount, AtomicReference
 
1131
                                <StackOverflowError> error, AtomicReference<IOException> exception)
 
1132
                        {
 
1133
                                this.refDb = refDb;
 
1134
                                this.changeCount = changeCount;
 
1135
                                this.error = error;
 
1136
                                this.exception = exception;
 
1137
                        }
 
1138
 
 
1139
                        public void OnRefsChanged(RefsChangedEvent @event)
 
1140
                        {
 
1141
                                try
 
1142
                                {
 
1143
                                        refDb.GetRefs("ref");
 
1144
                                        changeCount.IncrementAndGet();
 
1145
                                }
 
1146
                                catch (StackOverflowError soe)
 
1147
                                {
 
1148
                                        error.Set(soe);
 
1149
                                }
 
1150
                                catch (IOException ioe)
 
1151
                                {
 
1152
                                        exception.Set(ioe);
 
1153
                                }
 
1154
                        }
 
1155
 
 
1156
                        private readonly RefDatabase refDb;
 
1157
 
 
1158
                        private readonly AtomicInteger changeCount;
 
1159
 
 
1160
                        private readonly AtomicReference<StackOverflowError> error;
 
1161
 
 
1162
                        private readonly AtomicReference<IOException> exception;
 
1163
                }
 
1164
 
1030
1165
                /// <exception cref="System.IO.IOException"></exception>
1031
1166
                private void WriteLooseRef(string name, AnyObjectId id)
1032
1167
                {