← 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.Pack/DeltaStreamTest.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.Pack/DeltaStreamTest.cs
47
47
using NGit.Junit;
48
48
using NGit.Storage.Pack;
49
49
using NGit.Util;
 
50
using NUnit.Framework;
50
51
using Sharpen;
51
52
 
52
53
namespace NGit.Storage.Pack
187
188
                        // Skip should not open the base as we move past it, but it
188
189
                        // will open when we need to start copying data from it.
189
190
                        bool[] opened = new bool[1];
190
 
                        in_1 = new _DeltaStream_179(this, opened, new ByteArrayInputStream(delta));
 
191
                        in_1 = new _DeltaStream_180(this, opened, new ByteArrayInputStream(delta));
191
192
                        IOUtil.SkipFully(in_1, 7);
192
193
                        NUnit.Framework.Assert.IsFalse(opened[0], "not yet open");
193
194
                        NUnit.Framework.Assert.AreEqual(data[7], in_1.Read());
194
195
                        NUnit.Framework.Assert.IsTrue(opened[0], "now open");
195
196
                }
196
197
 
197
 
                private sealed class _DeltaStream_179 : DeltaStream
 
198
                private sealed class _DeltaStream_180 : DeltaStream
198
199
                {
199
 
                        public _DeltaStream_179(DeltaStreamTest _enclosing, bool[] opened, InputStream baseArg1
 
200
                        public _DeltaStream_180(DeltaStreamTest _enclosing, bool[] opened, InputStream baseArg1
200
201
                                ) : base(baseArg1)
201
202
                        {
202
203
                                this._enclosing = _enclosing;
228
229
                        Init(4, 4);
229
230
                        Copy(0, 4);
230
231
                        AssertValidState();
231
 
                        DeltaStream @in = new _DeltaStream_203(this, new ByteArrayInputStream(delta));
 
232
                        DeltaStream @in = new _DeltaStream_204(this, new ByteArrayInputStream(delta));
232
233
                        try
233
234
                        {
234
235
                                @in.Read(new byte[4]);
238
239
                        {
239
240
                                NUnit.Framework.Assert.AreEqual(JGitText.Get().baseLengthIncorrect, e.Message);
240
241
                        }
241
 
                        @in = new _DeltaStream_221(new ByteArrayInputStream(delta));
 
242
                        @in = new _DeltaStream_222(new ByteArrayInputStream(delta));
242
243
                        try
243
244
                        {
244
245
                                @in.Read(new byte[4]);
250
251
                        }
251
252
                }
252
253
 
253
 
                private sealed class _DeltaStream_203 : DeltaStream
 
254
                private sealed class _DeltaStream_204 : DeltaStream
254
255
                {
255
 
                        public _DeltaStream_203(DeltaStreamTest _enclosing, InputStream baseArg1) : base(
 
256
                        public _DeltaStream_204(DeltaStreamTest _enclosing, InputStream baseArg1) : base(
256
257
                                baseArg1)
257
258
                        {
258
259
                                this._enclosing = _enclosing;
273
274
                        private readonly DeltaStreamTest _enclosing;
274
275
                }
275
276
 
276
 
                private sealed class _DeltaStream_221 : DeltaStream
 
277
                private sealed class _DeltaStream_222 : DeltaStream
277
278
                {
278
 
                        public _DeltaStream_221(InputStream baseArg1) : base(baseArg1)
 
279
                        public _DeltaStream_222(InputStream baseArg1) : base(baseArg1)
279
280
                        {
280
281
                        }
281
282
 
333
334
                        delta = deltaBuf.ToByteArray();
334
335
                        NUnit.Framework.Assert.AreEqual(@base.Length, BinaryDelta.GetBaseSize(delta));
335
336
                        NUnit.Framework.Assert.AreEqual(data.Length, BinaryDelta.GetResultSize(delta));
336
 
                        NUnit.Framework.Assert.IsTrue(Arrays.Equals(data, BinaryDelta.Apply(@base, delta)
337
 
                                ));
 
337
                        var appliedDelta = BinaryDelta.Apply (@base, delta);
 
338
                        Assert.AreEqual (data.Length, appliedDelta.Length);
 
339
                        for (int i = 0; i < data.Length; i++)
 
340
                                Assert.AreEqual (data[i], appliedDelta[i]);
 
341
 
338
342
                        // Assert that a single bulk read produces the correct result.
339
343
                        //
340
344
                        byte[] act = new byte[data.Length];
367
371
                /// <exception cref="System.IO.IOException"></exception>
368
372
                private DeltaStream Open()
369
373
                {
370
 
                        return new _DeltaStream_298(this, new ByteArrayInputStream(delta));
 
374
                        return new _DeltaStream_299(this, new ByteArrayInputStream(delta));
371
375
                }
372
376
 
373
 
                private sealed class _DeltaStream_298 : DeltaStream
 
377
                private sealed class _DeltaStream_299 : DeltaStream
374
378
                {
375
 
                        public _DeltaStream_298(DeltaStreamTest _enclosing, InputStream baseArg1) : base(
 
379
                        public _DeltaStream_299(DeltaStreamTest _enclosing, InputStream baseArg1) : base(
376
380
                                baseArg1)
377
381
                        {
378
382
                                this._enclosing = _enclosing;