← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/GetMarkupExtensionAtPositionTests.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/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/GetMarkupExtensionAtPositionTests.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 NUnit.Framework;
 
6
 
 
7
namespace ICSharpCode.XamlBinding.Tests
 
8
{
 
9
        [TestFixture]
 
10
        public class GetMarkupExtensionAtPositionTests
 
11
        {
 
12
                [Test]
 
13
                public void EmptyTest()
 
14
                {
 
15
                        string markup = "{x:Type}";
 
16
                        
 
17
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
18
                                ExtensionType = "x:Type",
 
19
                                StartOffset = 0,
 
20
                                EndOffset = 8
 
21
                        };
 
22
                        
 
23
                        RunParseTest(markup, info);
 
24
                        RunDetectionTest(markup, 5, info);
 
25
                }
 
26
                
 
27
                [Test]
 
28
                public void SimpleTest()
 
29
                {
 
30
                        string markup = "{x:Type Button}";
 
31
                        
 
32
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
33
                                ExtensionType = "x:Type",
 
34
                                StartOffset = 0,
 
35
                                EndOffset = 15
 
36
                        };
 
37
                        
 
38
                        info.PositionalArguments.Add(new AttributeValue("Button") { StartOffset = 8 });
 
39
                        
 
40
                        RunParseTest(markup, info);
 
41
                        RunDetectionTest(markup, 10, info);
 
42
                }
 
43
                
 
44
                [Test]
 
45
                public void SimplePosArgTest()
 
46
                {
 
47
                        string markup = "{x:Type Button, Button2}";
 
48
                        
 
49
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
50
                                ExtensionType = "x:Type",
 
51
                                StartOffset = 0,
 
52
                                EndOffset = 24
 
53
                        };
 
54
                        
 
55
                        info.PositionalArguments.Add(new AttributeValue("Button") { StartOffset = 8 });
 
56
                        info.PositionalArguments.Add(new AttributeValue("Button2") { StartOffset = 16 });
 
57
                        
 
58
                        RunParseTest(markup, info);
 
59
                        RunDetectionTest(markup, 23, info);
 
60
                }
 
61
                
 
62
                [Test]
 
63
                public void SimpleNamedArgTest()
 
64
                {
 
65
                        string markup = "{x:Type Type=Button}";
 
66
                        
 
67
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
68
                                ExtensionType = "x:Type",
 
69
                                StartOffset = 0,
 
70
                                EndOffset = 20
 
71
                        };
 
72
                        
 
73
                        info.NamedArguments.Add("Type", new AttributeValue("Button") { StartOffset = 13 });
 
74
                        
 
75
                        RunParseTest(markup, info);
 
76
                        RunDetectionTest(markup, 0, info);
 
77
                }
 
78
 
 
79
                [Test]
 
80
                public void SimpleNamedArgTest1()
 
81
                {
 
82
                        string markup = "{x:Type Type=Button, a=b}";
 
83
                        
 
84
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
85
                                ExtensionType = "x:Type",
 
86
                                StartOffset = 0,
 
87
                                EndOffset = 25
 
88
                        };
 
89
                        
 
90
                        info.NamedArguments.Add("Type", new AttributeValue("Button") { StartOffset = 13 });
 
91
                        info.NamedArguments.Add("a", new AttributeValue("b") { StartOffset = 23 });
 
92
                        
 
93
                        RunParseTest(markup, info);
 
94
                        RunDetectionTest(markup, 20, info);
 
95
                }
 
96
                
 
97
                [Test]
 
98
                public void PosAndNamedArgTest()
 
99
                {
 
100
                        string markup = "{x:Type xy, Type=Button, a=b}";
 
101
                        
 
102
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
103
                                ExtensionType = "x:Type",
 
104
                                StartOffset = 0,
 
105
                                EndOffset = 29
 
106
                        };
 
107
                        
 
108
                        info.PositionalArguments.Add(new AttributeValue("xy") { StartOffset = 8 });
 
109
                        
 
110
                        info.NamedArguments.Add("Type", new AttributeValue("Button") { StartOffset = 17 });
 
111
                        info.NamedArguments.Add("a", new AttributeValue("b") { StartOffset = 27 });
 
112
                        
 
113
                        RunParseTest(markup, info);
 
