← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.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/nrefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.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.IO;
 
6
using ICSharpCode.NRefactory.VB.Parser;
 
7
using NUnit.Framework;
 
8
 
 
9
namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 
10
{
 
11
        [TestFixture]
 
12
        public sealed class LiteralsTests
 
13
        {
 
14
                VBLexer GenerateLexer(StringReader sr)
 
15
                {
 
16
                        return new VBLexer(sr);
 
17
                }
 
18
                
 
19
                Token GetSingleToken(string text)
 
20
                {
 
21
                        VBLexer lexer = GenerateLexer(new StringReader(text));
 
22
                        Token t = lexer.NextToken();
 
23
                        Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL");
 
24
                        Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
 
25
                        Assert.AreEqual("", lexer.Errors.ErrorOutput);
 
26
                        return t;
 
27
                }
 
28
                
 
29
                void CheckToken(string text, int tokenType, object val)
 
30
                {
 
31
                        Token t = GetSingleToken(text);
 
32
                        Assert.AreEqual(tokenType, t.Kind, "Tokens.Literal");
 
33
                        Assert.IsNotNull(t.LiteralValue, "literalValue is null");
 
34
                        Assert.AreEqual(val.GetType(), t.LiteralValue.GetType(), "literalValue.GetType()");
 
35
                        Assert.AreEqual(val, t.LiteralValue, "literalValue");
 
36
                }
 
37
                
 
38
                [Test]
 
39
                public void TestSingleDigit()
 
40
                {
 
41
                        CheckToken("5", Tokens.LiteralInteger, 5);
 
42
                }
 
43
                
 
44
                [Test]
 
45
                public void TestZero()
 
46
                {
 
47
                        CheckToken("0", Tokens.LiteralInteger, 0);
 
48
                }
 
49
                
 
50
                [Test]
 
51
                public void TestInteger()
 
52
                {
 
53
                        CheckToken("15", Tokens.LiteralInteger, 15);
 
54
                        CheckToken("8581", Tokens.LiteralInteger, 8581);
 
55
                }
 
56
                
 
57
                [Test]
 
58
                public void InvalidTypeCharacter()
 
59
                {
 
60
                        // just check that we don't get exceptions:
 
61
                        GenerateLexer(new StringReader(".5s")).NextToken();
 
62
                        GenerateLexer(new StringReader(".5ul")).NextToken();
 
63
                }
 
64
                
 
65
                [Test]
 
66
                public void TestHexadecimalInteger()
 
67
                {
 
68
                        CheckToken("&H10", Tokens.LiteralInteger, 0x10);
 
69
                        CheckToken("&H10&", Tokens.LiteralInteger, (long)0x10);
 
70
                        CheckToken("&h3ff%", Tokens.LiteralInteger, 0x3ff);
 
71
                        CheckToken("&h8000s", Tokens.LiteralInteger, short.MinValue);
 
72
                        CheckToken("&h8000us", Tokens.LiteralInteger, (ushort)0x8000);
 
73
                        CheckToken("&HffffFFFF", Tokens.LiteralInteger, -1);
 
74
                        CheckToken("&HffffFFFF%", Tokens.LiteralInteger, -1);
 
75
                        CheckToken("&HffffFFFFui", Tokens.LiteralInteger, uint.MaxValue);
 
76
                        CheckToken("&HffffFFFF&", Tokens.LiteralInteger, (long)uint.MaxValue);
 
77
                }
 
78
                
 
79
                [Test]
 
80
                public void TestLongHexadecimalInteger()
 
81
                {
 
82
                        CheckToken("&H4244636f446c6d58", Tokens.LiteralInteger, 0x4244636f446c6d58);
 
83
                        CheckToken("&hf244636f446c6d58", Tokens.LiteralInteger, -989556688574190248);
 
84
                        CheckToken("&hf244636f446c6d58&", Tokens.LiteralInteger, -989556688574190248);
 
85
                        CheckToken("&hf244636f446c6d58ul", Tokens.LiteralInteger, 0xf244636f446c6d58);
 
86
                }
 
87
                
 
88
                [Test]
 
89
                public void InvalidHexadecimalInteger()
 
90
                {
 
91
                        // just check that we don't get exceptions:
 
92
                        GenerateLexer(new StringReader("&H")).NextToken();
 
93
                        // >ulong.MaxValue
 
94
                        GenerateLexer(new StringReader("&hff244636f446c6d58")).NextToken();
 
95
                        // needs an ulong, but "i" postfix specified integer
 
96
                        GenerateLexer(new StringReader("&hf244636f446c6d58i")).NextToken();
 
97
                        GenerateLexer(new StringReader("&hf244636f446c6d58ui")).NextToken();
 
98
                }
 
99
                
 
100
                [Test]
 
101
                public void TestIncompleteHexadecimal()
 
102
                {
 
103
                        VBLexer lexer = GenerateLexer(new StringReader("&H\r\nabc"));
 
104
                        Token t = lexer.NextToken();
 
105
                        Assert.AreEqual(Tokens.LiteralInteger, t.Kind);
 
106
                        Assert.AreEqual(0, (int)t.LiteralValue);
 
107
                        Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (1)");
 
108
                        Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind, "Tokens.Identifier");
 
109
                        Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (2)");
 
110
                        Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
 
111
                        Assert.AreNotEqual("", lexer.Errors.ErrorOutput);
 
112
                }
 
113
                
 
114
                [Test]
 
115
                public void TestStringLiterals()
 
116
                {
 
117
                        CheckToken("\"\"", Tokens.LiteralString, "");
 
118
                        CheckToken("\"Hello, World!\"", Tokens.LiteralString, "Hello, World!");
 
119
                        CheckToken("\"\"\"\"", Tokens.LiteralString, "\"");
 
120
                }
 
121
                
 
122
                [Test]
 
123
                public void TestCharacterLiterals()
 
124
                {
 
125
                        CheckToken("\" \"c", Tokens.LiteralCharacter, ' ');
 
126
                        CheckToken("\"!\"c", Tokens.LiteralCharacter, '!');
 
127
                        CheckToken("\"\"\"\"c", Tokens.LiteralCharacter, '"');
 
128
                }
 
129
                
 
130
                [Test]
 
131
                public void TestDateLiterals()
 
132
                {
 
133
                        CheckToken("# 8/23/1970 #", Tokens.LiteralDate, new DateTime(1970, 8, 23, 0, 0, 0));
 
134
                        CheckToken("#8/23/1970#", Tokens.LiteralDate, new DateTime(1970, 8, 23, 0, 0, 0));
 
135
                        CheckToken("# 8/23/1970  3:45:39AM #", Tokens.LiteralDate, new DateTime(1970, 8, 23, 3, 45, 39));
 
136
                        CheckToken("# 3:45:39AM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 3, 45, 39));
 
137
                        CheckToken("# 3:45:39  PM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 15, 45, 39));
 
138
                        CheckToken("# 3:45:39 #", Tokens.LiteralDate, new DateTime(1, 1, 1, 3, 45, 39));
 
139
                        CheckToken("# 13:45:39 #", Tokens.LiteralDate, new DateTime(1, 1, 1, 13, 45, 39));
 
140
                        CheckToken("# 1AM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 1, 0, 0));
 
141
                }
 
142
                
 
143
                [Test]
 
144
                public void TestDouble()
 
145
                {
 
146
                        CheckToken("1.0", Tokens.LiteralDouble, 1.0);
 
147
                        CheckToken("1.1", Tokens.LiteralDouble, 1.1);
 
148
                        CheckToken("2e-5", Tokens.LiteralDouble, 2e-5);
 
149
                        CheckToken("2.0e-5", Tokens.LiteralDouble, 2e-5);
 
150
                        CheckToken("2e5", Tokens.LiteralDouble, 2e5);
 
151
                        CheckToken("2.2e5", Tokens.LiteralDouble, 2.2e5);
 
152
                        CheckToken("2e+5", Tokens.LiteralDouble, 2e5);
 
153
                        CheckToken("2.2e+5", Tokens.LiteralDouble, 2.2e5);
 
154
                        
 
155
                        CheckToken("1r", Tokens.LiteralDouble, 1.0);
 
156
                        CheckToken("1.0r", Tokens.LiteralDouble, 1.0);
 
157
                        CheckToken("1.1r", Tokens.LiteralDouble, 1.1);
 
158
                        CheckToken("2e-5r", Tokens.LiteralDouble, 2e-5);
 
159
                        CheckToken("2.0e-5r", Tokens.LiteralDouble, 2e-5);
 
160
                        CheckToken("2e5r", Tokens.LiteralDouble, 2e5);
 
161
                        CheckToken("2.2e5r", Tokens.LiteralDouble, 2.2e5);
 
162
                        CheckToken("2e+5r", Tokens.LiteralDouble, 2e5);
 
163
                        CheckToken("2.2e+5r", Tokens.LiteralDouble, 2.2e5);
 
164
                }
 
165
                
 
166
                [Test]
 
167
                public void TestSingle()
 
168
                {
 
169
                        CheckToken("1f", Tokens.LiteralSingle, 1.0f);
 
170
                        CheckToken("1.0f", Tokens.LiteralSingle, 1.0f);
 
171
                        CheckToken("1.1f", Tokens.LiteralSingle, 1.1f);
 
172
                        CheckToken("2e-5f", Tokens.LiteralSingle, 2e-5f);
 
173
                        CheckToken("2.0e-5f", Tokens.LiteralSingle, 2e-5f);
 
174
                        CheckToken("2e5f", Tokens.LiteralSingle, 2e5f);
 
175
                        CheckToken("2.2e5f", Tokens.LiteralSingle, 2.2e5f);
 
176
                        CheckToken("2e+5f", Tokens.LiteralSingle, 2e5f);
 
177
                        CheckToken("2.2e+5f", Tokens.LiteralSingle, 2.2e5f);
 
178
                }
 
179
                
 
180
                [Test]
 
181
                public void TestDecimal()
 
182
                {
 
183
                        CheckToken("1d", Tokens.LiteralDecimal, 1m);
 
184
                        CheckToken("1.0d", Tokens.LiteralDecimal, 1.0m);
 
185
                        CheckToken("1.1d", Tokens.LiteralDecimal, 1.1m);
 
186
                        CheckToken("2e-5d", Tokens.LiteralDecimal, 2e-5m);
 
187
                        CheckToken("2.0e-5d", Tokens.LiteralDecimal, 2.0e-5m);
 
188
                        CheckToken("2e5d", Tokens.LiteralDecimal, 2e5m);
 
189
                        CheckToken("2.2e5d", Tokens.LiteralDecimal, 2.2e5m);
 
190
                        CheckToken("2e+5d", Tokens.LiteralDecimal, 2e5m);
 
191
                        CheckToken("2.2e+5d", Tokens.LiteralDecimal, 2.2e5m);
 
192
                }
 
193
        }
 
194
}