← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit.Tests/Document/LineManagerTests.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit.Tests/Document/LineManagerTests.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using NUnit.Framework;
 
7
 
 
8
namespace ICSharpCode.AvalonEdit.Document
 
9
{
 
10
        [TestFixture]
 
11
        public class LineManagerTests
 
12
        {
 
13
                TextDocument document;
 
14
                
 
15
                [SetUp]
 
16
                public void SetUp()
 
17
                {
 
18
                        document = new TextDocument();
 
19
                }
 
20
                
 
21
                [Test]
 
22
                public void CheckEmptyDocument()
 
23
                {
 
24
                        Assert.AreEqual("", document.Text);
 
25
                        Assert.AreEqual(0, document.TextLength);
 
26
                        Assert.AreEqual(1, document.LineCount);
 
27
                }
 
28
                
 
29
                [Test]
 
30
                public void CheckClearingDocument()
 
31
                {
 
32
                        document.Text = "Hello,\nWorld!";
 
33
                        Assert.AreEqual(2, document.LineCount);
 
34
                        document.Text = "";
 
35
                        Assert.AreEqual("", document.Text);
 
36
                        Assert.AreEqual(0, document.TextLength);
 
37
                        Assert.AreEqual(1, document.LineCount);
 
38
                }
 
39
                
 
40
                [Test]
 
41
                public void CheckGetLineInEmptyDocument()
 
42
                {
 
43
                        Assert.AreEqual(1, document.Lines.Count);
 
44
                        List<DocumentLine> lines = new List<DocumentLine>(document.Lines);
 
45
                        Assert.AreEqual(1, lines.Count);
 
46
                        DocumentLine line = document.Lines[0];
 
47
                        Assert.AreSame(line, lines[0]);
 
48
                        Assert.AreSame(line, document.GetLineByNumber(1));
 
49
                        Assert.AreSame(line, document.GetLineByOffset(0));
 
50
                }
 
51
                
 
52
                [Test]
 
53
                public void CheckLineSegmentInEmptyDocument()
 
54
                {
 
55
                        DocumentLine line = document.GetLineByNumber(1);
 
56
                        Assert.AreEqual(1, line.LineNumber);
 
57
                        Assert.AreEqual(0, line.Offset);
 
58
                        Assert.IsFalse(line.IsDeleted);
 
59
                        Assert.AreEqual(0, line.Length);
 
60
                        Assert.AreEqual(0, line.TotalLength);
 
61
                        Assert.AreEqual(0, line.DelimiterLength);
 
62
                }
 
63
                
 
64
                [Test]
 
65
                public void LineIndexOfTest()
 
66
                {
 
67
                        DocumentLine line = document.GetLineByNumber(1);
 
68
                        Assert.AreEqual(0, document.Lines.IndexOf(line));
 
69
                        DocumentLine lineFromOtherDocument = new TextDocument().GetLineByNumber(1);
 
70
                        Assert.AreEqual(-1, document.Lines.IndexOf(lineFromOtherDocument));
 
71
                        document.Text = "a\nb\nc";
 
72
                        DocumentLine middleLine = document.GetLineByNumber(2);
 
73
                        Assert.AreEqual(1, document.Lines.IndexOf(middleLine));
 
74
                        document.Remove(1, 3);
 
75
                        Assert.IsTrue(middleLine.IsDeleted);
 
76
                        Assert.AreEqual(-1, document.Lines.IndexOf(middleLine));
 
77
                }
 
78
                
 
79
                [Test]
 
80
                public void InsertInEmptyDocument()
 
81
                {
 
82
                        document.Insert(0, "a");
 
83
                        Assert.AreEqual(document.LineCount, 1);
 
84
                        DocumentLine line = document.GetLineByNumber(1);
 
85
                        Assert.AreEqual("a", document.GetText(line));
 
86
                }
 
87
                
 
88
                [Test]
 
89
                public void SetText()
 
90
                {
 
91
                        document.Text = "a";
 
92
                        Assert.AreEqual(document.LineCount, 1);
 
93
                        DocumentLine line = document.GetLineByNumber(1);
 
94
                        Assert.AreEqual("a", document.GetText(line));
 
95
                }
 
96
                
 
97
                [Test]
 
98
                public void InsertNothing()
 
99
                {
 
100
                        document.Insert(0, "");
 
101
                        Assert.AreEqual(document.LineCount, 1);
 
102
                        Assert.AreEqual(document.TextLength, 0);
 
103
                }
 
104
                
 
105
                [Test, ExpectedException(typeof(ArgumentNullException))]
 
106
                public void InsertNull()
 
107
                {
 
108
                        document.Insert(0, null);
 
109
                }
 
110
                
 
111
                [Test, ExpectedException(typeof(ArgumentNullException))]
 
112
                public void SetTextNull()
 
113
                {
 
114
                        document.Text = null;
 
115
                }
 
116
                
 
117
                [Test]
 
118
                public void RemoveNothing()
 
119
                {
 
120
                        document.Remove(0, 0);
 
121
                        Assert.AreEqual(document.LineCount, 1);
 
122
                        Assert.AreEqual(document.TextLength, 0);
 
123
                }
 
124
                
 
125
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
126
                public void GetCharAt0EmptyDocument()
 
127
                {
 
128
                        document.GetCharAt(0);
 
129
                }
 
130
                
 
131
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
132
                public void GetCharAtNegativeOffset()
 
133
                {
 
134
                        document.Text = "a\nb";
 
135
                        document.GetCharAt(-1);
 
136
                }
 
137
                
 
138
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
139
                public void GetCharAtEndOffset()
 
140
                {
 
141
                        document.Text = "a\nb";
 
142
                        document.GetCharAt(document.TextLength);
 
143
                }
 
144
                
 
145
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
146
                public void InsertAtNegativeOffset()
 
147
                {
 
148
                        document.Text = "a\nb";
 
149
                        document.Insert(-1, "text");
 
150
                }
 
151
                
 
152
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
153
                public void InsertAfterEndOffset()
 
154
                {
 
155
                        document.Text = "a\nb";
 
156
                        document.Insert(4, "text");
 
157
                }
 
158
                
 
159
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
160
                public void RemoveNegativeAmount()
 
161
                {
 
162
                        document.Text = "abcd";
 
163
                        document.Remove(2, -1);
 
164
                }
 
165
                
 
166
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
167
                public void RemoveTooMuch()
 
168
                {
 
169
                        document.Text = "abcd";
 
170
                        document.Remove(2, 10);
 
171
                }
 
172
                
 
173
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
174
                public void GetLineByNumberNegative()
 
175
                {
 
176
                        document.Text = "a\nb";
 
177
                        document.GetLineByNumber(-1);
 
178
                }
 
179
                
 
180
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
181
                public void GetLineByNumberTooHigh()
 
182
                {
 
183
                        document.Text = "a\nb";
 
184
                        document.GetLineByNumber(3);
 
185
                }
 
186
                
 
187
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
188
                public void GetLineByOffsetNegative()
 
189
                {
 
190
                        document.Text = "a\nb";
 
191
                        document.GetLineByOffset(-1);
 
192
                }
 
193
                
 
194
                
 
195
                [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
 
196
                public void GetLineByOffsetToHigh()
 
197
                {
 
198
                        document.Text = "a\nb";
 
199
                        document.GetLineByOffset(10);
 
200
                }
 
201
                
 
202
                [Test]
 
203
                public void InsertAtEndOffset()
 
204
                {
 
205
                        document.Text = "a\nb";
 
206
                        CheckDocumentLines("a",
 
207
                                           "b");
 
208
                        document.Insert(3, "text");
 
209
                        CheckDocumentLines("a",
 
210
                                           "btext");
 
211
                }
 
212
                
 
213
                [Test]
 
214
                public void GetCharAt()
 
215
                {
 
216
                        document.Text = "a\r\nb";
 
217
                        Assert.AreEqual('a', document.GetCharAt(0));
 
218
                        Assert.AreEqual('\r', document.GetCharAt(1));
 
219
                        Assert.AreEqual('\n', document.GetCharAt(2));
 
220
                        Assert.AreEqual('b', document.GetCharAt(3));
 
221
                }
 
222
                
 
223
                [Test]
 
224
                public void CheckMixedNewLineTest()
 
225
                {
 
226
                        const string mixedNewlineText = "line 1\nline 2\r\nline 3\rline 4";
 
227
                        document.Text = mixedNewlineText;
 
228
                        Assert.AreEqual(mixedNewlineText, document.Text);
 
229
                        Assert.AreEqual(4, document.LineCount);
 
230
                        for (int i = 1; i < 4; i++) {
 
231
                                DocumentLine line = document.GetLineByNumber(i);
 
232
                                Assert.AreEqual(i, line.LineNumber);
 
233
                                Assert.AreEqual("line " + i, document.GetText(line));
 
234
                        }
 
235
                        Assert.AreEqual(1, document.GetLineByNumber(1).DelimiterLength);
 
236
                        Assert.AreEqual(2, document.GetLineByNumber(2).DelimiterLength);
 
237
                        Assert.AreEqual(1, document.GetLineByNumber(3).DelimiterLength);
 
238
                        Assert.AreEqual(0, document.GetLineByNumber(4).DelimiterLength);
 
239
                }
 
240
                
 
241
                [Test]
 
242
                public void LfCrIsTwoNewLinesTest()
 
243
                {
 
244
                        document.Text = "a\n\rb";
 
245
                        Assert.AreEqual("a\n\rb", document.Text);
 
246
                        CheckDocumentLines("a",
 
247
                                           "",
 
248
                                           "b");
 
249
                }
 
250
                
 
251
                [Test]
 
252
                public void RemoveFirstPartOfDelimiter()
 
253
                {
 
254
                        document.Text = "a\r\nb";
 
255
                        document.Remove(1, 1);
 
256
                        Assert.AreEqual("a\nb", document.Text);
 
257
                        CheckDocumentLines("a",
 
258
                                           "b");
 
259
                }
 
260
                
 
261
                [Test]
 
262
                public void RemoveLineContentAndJoinDelimiters()
 
263
                {
 
264
                        document.Text = "a\rb\nc";
 
265
                        document.Remove(2, 1);
 
266
                        Assert.AreEqual("a\r\nc", document.Text);
 
267
                        CheckDocumentLines("a",
 
268
                                           "c");
 
269
                }
 
270
                
 
271
                [Test]
 
272
                public void RemoveLineContentAndJoinDelimiters2()
 
273
                {
 
274
                        document.Text = "a\rb\nc\nd";
 
275
                        document.Remove(2, 3);
 
276
                        Assert.AreEqual("a\r\nd", document.Text);
 
277
                        CheckDocumentLines("a",
 
278
                                           "d");
 
279
                }
 
280
                
 
281
                [Test]
 
282
                public void RemoveLineContentAndJoinDelimiters3()
 
283
                {
 
284
                        document.Text = "a\rb\r\nc";
 
285
                        document.Remove(2, 2);
 
286
                        Assert.AreEqual("a\r\nc", document.Text);
 
287
                        CheckDocumentLines("a",
 
288
                                           "c");
 
289
                }
 
290
                
 
291
                [Test]
 
292
                public void RemoveLineContentAndJoinNonMatchingDelimiters()
 
293
                {
 
294
                        document.Text = "a\nb\nc";
 
295
                        document.Remove(2, 1);
 
296
                        Assert.AreEqual("a\n\nc", document.Text);
 
297
                        CheckDocumentLines("a",
 
298
                                           "",
 
299
                                           "c");
 
300
                }
 
301
                
 
302
                [Test]
 
303
                public void RemoveLineContentAndJoinNonMatchingDelimiters2()
 
304
                {
 
305
                        document.Text = "a\nb\rc";
 
306
                        document.Remove(2, 1);
 
307
                        Assert.AreEqual("a\n\rc", document.Text);
 
308
                        CheckDocumentLines("a",
 
309
                                           "",
 
310
                                           "c");
 
311
                }
 
312
                
 
313
                [Test]
 
314
                public void RemoveMultilineUpToFirstPartOfDelimiter()
 
315
                {
 
316
                        document.Text = "0\n1\r\n2";
 
317
                        document.Remove(1, 3);
 
318
                        Assert.AreEqual("0\n2", document.Text);
 
319
                        CheckDocumentLines("0",
 
320
                                           "2");
 
321
                }
 
322
                
 
323
                [Test]
 
324
                public void RemoveSecondPartOfDelimiter()
 
325
                {
 
326
                        document.Text = "a\r\nb";
 
327
                        document.Remove(2, 1);
 
328
                        Assert.AreEqual("a\rb", document.Text);
 
329
                        CheckDocumentLines("a",
 
330
                                           "b");
 
331
                }
 
332
                
 
333
                [Test]
 
334
                public void RemoveFromSecondPartOfDelimiter()
 
335
                {
 
336
                        document.Text = "a\r\nb\nc";
 
337
                        document.Remove(2, 3);
 
338
                        Assert.AreEqual("a\rc", document.Text);
 
339
                        CheckDocumentLines("a",
 
340
                                           "c");
 
341
                }
 
342
                
 
343
                [Test]
 
344
                public void RemoveFromSecondPartOfDelimiterToDocumentEnd()
 
345
                {
 
346
                        document.Text = "a\r\nb";
 
347
                        document.Remove(2, 2);
 
348
                        Assert.AreEqual("a\r", document.Text);
 
349
                        CheckDocumentLines("a",
 
350
                                           "");
 
351
                }
 
352
                
 
353
                [Test]
 
354
                public void RemoveUpToMatchingDelimiter1()
 
355
                {
 
356
                        document.Text = "a\r\nb\nc";
 
357
                        document.Remove(2, 2);
 
358
                        Assert.AreEqual("a\r\nc", document.Text);
 
359
                        CheckDocumentLines("a",
 
360
                                           "c");
 
361
                }
 
362
                
 
363
                [Test]
 
364
                public void RemoveUpToMatchingDelimiter2()
 
365
                {
 
366
                        document.Text = "a\r\nb\r\nc";
 
367
                        document.Remove(2, 3);
 
368
                        Assert.AreEqual("a\r\nc", document.Text);
 
369
                        CheckDocumentLines("a",
 
370
                                           "c");
 
371
                }
 
372
                
 
373
                [Test]
 
374
                public void RemoveUpToNonMatchingDelimiter()
 
375
                {
 
376
                        document.Text = "a\r\nb\rc";
 
377
                        document.Remove(2, 2);
 
378
                        Assert.AreEqual("a\r\rc", document.Text);
 
379
                        CheckDocumentLines("a",
 
380
                                           "",
 
381
                                           "c");
 
382
                }
 
383
                
 
384
                [Test]
 
385
                public void RemoveTwoCharDelimiter()
 
386
                {
 
387
                        document.Text = "a\r\nb";
 
388
                        document.Remove(1, 2);
 
389
                        Assert.AreEqual("ab", document.Text);
 
390
                        CheckDocumentLines("ab");
 
391
                }
 
392
                
 
393
                [Test]
 
394
                public void RemoveOneCharDelimiter()
 
395
                {
 
396
                        document.Text = "a\nb";
 
397
                        document.Remove(1, 1);
 
398
                        Assert.AreEqual("ab", document.Text);
 
399
                        CheckDocumentLines("ab");
 
400
                }
 
401
                
 
402
                void CheckDocumentLines(params string[] lines)
 
403
                {
 
404
                        Assert.AreEqual(lines.Length, document.LineCount, "LineCount");
 
405
                        for (int i = 0; i < lines.Length; i++) {
 
406
                                Assert.AreEqual(lines[i],  document.GetText(document.Lines[i]), "Text of line " + (i + 1));
 
407
                        }
 
408
                }
 
409
                
 
410
                [Test]
 
411
                public void FixUpFirstPartOfDelimiter()
 
412
                {
 
413
                        document.Text = "a\n\nb";
 
414
                        document.Replace(1, 1, "\r");
 
415
                        Assert.AreEqual("a\r\nb", document.Text);
 
416
                        CheckDocumentLines("a",
 
417
                                           "b");
 
418
                }
 
419
                
 
420
                [Test]
 
421
                public void FixUpSecondPartOfDelimiter()
 
422
                {
 
423
                        document.Text = "a\r\rb";
 
424
                        document.Replace(2, 1, "\n");
 
425
                        Assert.AreEqual("a\r\nb", document.Text);
 
426
                        CheckDocumentLines("a",
 
427
                                           "b");
 
428
                }
 
429
                
 
430
                [Test]
 
431
                public void InsertInsideDelimiter()
 
432
                {
 
433
                        document.Text = "a\r\nc";
 
434
                        document.Insert(2, "b");
 
435
                        Assert.AreEqual("a\rb\nc", document.Text);
 
436
                        CheckDocumentLines("a",
 
437
                                           "b",
 
438
                                           "c");
 
439
                }
 
440
                
 
441
                [Test]
 
442
                public void InsertInsideDelimiter2()
 
443
                {
 
444
                        document.Text = "a\r\nd";
 
445
                        document.Insert(2, "b\nc");
 
446
                        Assert.AreEqual("a\rb\nc\nd", document.Text);
 
447
                        CheckDocumentLines("a",
 
448
                                           "b",
 
449
                                           "c",
 
450
                                           "d");
 
451
                }
 
452
                
 
453
                [Test]
 
454
                public void InsertInsideDelimiter3()
 
455
                {
 
456
                        document.Text = "a\r\nc";
 
457
                        document.Insert(2, "b\r");
 
458
                        Assert.AreEqual("a\rb\r\nc", document.Text);
 
459
                        CheckDocumentLines("a",
 
460
                                           "b",
 
461
                                           "c");
 
462
                }
 
463
                
 
464
                [Test]
 
465
                public void ExtendDelimiter1()
 
466
                {
 
467
                        document.Text = "a\nc";
 
468
                        document.Insert(1, "b\r");
 
469
                        Assert.AreEqual("ab\r\nc", document.Text);
 
470
                        CheckDocumentLines("ab",
 
471
                                           "c");
 
472
                }
 
473
                
 
474
                [Test]
 
475
                public void ExtendDelimiter2()
 
476
                {
 
477
                        document.Text = "a\rc";
 
478
                        document.Insert(2, "\nb");
 
479
                        Assert.AreEqual("a\r\nbc", document.Text);
 
480
                        CheckDocumentLines("a",
 
481
                                           "bc");
 
482
                }
 
483
                
 
484
                [Test]
 
485
                public void ReplaceLineContentBetweenMatchingDelimiters()
 
486
                {
 
487
                        document.Text = "a\rb\nc";
 
488
                        document.Replace(2, 1, "x");
 
489
                        Assert.AreEqual("a\rx\nc", document.Text);
 
490
                        CheckDocumentLines("a",
 
491
                                           "x",
 
492
                                           "c");
 
493
                }
 
494
                
 
495
                [Test]
 
496
                public void GetOffset()
 
497
                {
 
498
                        document.Text = "Hello,\nWorld!";
 
499
                        Assert.AreEqual(0, document.GetOffset(1, 1));
 
500
                        Assert.AreEqual(1, document.GetOffset(1, 2));
 
501
                        Assert.AreEqual(5, document.GetOffset(1, 6));
 
502
                        Assert.AreEqual(6, document.GetOffset(1, 7));
 
503
                        Assert.AreEqual(7, document.GetOffset(2, 1));
 
504
                        Assert.AreEqual(8, document.GetOffset(2, 2));
 
505
                        Assert.AreEqual(12, document.GetOffset(2, 6));
 
506
                        Assert.AreEqual(13, document.GetOffset(2, 7));
 
507
                }
 
508
                
 
509
                [Test]
 
510
                public void GetOffsetIgnoreNegativeColumns()
 
511
                {
 
512
                        document.Text = "Hello,\nWorld!";
 
513
                        Assert.AreEqual(0, document.GetOffset(1, -1));
 
514
                        Assert.AreEqual(0, document.GetOffset(1, -100));
 
515
                        Assert.AreEqual(0, document.GetOffset(1, 0));
 
516
                        Assert.AreEqual(7, document.GetOffset(2, -1));
 
517
                        Assert.AreEqual(7, document.GetOffset(2, -100));
 
518
                        Assert.AreEqual(7, document.GetOffset(2, 0));
 
519
                }
 
520
                
 
521
                [Test]
 
522
                public void GetOffsetIgnoreTooHighColumns()
 
523
                {
 
524
                        document.Text = "Hello,\nWorld!";
 
525
                        Assert.AreEqual(6, document.GetOffset(1, 8));
 
526
                        Assert.AreEqual(6, document.GetOffset(1, 100));
 
527
                        Assert.AreEqual(13, document.GetOffset(2, 8));
 
528
                        Assert.AreEqual(13, document.GetOffset(2, 100));
 
529
                }
 
530
        }
 
531
}