114
                        RunDetectionTest(markup, 29, info);
 
115
                }
 
116
                
 
117
                [Test]
 
118
                public void MissingColonTest()
 
119
                {
 
120
                        string markup = "{x:Type xy Type=Button, a=b}";
 
121
                        
 
122
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
123
                                ExtensionType = "x:Type",
 
124
                                StartOffset = 0,
 
125
                                EndOffset = 28
 
126
                        };
 
127
                        
 
128
                        info.PositionalArguments.Add(new AttributeValue("xy") { StartOffset = 8 });
 
129
                        
 
130
                        info.NamedArguments.Add("Type", new AttributeValue("Button") { StartOffset = 16 });
 
131
                        info.NamedArguments.Add("a", new AttributeValue("b") { StartOffset = 26 });
 
132
                        
 
133
                        RunParseTest(markup, info);
 
134
                }
 
135
                
 
136
                [Test]
 
137
                public void MissingColonTest2()
 
138
                {
 
139
                        string markup = "{x:Type xy Type=Button a=b}";
 
140
                        
 
141
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
142
                                ExtensionType = "x:Type",
 
143
                                StartOffset = 0,
 
144
                                EndOffset = 27
 
145
                        };
 
146
                        
 
147
                        info.PositionalArguments.Add(new AttributeValue("xy") { StartOffset = 8 });
 
148
                        
 
149
                        info.NamedArguments.Add("Type", new AttributeValue("Button") { StartOffset = 16 });
 
150
                        info.NamedArguments.Add("a", new AttributeValue("b") { StartOffset = 25 });
 
151
                        
 
152
                        RunParseTest(markup, info);
 
153
                }
 
154
                
 
155
                [Test]
 
156
                public void NestedTest1()
 
157
                {
 
158
                        string markup = "{bla {bla2}}";
 
159
                        
 
160
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
161
                                ExtensionType = "bla",
 
162
                                StartOffset = 0,
 
163
                                EndOffset = 12
 
164
                        };
 
165
                        
 
166
                        info.PositionalArguments.Add(new AttributeValue(new MarkupExtensionInfo() { ExtensionType = "bla2", StartOffset = 5, EndOffset = 11 }) { StartOffset = 5 });
 
167
                        
 
168
                        RunParseTest(markup, info);
 
169
                }
 
170
                
 
171
                [Test]
 
172
                public void NestedTest2()
 
173
                {
 
174
                        string markup = "{bla a, {bla2}}";
 
175
                        
 
176
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
177
                                ExtensionType = "bla",
 
178
                                StartOffset = 0,
 
179
                                EndOffset = 15
 
180
                        };
 
181
                        
 
182
                        info.PositionalArguments.Add(new AttributeValue("a") { StartOffset = 5 });
 
183
                        info.PositionalArguments.Add(
 
184
                                new AttributeValue(
 
185
                                        new MarkupExtensionInfo() {
 
186
                                                ExtensionType = "bla2",
 
187
                                                StartOffset = 8,
 
188
                                                EndOffset = 14
 
189
                                        }
 
190
                                ) {
 
191
                                        StartOffset = 8
 
192
                                }
 
193
                        );
 
194
                        
 
195
                        RunParseTest(markup, info);
 
196
                }
 
197
                
 
198
                [Test]
 
199
                public void NestedTest3()
 
200
                {
 
201
                        string markup = "{bla a, {bla2}, b, {bla3 {a}, b}}";
 
202
                        
 
203
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
204
                                ExtensionType = "bla",
 
205
                                StartOffset = 0,
 
206
                                EndOffset = 33
 
207
                        };
 
208
                        
 
209
                        info.PositionalArguments.Add(new AttributeValue("a") { StartOffset = 5 });
 
210
                        info.PositionalArguments.Add(
 
211
                                new AttributeValue(
 
212
                                        new MarkupExtensionInfo() {
 
213
                                                ExtensionType = "bla2",
 
214
                                                StartOffset = 8,
 
215
                                                EndOffset = 14
 
216
                                        }
 
217
                                ) {
 
218
                                        StartOffset = 8
 
219
                                }
 
220
                        );
 
221
                        info.PositionalArguments.Add(new AttributeValue("b") { StartOffset = 16 });
 
222
                        
 
223
                        var nested2 =   new MarkupExtensionInfo() {
 
224
                                ExtensionType = "bla3",
 
225
                                StartOffset = 19,
 
226
                                EndOffset = 32
 
227
                        };
 
228
                        
 
229
                        nested2.PositionalArguments.Add(
 
230
                                new AttributeValue(
 
231
                                        new MarkupExtensionInfo() {
 
232
                                                ExtensionType = "a",
 
233
                                                StartOffset = 25,
 
234
                                                EndOffset = 28
 
235
                                        }
 
236
                                ) {
 
237
                                        StartOffset = 25
 
238
                                }
 
239
                        );
 
240
                        
 
241
                        nested2.PositionalArguments.Add(new AttributeValue("b") { StartOffset = 30 });
 
242
                        
 
243
                        info.PositionalArguments.Add(
 
244
                                new AttributeValue(nested2) {
 
245
                                        StartOffset = 19
 
246
                                }
 
247
                        );
 
248
                        
 
249
                        RunParseTest(markup, info);
 
250
                }
 
251
                
 
252
                [Test]
 
253
                public void NestedTest4()
 
254
                {
 
255
                        string markup = "{bla a, x={bla3 {a}, b={c}, d=e}, y=z}";
 
256
                        
 
257
                        MarkupExtensionInfo info = new MarkupExtensionInfo() {
 
258
                                ExtensionType = "bla",
 
259
                                StartOffset = 0,
 
260
                                EndOffset = 38
 
261
                        };
 
262
                        
 
263
                        info.PositionalArguments.Add(new AttributeValue("a") { StartOffset = 5 });
 
264
                        
 
265
                        //x={bla3 {a}, b={c}, d=e}
 
266
                        
 
267
                        MarkupExtensionInfo inner = new MarkupExtensionInfo() {
 
268
                                ExtensionType = "bla3",
 
269
                                StartOffset = 10,
 
270
                                EndOffset = 32
 
271
                        };
 
272
                        
 
273
                        MarkupExtensionInfo smallInner = new MarkupExtensionInfo() {
 
274
                                ExtensionType = "a",
 
275
                                StartOffset = 16,
 
276
                                EndOffset = 19
 
277
                        };
 
278
                        
 
279
                        inner.PositionalArguments.Add(new AttributeValue(smallInner) { StartOffset = 16 });
 
280
                        
 
281
                        MarkupExtensionInfo smallInner2 = new MarkupExtensionInfo() {
 
282
                                ExtensionType = "c",
 
283
                                StartOffset = 23,
 
284
                                EndOffset = 26
 
285
                        };
 
286
                        
 
287
                        inner.NamedArguments.Add("b", new AttributeValue(smallInner2) { StartOffset = 23 });
 
288
                        
 
289
                        inner.NamedArguments.Add("d", new AttributeValue("e") { StartOffset = 30 });
 
290
                        
 
291
                        info.NamedArguments.Add("x", new AttributeValue(inner) { StartOffset = 10 });
 
292
                        
 
293
                        info.NamedArguments.Add("y", new AttributeValue("z") { StartOffset = 36 });
 
294
                        
 
295
                        RunParseTest(markup, info);
 
296
                        RunDetectionTest(markup, 9, info);
 
297
                        RunDetectionTest(markup, 11, inner);
 
298
                        RunDetectionTest(markup, 17, smallInner);
 
299
                        RunDetectionTest(markup, 19, inner);
 
300
                        RunDetectionTest(markup, 32, info);
 
301
                }
 
302
                
 
303
                static void RunDetectionTest(string markup, int offset, MarkupExtensionInfo expectedResult)
 
304
                {
 
305
                        MarkupExtensionInfo data = MarkupExtensionParser.Parse(markup);
 
306
                        MarkupExtensionInfo result = Utils.GetMarkupExtensionAtPosition(data, offset);
 
307
                        
 
308
                        Assert.AreEqual(expectedResult, result);
 
309
                }
 
310
                
 
311
                static void RunParseTest(string markup, MarkupExtensionInfo expectedResult)
 
312
                {
 
313
                        MarkupExtensionInfo data = MarkupExtensionParser.Parse(markup);
 
314
                        
 
315
                        Assert.AreEqual(expectedResult, data);
 
316
                }
 
317
        }
 
318
}