mirror of https://github.com/icsharpcode/ILSpy.git
Daniel Grunwald
7 years ago
220 changed files with 0 additions and 45631 deletions
@ -1,35 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System.Reflection; |
|
||||||
using System.Runtime.CompilerServices; |
|
||||||
|
|
||||||
// Information about this assembly is defined by the following
|
|
||||||
// attributes.
|
|
||||||
//
|
|
||||||
// change them to the information which is associated with the assembly
|
|
||||||
// you compile.
|
|
||||||
|
|
||||||
[assembly: AssemblyTitle("NRefactory Test")] |
|
||||||
[assembly: AssemblyDescription("Unit tests for the parser and refactoring library for C# and VB.NET")] |
|
||||||
[assembly: AssemblyConfiguration("")] |
|
||||||
[assembly: AssemblyCompany("ic#code")] |
|
||||||
[assembly: AssemblyProduct("SharpDevelop")] |
|
||||||
[assembly: AssemblyCopyright("2004-2006 AlphaSierraPapa")] |
|
||||||
[assembly: AssemblyTrademark("")] |
|
||||||
[assembly: AssemblyCulture("")] |
|
||||||
|
|
||||||
// The assembly version has following format :
|
|
||||||
//
|
|
||||||
// Major.Minor.Build.Revision
|
|
||||||
//
|
|
||||||
// You can specify all values by your own or you can build default build and revision
|
|
||||||
// numbers with the '*' character (the default):
|
|
||||||
|
|
||||||
[assembly: AssemblyVersion("2.0.0.1")] |
|
||||||
|
|
||||||
// The following attributes specify the key for the sign of your assembly. See the
|
|
||||||
// .NET Framework documentation for more information about signing.
|
|
||||||
// This is not required, if you don't want signing let these attributes like they're.
|
|
||||||
[assembly: AssemblyDelaySign(false)] |
|
||||||
[assembly: AssemblyKeyFile("")] |
|
||||||
@ -1,102 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Reflection; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class StructuralTest |
|
||||||
{ |
|
||||||
// [Test]
|
|
||||||
// public void TestToStringMethods()
|
|
||||||
// {
|
|
||||||
// Type[] allTypes = typeof(INode).Assembly.GetTypes();
|
|
||||||
//
|
|
||||||
// foreach (Type type in allTypes) {
|
|
||||||
// if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null) {
|
|
||||||
// MethodInfo methodInfo = type.GetMethod("ToString", BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
|
|
||||||
// Assert.IsNotNull(methodInfo, "ToString() not found in " + type.FullName);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void TestUnitTests()
|
|
||||||
// {
|
|
||||||
// Type[] allTypes = typeof(StructuralTest).Assembly.GetTypes();
|
|
||||||
//
|
|
||||||
// foreach (Type type in allTypes) {
|
|
||||||
// if (type.GetCustomAttributes(typeof(TestFixtureAttribute), true).Length > 0) {
|
|
||||||
// foreach (MethodInfo m in type.GetMethods()) {
|
|
||||||
// if (m.IsPublic && m.ReturnType == typeof(void) && m.GetParameters().Length == 0) {
|
|
||||||
// if (m.GetCustomAttributes(typeof(TestAttribute), true).Length == 0) {
|
|
||||||
// Assert.Fail(type.Name + "." + m.Name + " should have the [Test] attribute!");
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void TestAcceptVisitorMethods()
|
|
||||||
// {
|
|
||||||
// Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
|
|
||||||
//
|
|
||||||
// foreach (Type type in allTypes) {
|
|
||||||
// if (type.IsClass && !type.IsAbstract && type.GetInterface(typeof(INode).FullName) != null) {
|
|
||||||
// MethodInfo methodInfo = type.GetMethod("AcceptVisitor", BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
|
|
||||||
// Assertion.AssertNotNull("AcceptVisitor() not found in " + type.FullName, methodInfo);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void TestIAstVisitor()
|
|
||||||
// {
|
|
||||||
// Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
|
|
||||||
// Type visitor = typeof(IAstVisitor);
|
|
||||||
//
|
|
||||||
// foreach (Type type in allTypes) {
|
|
||||||
// if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
|
|
||||||
// MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
|
|
||||||
// Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
|
|
||||||
// Assert.AreEqual(2, methodInfo.GetParameters().Length);
|
|
||||||
// ParameterInfo first = methodInfo.GetParameters()[0];
|
|
||||||
// Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
|
|
||||||
//
|
|
||||||
// ParameterInfo second = methodInfo.GetParameters()[1];
|
|
||||||
// Assert.AreEqual(typeof(System.Object), second.ParameterType);
|
|
||||||
// Assert.AreEqual("data", second.Name);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void TestAbstractAstVisitorVisitor()
|
|
||||||
// {
|
|
||||||
// Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
|
|
||||||
// Type visitor = typeof(AbstractAstVisitor);
|
|
||||||
//
|
|
||||||
// foreach (Type type in allTypes) {
|
|
||||||
// if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
|
|
||||||
// MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
|
|
||||||
// Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(2, methodInfo.GetParameters().Length);
|
|
||||||
// ParameterInfo first = methodInfo.GetParameters()[0];
|
|
||||||
// Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
|
|
||||||
//
|
|
||||||
// ParameterInfo second = methodInfo.GetParameters()[1];
|
|
||||||
// Assert.AreEqual(typeof(System.Object), second.ParameterType);
|
|
||||||
// Assert.AreEqual("data", second.Name);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,109 +0,0 @@ |
|||||||
<?xml version="1.0" encoding="utf-8"?> |
|
||||||
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|
||||||
<PropertyGroup> |
|
||||||
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> |
|
||||||
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> |
|
||||||
<ProductVersion>8.0.50215</ProductVersion> |
|
||||||
<SchemaVersion>2.0</SchemaVersion> |
|
||||||
<ProjectGuid>{870115DD-960A-4406-A6B9-600BCDC36A03}</ProjectGuid> |
|
||||||
<RootNamespace>ICSharpCode.NRefactory.VB.Tests</RootNamespace> |
|
||||||
<AssemblyName>ICSharpCode.NRefactory.VB.Tests</AssemblyName> |
|
||||||
<OutputTarget>Library</OutputTarget> |
|
||||||
<NoStdLib>False</NoStdLib> |
|
||||||
<NoConfig>False</NoConfig> |
|
||||||
<RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent> |
|
||||||
<OutputType>Library</OutputType> |
|
||||||
<OutputPath>bin\$(Configuration)\</OutputPath> |
|
||||||
<AllowUnsafeBlocks>False</AllowUnsafeBlocks> |
|
||||||
<WarningLevel>4</WarningLevel> |
|
||||||
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion> |
|
||||||
<TreatWarningsAsErrors>False</TreatWarningsAsErrors> |
|
||||||
<TargetFrameworkProfile>Client</TargetFrameworkProfile> |
|
||||||
<NoWin32Manifest>False</NoWin32Manifest> |
|
||||||
<IntermediateOutputPath>obj\$(Configuration)\</IntermediateOutputPath> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> |
|
||||||
<CheckForOverflowUnderflow>True</CheckForOverflowUnderflow> |
|
||||||
<DefineConstants>DEBUG</DefineConstants> |
|
||||||
<Optimize>False</Optimize> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> |
|
||||||
<Optimize>True</Optimize> |
|
||||||
<CheckForOverflowUnderflow>False</CheckForOverflowUnderflow> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> |
|
||||||
<DebugType>Full</DebugType> |
|
||||||
<DebugSymbols>true</DebugSymbols> |
|
||||||
<StartAction>Project</StartAction> |
|
||||||
<BaseIntermediateOutputPath>obj\</BaseIntermediateOutputPath> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)' == 'Release' "> |
|
||||||
<DebugSymbols>False</DebugSymbols> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Platform)' == 'AnyCPU' "> |
|
||||||
<RegisterForComInterop>False</RegisterForComInterop> |
|
||||||
<GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies> |
|
||||||
<BaseAddress>4194304</BaseAddress> |
|
||||||
<FileAlignment>4096</FileAlignment> |
|
||||||
<PlatformTarget>AnyCPU</PlatformTarget> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' "> |
|
||||||
<CheckForOverflowUnderflow>True</CheckForOverflowUnderflow> |
|
||||||
<DefineConstants>DEBUG</DefineConstants> |
|
||||||
<Optimize>False</Optimize> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' "> |
|
||||||
<Optimize>True</Optimize> |
|
||||||
<CheckForOverflowUnderflow>False</CheckForOverflowUnderflow> |
|
||||||
</PropertyGroup> |
|
||||||
<PropertyGroup Condition=" '$(Platform)' == 'x86' "> |
|
||||||
<RegisterForComInterop>False</RegisterForComInterop> |
|
||||||
<GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies> |
|
||||||
<BaseAddress>4194304</BaseAddress> |
|
||||||
<FileAlignment>4096</FileAlignment> |
|
||||||
<PlatformTarget>x86</PlatformTarget> |
|
||||||
</PropertyGroup> |
|
||||||
<ItemGroup> |
|
||||||
<Reference Include="nunit.framework"> |
|
||||||
<HintPath>..\..\ICSharpCode.Decompiler\Tests\nunit.framework.dll</HintPath> |
|
||||||
</Reference> |
|
||||||
<Reference Include="System" /> |
|
||||||
<Reference Include="System.Core"> |
|
||||||
<RequiredTargetFramework>3.5</RequiredTargetFramework> |
|
||||||
</Reference> |
|
||||||
</ItemGroup> |
|
||||||
<ItemGroup> |
|
||||||
<Compile Include="AssemblyInfo.cs" /> |
|
||||||
<Compile Include="General\UnitTest.cs" /> |
|
||||||
<Compile Include="Lexer\CustomLexerTests.cs" /> |
|
||||||
<Compile Include="Lexer\ImplicitLineContinuationTests.cs" /> |
|
||||||
<Compile Include="Lexer\LATextReaderTests.cs" /> |
|
||||||
<Compile Include="Lexer\LexerContextTests.cs" /> |
|
||||||
<Compile Include="Lexer\LexerPositionTests.cs" /> |
|
||||||
<Compile Include="Lexer\LexerTests.cs" /> |
|
||||||
<Compile Include="Lexer\LiteralsTests.cs" /> |
|
||||||
<Compile Include="Lexer\TokenTests.cs" /> |
|
||||||
<Compile Include="Lexer\XmlModeLexerTests.cs" /> |
|
||||||
<Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" /> |
|
||||||
<Compile Include="Parser\GlobalScope\NamespaceDeclarationTests.cs" /> |
|
||||||
<Compile Include="Parser\GlobalScope\ImportsStatementTests.cs" /> |
|
||||||
<Compile Include="Parser\GlobalScope\TypeDeclarationTests.cs" /> |
|
||||||
<Compile Include="Parser\SnippetParserTests.cs" /> |
|
||||||
<Compile Include="Parser\ParseUtil.cs" /> |
|
||||||
<Compile Include="Parser\GlobalScope\OptionStatementTests.cs" /> |
|
||||||
</ItemGroup> |
|
||||||
<ItemGroup> |
|
||||||
<ProjectReference Include="..\ICSharpCode.NRefactory.VB\ICSharpCode.NRefactory.VB.csproj"> |
|
||||||
<Project>{7b82b671-419f-45f4-b778-d9286f996efa}</Project> |
|
||||||
<Name>ICSharpCode.NRefactory.VB</Name> |
|
||||||
</ProjectReference> |
|
||||||
<ProjectReference Include="..\..\NRefactory\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj"> |
|
||||||
<Project>{3b2a5653-ec97-4001-bb9b-d90f1af2c371}</Project> |
|
||||||
<Name>ICSharpCode.NRefactory</Name> |
|
||||||
</ProjectReference> |
|
||||||
</ItemGroup> |
|
||||||
<ItemGroup> |
|
||||||
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> |
|
||||||
</ItemGroup> |
|
||||||
<Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" /> |
|
||||||
</Project> |
|
||||||
@ -1,118 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CustomLexerTests |
|
||||||
{ |
|
||||||
VBLexer GenerateLexer(StringReader sr) |
|
||||||
{ |
|
||||||
return new VBLexer(sr); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestSingleEOLForMulitpleLines() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("Stop\n\n\nEnd")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Stop)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.End)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestSingleEOLForMulitpleLinesWithContinuation() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("Stop\n _\n\nEnd")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Stop)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.End)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void EscapedIdentifier() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("[Stop]")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void IdentifierWithTypeCharacter() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("Stop$")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExclamationMarkIsTypeCharacter() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("a!=b")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Assign)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExclamationMarkIsTypeCharacter2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("a! b")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExclamationMarkIsIdentifier() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("a!b")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.ExclamationMark)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExclamationMarkIsIdentifier2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("a![b]")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.ExclamationMark)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void RemCommentTest() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("a rem b")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL)); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void RemCommentTest2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("REM c")); |
|
||||||
Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF)); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,230 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ImplicitLineContinuationTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void Example1() |
|
||||||
{ |
|
||||||
string code = @"Module Test
|
|
||||||
Sub Print( |
|
||||||
Param1 As Integer, |
|
||||||
Param2 As Integer) |
|
||||||
|
|
||||||
If (Param1 < Param2) Or |
|
||||||
(Param1 > Param2) Then |
|
||||||
Console.WriteLine(""Not equal"") |
|
||||||
End If |
|
||||||
End Sub |
|
||||||
End Module";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.OpenParenthesis, |
|
||||||
Tokens.Identifier, Tokens.As, Tokens.Integer, Tokens.Comma, |
|
||||||
Tokens.Identifier, Tokens.As, Tokens.Integer, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.If, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.LessThan, Tokens.Identifier, Tokens.CloseParenthesis, Tokens.Or, |
|
||||||
Tokens.OpenParenthesis, Tokens.Identifier, Tokens.GreaterThan, Tokens.Identifier, Tokens.CloseParenthesis, Tokens.Then, Tokens.EOL, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.LiteralString, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.If, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Module); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void QualifierInWith() |
|
||||||
{ |
|
||||||
string code = @"Module Test
|
|
||||||
Sub Print |
|
||||||
With xml |
|
||||||
Dim a = b. |
|
||||||
d |
|
||||||
Dim c = . |
|
||||||
Count |
|
||||||
End With |
|
||||||
End Sub |
|
||||||
End Module";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.With, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.Dot, Tokens.EOL, |
|
||||||
Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.With, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Module); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Example2() |
|
||||||
{ |
|
||||||
string code = @"Module Test
|
|
||||||
Sub Print |
|
||||||
Dim a = _ |
|
||||||
|
|
||||||
y |
|
||||||
End Sub |
|
||||||
End Module";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.EOL, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Module); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Query() |
|
||||||
{ |
|
||||||
string code = @"Module Test
|
|
||||||
Sub A |
|
||||||
Dim q = From x In a |
|
||||||
Select x |
|
||||||
End Sub |
|
||||||
End Module";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, |
|
||||||
Tokens.Select, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Module); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Query1() |
|
||||||
{ |
|
||||||
string code = @"Module Test
|
|
||||||
Sub A |
|
||||||
Dim actions = From a in b Select Sub() |
|
||||||
Dim i = 1 |
|
||||||
Select Case i |
|
||||||
End Select |
|
||||||
End Sub |
|
||||||
End Sub |
|
||||||
End Module";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Select, Tokens.Sub, Tokens.OpenParenthesis, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.Select, Tokens.Case, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Select, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Module); |
|
||||||
} |
|
||||||
|
|
||||||
/// <remarks>tests http://community.sharpdevelop.net/forums/p/12068/32893.aspx#32893</remarks>
|
|
||||||
[Test] |
|
||||||
public void Bug_Thread12068() |
|
||||||
{ |
|
||||||
string code = @"Class MainClass
|
|
||||||
Public Shared Sub Main() |
|
||||||
Dim categoryNames = From p In AList _ |
|
||||||
Select p.AFunction(1,2,3) _ |
|
||||||
Distinct |
|
||||||
End Sub |
|
||||||
End Class";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens( |
|
||||||
lexer, Tokens.Class, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Public, Tokens.Shared, Tokens.Sub, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, |
|
||||||
Tokens.Select, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.LiteralInteger, |
|
||||||
Tokens.Comma, Tokens.LiteralInteger, Tokens.Comma, Tokens.LiteralInteger, Tokens.CloseParenthesis, |
|
||||||
Tokens.Distinct, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Class |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void LineContinuationAfterAttributes() |
|
||||||
{ |
|
||||||
string code = @"<TestFixture>
|
|
||||||
Public Class TestContinuation |
|
||||||
<Test> |
|
||||||
Public Sub TestMethod |
|
||||||
Assert.Fail |
|
||||||
End Sub |
|
||||||
|
|
||||||
<Test> _ |
|
||||||
Public Sub TestMethod2 |
|
||||||
Assert.Fail |
|
||||||
End Sub |
|
||||||
End Class";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens( |
|
||||||
lexer, Tokens.LessThan, Tokens.Identifier, Tokens.GreaterThan, |
|
||||||
Tokens.Public, Tokens.Class, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.LessThan, Tokens.Identifier, Tokens.GreaterThan, |
|
||||||
Tokens.Public, Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.LessThan, Tokens.Identifier, Tokens.GreaterThan, |
|
||||||
Tokens.Public, Tokens.Sub, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Class |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NoILCAfterGlobalAttributes() |
|
||||||
{ |
|
||||||
string code = "<Assembly: AssemblyTitle(\"My.UnitTests\")>" + Environment.NewLine + |
|
||||||
"<Assembly: AssemblyDescription(\"\")>"; |
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens( |
|
||||||
lexer, Tokens.LessThan, Tokens.Assembly, Tokens.Colon, |
|
||||||
Tokens.Identifier, Tokens.OpenParenthesis, Tokens.LiteralString, |
|
||||||
Tokens.CloseParenthesis, Tokens.GreaterThan, Tokens.EOL, |
|
||||||
Tokens.LessThan, Tokens.Assembly, Tokens.Colon, |
|
||||||
Tokens.Identifier, Tokens.OpenParenthesis, Tokens.LiteralString, |
|
||||||
Tokens.CloseParenthesis, Tokens.GreaterThan |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
#region Helpers
|
|
||||||
VBLexer GenerateLexer(StringReader sr) |
|
||||||
{ |
|
||||||
return new VBLexer(sr); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckTokens(VBLexer lexer, params int[] tokens) |
|
||||||
{ |
|
||||||
for (int i = 0; i < tokens.Length; i++) { |
|
||||||
int token = tokens[i]; |
|
||||||
Token t = lexer.NextToken(); |
|
||||||
int next = t.Kind; |
|
||||||
Assert.AreEqual(token, next, "{2} of {3}: {0} != {1}; at {4}", Tokens.GetTokenString(token), Tokens.GetTokenString(next), i + 1, tokens.Length, t.Location); |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,35 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LATextReaderTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void TestPeek() |
|
||||||
{ |
|
||||||
LATextReader reader = new LATextReader(new StringReader("abcd")); |
|
||||||
|
|
||||||
CheckPeek(reader, 0, 'a'); |
|
||||||
CheckPeek(reader, 2, 'c'); |
|
||||||
CheckPeek(reader, 3, 'd'); |
|
||||||
CheckPeek(reader, 1, 'b'); |
|
||||||
CheckPeek(reader, 0, 'a'); |
|
||||||
Assert.AreEqual((int)'a', reader.Read()); |
|
||||||
CheckPeek(reader, 1, 'c'); |
|
||||||
CheckPeek(reader, 2, 'd'); |
|
||||||
CheckPeek(reader, 0, 'b'); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckPeek(LATextReader reader, int num1, char char2) |
|
||||||
{ |
|
||||||
Assert.AreEqual((int)char2, reader.Peek(num1)); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,575 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LexerContextTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void SimpleGlobal() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Option Explicit", |
|
||||||
@"enter Global
|
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VariableWithXmlLiteral() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class Test
|
|
||||||
Public Sub New() |
|
||||||
Dim x = <a /> |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Xml |
|
||||||
enter Xml |
|
||||||
exit Xml |
|
||||||
exit Xml |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MemberWithXmlLiteral() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class Test
|
|
||||||
Private xml As XElement = <b /> |
|
||||||
|
|
||||||
Public Sub New() |
|
||||||
Dim x = <a /> |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Type |
|
||||||
exit Type |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Xml |
|
||||||
enter Xml |
|
||||||
exit Xml |
|
||||||
exit Xml |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Member |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Xml |
|
||||||
enter Xml |
|
||||||
exit Xml |
|
||||||
exit Xml |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GlobalAttributeTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"<assembly: CLSCompliant(True)>
|
|
||||||
Class Test |
|
||||||
Public Sub New() |
|
||||||
Dim x = 5 |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter Attribute |
|
||||||
exit Attribute |
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ClassAttributeTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"<Serializable>
|
|
||||||
Class Test |
|
||||||
Public Sub New() |
|
||||||
Dim x = 5 |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter Attribute |
|
||||||
exit Attribute |
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MethodAttributeTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class Test
|
|
||||||
<Test> |
|
||||||
Public Sub New() |
|
||||||
Dim x = 5 |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Attribute |
|
||||||
exit Attribute |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WithBlockTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class Test
|
|
||||||
Public Sub New() |
|
||||||
With x |
|
||||||
|
|
||||||
End With |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void StatementsTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class Test
|
|
||||||
Public Sub New() |
|
||||||
For i As Integer = 0 To 10 |
|
||||||
|
|
||||||
Next |
|
||||||
|
|
||||||
For Each x As Integer In list |
|
||||||
|
|
||||||
Next |
|
||||||
|
|
||||||
Try |
|
||||||
|
|
||||||
Catch e As Exception |
|
||||||
|
|
||||||
End Try |
|
||||||
End Sub |
|
||||||
End Class |
|
||||||
",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Identifier |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Identifier |
|
||||||
enter Type |
|
||||||
exit Type |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
enter Identifier |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Identifier |
|
||||||
enter Type |
|
||||||
exit Type |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Type |
|
||||||
exit Type |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
"
|
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ClassTest() |
|
||||||
{ |
|
||||||
RunTest( |
|
||||||
@"Class MainClass ' a comment
|
|
||||||
Dim under_score_field As Integer |
|
||||||
Sub SomeMethod() |
|
||||||
simple += 1 |
|
||||||
For Each loopVarName In collection |
|
||||||
Next |
|
||||||
End Sub |
|
||||||
End Class",
|
|
||||||
@"enter Global
|
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Type |
|
||||||
exit Type |
|
||||||
exit Member |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Identifier |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Body |
|
||||||
exit Body |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CollectionInitializer() |
|
||||||
{ |
|
||||||
RunTest(@"'
|
|
||||||
' Created by SharpDevelop. |
|
||||||
' User: Siegfried |
|
||||||
' Date: 22.06.2010 |
|
||||||
' Time: 21:29 |
|
||||||
' |
|
||||||
' To change this template use Tools | Options | Coding | Edit Standard Headers. |
|
||||||
' |
|
||||||
|
|
||||||
Option Infer On |
|
||||||
|
|
||||||
Imports System.Linq |
|
||||||
Imports System.Xml.Linq |
|
||||||
|
|
||||||
Module Program |
|
||||||
Sub Main() |
|
||||||
Console.WriteLine(""Hello World!"") |
|
||||||
|
|
||||||
Dim name = ""Test"" |
|
||||||
Dim content = { 4, 5, New XAttribute(""a"", 3) } |
|
||||||
|
|
||||||
Dim xml = <<%= name %> <%= content %> /> |
|
||||||
|
|
||||||
Console.ReadKey() |
|
||||||
End Sub |
|
||||||
End Module",
|
|
||||||
@"enter Global
|
|
||||||
enter Importable |
|
||||||
exit Importable |
|
||||||
enter Importable |
|
||||||
exit Importable |
|
||||||
enter TypeDeclaration |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Member |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Body |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter ObjectCreation |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit ObjectCreation |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Identifier |
|
||||||
exit Identifier |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Xml |
|
||||||
enter Xml |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Xml |
|
||||||
exit Xml |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
enter Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Expression |
|
||||||
exit Body |
|
||||||
exit Member |
|
||||||
exit TypeDeclaration |
|
||||||
exit Global |
|
||||||
");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Imports() |
|
||||||
{ |
|
||||||
RunTest(@"Imports System
|
|
||||||
Imports System.Linq |
|
||||||
Imports System.Collections.Generic",
|
|
||||||
@"enter Global
|
|
||||||
enter Importable |
|
||||||
exit Importable |
|
||||||
enter Importable |
|
||||||
exit Importable |
|
||||||
enter Importable |
|
||||||
exit Importable |
|
||||||
exit Global |
|
||||||
");
|
|
||||||
} |
|
||||||
|
|
||||||
void RunTest(string code, string expectedOutput) |
|
||||||
{ |
|
||||||
ExpressionFinder p = new ExpressionFinder(); |
|
||||||
VBLexer lexer = new VBLexer(new StringReader(code)); |
|
||||||
Token t; |
|
||||||
|
|
||||||
do { |
|
||||||
t = lexer.NextToken(); |
|
||||||
p.InformToken(t); |
|
||||||
} while (t.Kind != Tokens.EOF); |
|
||||||
|
|
||||||
Console.WriteLine(p.Output); |
|
||||||
|
|
||||||
Assert.IsEmpty(p.Errors); |
|
||||||
|
|
||||||
Assert.AreEqual(expectedOutput.Replace("\r", ""), |
|
||||||
p.Output.Replace("\r", "")); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,87 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LexerPositionTests |
|
||||||
{ |
|
||||||
VBLexer GenerateLexer(string s) |
|
||||||
{ |
|
||||||
return new VBLexer(new StringReader(s)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestNewLine() |
|
||||||
{ |
|
||||||
VBLexer l = GenerateLexer("public\nstatic"); |
|
||||||
Token t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.Public, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 1), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.EndLocation); |
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOL, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 1), t.EndLocation); |
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.Static, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(2, 1), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 7), t.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestCarriageReturnNewLine() |
|
||||||
{ |
|
||||||
VBLexer l = GenerateLexer("public\r\nstatic"); |
|
||||||
Token t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.Public, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 1), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.EndLocation); |
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOL, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 1), t.EndLocation); |
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.Static, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(2, 1), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 7), t.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestPositionOfEOF1() |
|
||||||
{ |
|
||||||
VBLexer l = GenerateLexer("public"); |
|
||||||
l.NextToken(); // public
|
|
||||||
Token t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOL, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.EndLocation); |
|
||||||
|
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOF, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(1, 7), t.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestPositionOfEOF2() |
|
||||||
{ |
|
||||||
VBLexer l = GenerateLexer("public _\n "); |
|
||||||
l.NextToken(); // public
|
|
||||||
Token t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOL, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(2, 2), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 2), t.EndLocation); |
|
||||||
|
|
||||||
t = l.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOF, t.Kind); |
|
||||||
Assert.AreEqual(new TextLocation(2, 2), t.Location); |
|
||||||
Assert.AreEqual(new TextLocation(2, 2), t.EndLocation); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,194 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public sealed class LiteralsTests |
|
||||||
{ |
|
||||||
VBLexer GenerateLexer(StringReader sr) |
|
||||||
{ |
|
||||||
return new VBLexer(sr); |
|
||||||
} |
|
||||||
|
|
||||||
Token GetSingleToken(string text) |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(text)); |
|
||||||
Token t = lexer.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL"); |
|
||||||
Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF"); |
|
||||||
Assert.AreEqual("", lexer.Errors.ErrorOutput); |
|
||||||
return t; |
|
||||||
} |
|
||||||
|
|
||||||
void CheckToken(string text, int tokenType, object val) |
|
||||||
{ |
|
||||||
Token t = GetSingleToken(text); |
|
||||||
Assert.AreEqual(tokenType, t.Kind, "Tokens.Literal"); |
|
||||||
Assert.IsNotNull(t.LiteralValue, "literalValue is null"); |
|
||||||
Assert.AreEqual(val.GetType(), t.LiteralValue.GetType(), "literalValue.GetType()"); |
|
||||||
Assert.AreEqual(val, t.LiteralValue, "literalValue"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestSingleDigit() |
|
||||||
{ |
|
||||||
CheckToken("5", Tokens.LiteralInteger, 5); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestZero() |
|
||||||
{ |
|
||||||
CheckToken("0", Tokens.LiteralInteger, 0); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestInteger() |
|
||||||
{ |
|
||||||
CheckToken("15", Tokens.LiteralInteger, 15); |
|
||||||
CheckToken("8581", Tokens.LiteralInteger, 8581); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InvalidTypeCharacter() |
|
||||||
{ |
|
||||||
// just check that we don't get exceptions:
|
|
||||||
GenerateLexer(new StringReader(".5s")).NextToken(); |
|
||||||
GenerateLexer(new StringReader(".5ul")).NextToken(); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestHexadecimalInteger() |
|
||||||
{ |
|
||||||
CheckToken("&H10", Tokens.LiteralInteger, 0x10); |
|
||||||
CheckToken("&H10&", Tokens.LiteralInteger, (long)0x10); |
|
||||||
CheckToken("&h3ff%", Tokens.LiteralInteger, 0x3ff); |
|
||||||
CheckToken("&h8000s", Tokens.LiteralInteger, short.MinValue); |
|
||||||
CheckToken("&h8000us", Tokens.LiteralInteger, (ushort)0x8000); |
|
||||||
CheckToken("&HffffFFFF", Tokens.LiteralInteger, -1); |
|
||||||
CheckToken("&HffffFFFF%", Tokens.LiteralInteger, -1); |
|
||||||
CheckToken("&HffffFFFFui", Tokens.LiteralInteger, uint.MaxValue); |
|
||||||
CheckToken("&HffffFFFF&", Tokens.LiteralInteger, (long)uint.MaxValue); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestLongHexadecimalInteger() |
|
||||||
{ |
|
||||||
CheckToken("&H4244636f446c6d58", Tokens.LiteralInteger, 0x4244636f446c6d58); |
|
||||||
CheckToken("&hf244636f446c6d58", Tokens.LiteralInteger, -989556688574190248); |
|
||||||
CheckToken("&hf244636f446c6d58&", Tokens.LiteralInteger, -989556688574190248); |
|
||||||
CheckToken("&hf244636f446c6d58ul", Tokens.LiteralInteger, 0xf244636f446c6d58); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InvalidHexadecimalInteger() |
|
||||||
{ |
|
||||||
// just check that we don't get exceptions:
|
|
||||||
GenerateLexer(new StringReader("&H")).NextToken(); |
|
||||||
// >ulong.MaxValue
|
|
||||||
GenerateLexer(new StringReader("&hff244636f446c6d58")).NextToken(); |
|
||||||
// needs an ulong, but "i" postfix specified integer
|
|
||||||
GenerateLexer(new StringReader("&hf244636f446c6d58i")).NextToken(); |
|
||||||
GenerateLexer(new StringReader("&hf244636f446c6d58ui")).NextToken(); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestIncompleteHexadecimal() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader("&H\r\nabc")); |
|
||||||
Token t = lexer.NextToken(); |
|
||||||
Assert.AreEqual(Tokens.LiteralInteger, t.Kind); |
|
||||||
Assert.AreEqual(0, (int)t.LiteralValue); |
|
||||||
Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (1)"); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind, "Tokens.Identifier"); |
|
||||||
Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (2)"); |
|
||||||
Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF"); |
|
||||||
Assert.AreNotEqual("", lexer.Errors.ErrorOutput); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestStringLiterals() |
|
||||||
{ |
|
||||||
CheckToken("\"\"", Tokens.LiteralString, ""); |
|
||||||
CheckToken("\"Hello, World!\"", Tokens.LiteralString, "Hello, World!"); |
|
||||||
CheckToken("\"\"\"\"", Tokens.LiteralString, "\""); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestCharacterLiterals() |
|
||||||
{ |
|
||||||
CheckToken("\" \"c", Tokens.LiteralCharacter, ' '); |
|
||||||
CheckToken("\"!\"c", Tokens.LiteralCharacter, '!'); |
|
||||||
CheckToken("\"\"\"\"c", Tokens.LiteralCharacter, '"'); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestDateLiterals() |
|
||||||
{ |
|
||||||
CheckToken("# 8/23/1970 #", Tokens.LiteralDate, new DateTime(1970, 8, 23, 0, 0, 0)); |
|
||||||
CheckToken("#8/23/1970#", Tokens.LiteralDate, new DateTime(1970, 8, 23, 0, 0, 0)); |
|
||||||
CheckToken("# 8/23/1970 3:45:39AM #", Tokens.LiteralDate, new DateTime(1970, 8, 23, 3, 45, 39)); |
|
||||||
CheckToken("# 3:45:39AM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 3, 45, 39)); |
|
||||||
CheckToken("# 3:45:39 PM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 15, 45, 39)); |
|
||||||
CheckToken("# 3:45:39 #", Tokens.LiteralDate, new DateTime(1, 1, 1, 3, 45, 39)); |
|
||||||
CheckToken("# 13:45:39 #", Tokens.LiteralDate, new DateTime(1, 1, 1, 13, 45, 39)); |
|
||||||
CheckToken("# 1AM #", Tokens.LiteralDate, new DateTime(1, 1, 1, 1, 0, 0)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestDouble() |
|
||||||
{ |
|
||||||
CheckToken("1.0", Tokens.LiteralDouble, 1.0); |
|
||||||
CheckToken("1.1", Tokens.LiteralDouble, 1.1); |
|
||||||
CheckToken("2e-5", Tokens.LiteralDouble, 2e-5); |
|
||||||
CheckToken("2.0e-5", Tokens.LiteralDouble, 2e-5); |
|
||||||
CheckToken("2e5", Tokens.LiteralDouble, 2e5); |
|
||||||
CheckToken("2.2e5", Tokens.LiteralDouble, 2.2e5); |
|
||||||
CheckToken("2e+5", Tokens.LiteralDouble, 2e5); |
|
||||||
CheckToken("2.2e+5", Tokens.LiteralDouble, 2.2e5); |
|
||||||
|
|
||||||
CheckToken("1r", Tokens.LiteralDouble, 1.0); |
|
||||||
CheckToken("1.0r", Tokens.LiteralDouble, 1.0); |
|
||||||
CheckToken("1.1r", Tokens.LiteralDouble, 1.1); |
|
||||||
CheckToken("2e-5r", Tokens.LiteralDouble, 2e-5); |
|
||||||
CheckToken("2.0e-5r", Tokens.LiteralDouble, 2e-5); |
|
||||||
CheckToken("2e5r", Tokens.LiteralDouble, 2e5); |
|
||||||
CheckToken("2.2e5r", Tokens.LiteralDouble, 2.2e5); |
|
||||||
CheckToken("2e+5r", Tokens.LiteralDouble, 2e5); |
|
||||||
CheckToken("2.2e+5r", Tokens.LiteralDouble, 2.2e5); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestSingle() |
|
||||||
{ |
|
||||||
CheckToken("1f", Tokens.LiteralSingle, 1.0f); |
|
||||||
CheckToken("1.0f", Tokens.LiteralSingle, 1.0f); |
|
||||||
CheckToken("1.1f", Tokens.LiteralSingle, 1.1f); |
|
||||||
CheckToken("2e-5f", Tokens.LiteralSingle, 2e-5f); |
|
||||||
CheckToken("2.0e-5f", Tokens.LiteralSingle, 2e-5f); |
|
||||||
CheckToken("2e5f", Tokens.LiteralSingle, 2e5f); |
|
||||||
CheckToken("2.2e5f", Tokens.LiteralSingle, 2.2e5f); |
|
||||||
CheckToken("2e+5f", Tokens.LiteralSingle, 2e5f); |
|
||||||
CheckToken("2.2e+5f", Tokens.LiteralSingle, 2.2e5f); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TestDecimal() |
|
||||||
{ |
|
||||||
CheckToken("1d", Tokens.LiteralDecimal, 1m); |
|
||||||
CheckToken("1.0d", Tokens.LiteralDecimal, 1.0m); |
|
||||||
CheckToken("1.1d", Tokens.LiteralDecimal, 1.1m); |
|
||||||
CheckToken("2e-5d", Tokens.LiteralDecimal, 2e-5m); |
|
||||||
CheckToken("2.0e-5d", Tokens.LiteralDecimal, 2.0e-5m); |
|
||||||
CheckToken("2e5d", Tokens.LiteralDecimal, 2e5m); |
|
||||||
CheckToken("2.2e5d", Tokens.LiteralDecimal, 2.2e5m); |
|
||||||
CheckToken("2e+5d", Tokens.LiteralDecimal, 2e5m); |
|
||||||
CheckToken("2.2e+5d", Tokens.LiteralDecimal, 2.2e5m); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TokenTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void TokenToStringDoesNotThrowException() |
|
||||||
{ |
|
||||||
Assert.DoesNotThrow( |
|
||||||
() => { |
|
||||||
string text = new Token(71, 1, 1).ToString(); |
|
||||||
} |
|
||||||
); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,993 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Lexer |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class XmlModeLexerTests |
|
||||||
{ |
|
||||||
#region Xml Tests
|
|
||||||
[Test] |
|
||||||
public void TagWithContent() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test>Hello World</Test>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
Assert.AreEqual(Tokens.Dim, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Assign, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlOpenTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlContent, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlOpenEndTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void HtmlText() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <div><h1>Title</h1>" + |
|
||||||
"<p>test test <br /> test</p></div>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
Assert.AreEqual(Tokens.Dim, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Assign, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// <div>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// <h1>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// Title
|
|
||||||
Assert.AreEqual(Tokens.XmlContent, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// </h1>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenEndTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// <p>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// test test
|
|
||||||
Assert.AreEqual(Tokens.XmlContent, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// <br />
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTagEmptyElement, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// test
|
|
||||||
Assert.AreEqual(Tokens.XmlContent, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// </p>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenEndTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
// </div>
|
|
||||||
Assert.AreEqual(Tokens.XmlOpenEndTag, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind); |
|
||||||
Assert.AreEqual(Tokens.XmlCloseTag, lexer.NextToken().Kind); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlLiteralsExample1() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim xml = <menu>\n" + |
|
||||||
" <course name=\"appetizer\">\n" + |
|
||||||
" <dish>Shrimp Cocktail</dish>\n" + |
|
||||||
" <dish>Escargot</dish>\n" + |
|
||||||
" </course>\n" + |
|
||||||
" <course name=\"main\">\n" + |
|
||||||
" <dish>Filet Mignon</dish>\n" + |
|
||||||
" <dish>Garlic Potatoes</dish>\n" + |
|
||||||
" <dish>Broccoli</dish>\n" + |
|
||||||
" </course>\n" + |
|
||||||
" <course name=\"dessert\">\n" + |
|
||||||
" <dish>Chocolate Cheesecake</dish>\n" + |
|
||||||
" </course>\n" + |
|
||||||
" </menu>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
// <menu>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <course name=\"appetizer\">
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Shrimp Cocktail</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Escargot</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// </course>
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <course name=\"main\">
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Filet Mignon</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Garlic Potatoes</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Broccoli</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// </course>
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <course name=\"dessert\">
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// <dish>Chocolate Cheesecake</dish>
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// </course>
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
// whitespaces
|
|
||||||
Tokens.XmlContent, |
|
||||||
// </menu>
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleXmlWithComments() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = <?xml version=""1.0""?> <!-- Test file -->
|
|
||||||
<Test> |
|
||||||
<!-- Test data --> |
|
||||||
<Data /> |
|
||||||
</Test> |
|
||||||
<!-- eof --> |
|
||||||
<!-- hey, wait! --> |
|
||||||
<?target some data?>")));
|
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.XmlProcessingInstruction, Tokens.XmlContent, Tokens.XmlComment, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlComment, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, |
|
||||||
Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlComment, Tokens.XmlComment, Tokens.XmlProcessingInstruction); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleEmptyTag() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test />"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleTag() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test></Test>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlOpenEndTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlImport() |
|
||||||
{ |
|
||||||
string code = @"Imports System
|
|
||||||
Imports System.Linq |
|
||||||
|
|
||||||
Imports <xmlns='http://icsharpcode.net/sharpdevelop/avalonedit'>
|
|
||||||
Imports <xmlns:h='http://www.w3.org/TR/html4/'>
|
|
||||||
|
|
||||||
Class TestClass |
|
||||||
Sub TestSub() |
|
||||||
Dim xml = <h:table> |
|
||||||
<h:tr> |
|
||||||
<h:td>1. Cell</h:td> |
|
||||||
</h:tr> |
|
||||||
</h:table> |
|
||||||
End Sub |
|
||||||
End Class";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(code)); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Imports, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Imports, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Imports, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.EOL, |
|
||||||
Tokens.Imports, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.EOL, |
|
||||||
Tokens.Class, Tokens.Identifier, Tokens.EOL, Tokens.Sub, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.EOL, Tokens.End, Tokens.Sub, Tokens.EOL, Tokens.End, Tokens.Class |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CDataSection() |
|
||||||
{ |
|
||||||
string xml = @"Dim xml = <template>
|
|
||||||
<name>test</name> |
|
||||||
<language>VB</languge> |
|
||||||
<file language='XAML'> |
|
||||||
<![CDATA[<Window x:Class='DefaultNamespace.Window1' |
|
||||||
xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
|
|
||||||
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
|
|
||||||
Title='DefaultNamespace' Height='300' Width='300'> |
|
||||||
<Grid> |
|
||||||
|
|
||||||
</Grid> |
|
||||||
</Window>]]> |
|
||||||
</file> |
|
||||||
<file language='CSharp'> |
|
||||||
<![CDATA[using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
using System.Text; |
|
||||||
using System.Windows; |
|
||||||
using System.Windows.Controls; |
|
||||||
using System.Windows.Data; |
|
||||||
using System.Windows.Documents; |
|
||||||
using System.Windows.Input; |
|
||||||
using System.Windows.Media; |
|
||||||
|
|
||||||
namespace DefaultNamespace |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// Interaction logic for Window1.xaml
|
|
||||||
/// </summary>
|
|
||||||
public partial class Window1 : Window |
|
||||||
{ |
|
||||||
public Window1() |
|
||||||
{ |
|
||||||
InitializeComponent(); |
|
||||||
} |
|
||||||
} |
|
||||||
}]]> |
|
||||||
</file> |
|
||||||
</template> |
|
||||||
";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(xml))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, // 2
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, // 6
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, // 10
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, // 14
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, // 18
|
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, // 22
|
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, // 28
|
|
||||||
Tokens.XmlContent, Tokens.XmlCData, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, // 34
|
|
||||||
Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlCData, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag |
|
||||||
); |
|
||||||
|
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InlineVB() |
|
||||||
{ |
|
||||||
string code = @"Dim xml = <?xml version='1.0'?>
|
|
||||||
<menu> |
|
||||||
<course name=""appetizer""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""appetizer"" _ |
|
||||||
Select <dish><%= m.Food %></dish> _ |
|
||||||
%> |
|
||||||
</course> |
|
||||||
<course name=""main""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""main"" _ |
|
||||||
Select <dish><%= m.Food %></dish> _ |
|
||||||
%> |
|
||||||
</course> |
|
||||||
<course name=""dessert""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""dessert"" _ |
|
||||||
Select <dish><%= m.Food %></dish> _ |
|
||||||
%> |
|
||||||
</course> |
|
||||||
</menu>";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlProcessingInstruction, Tokens.XmlContent, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlStartInlineVB, |
|
||||||
Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Where, Tokens.Identifier, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.Select, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.XmlCloseTag, Tokens.XmlStartInlineVB, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.XmlEndInlineVB, |
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlEndInlineVB, Tokens.XmlContent, Tokens.XmlOpenEndTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlStartInlineVB, |
|
||||||
Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Where, Tokens.Identifier, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.Select, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.XmlCloseTag, Tokens.XmlStartInlineVB, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.XmlEndInlineVB, |
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlEndInlineVB, Tokens.XmlContent, Tokens.XmlOpenEndTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlStartInlineVB, |
|
||||||
Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Where, Tokens.Identifier, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.Select, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.XmlCloseTag, Tokens.XmlStartInlineVB, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.XmlEndInlineVB, |
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlEndInlineVB, Tokens.XmlContent, Tokens.XmlOpenEndTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InlineVB2() |
|
||||||
{ |
|
||||||
string code = @"Dim contact As XElement = <<%=elementName %>>
|
|
||||||
<name><%= MyName %></name> |
|
||||||
</>";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.As, Tokens.Identifier, Tokens.Assign, Tokens.XmlOpenTag, |
|
||||||
Tokens.XmlStartInlineVB, Tokens.Identifier, Tokens.XmlEndInlineVB, Tokens.XmlCloseTag, Tokens.XmlContent, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlStartInlineVB, Tokens.Identifier, Tokens.XmlEndInlineVB, |
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.XmlCloseTag); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlAccessOperators() |
|
||||||
{ |
|
||||||
string code = @"Dim childAxis = xml.<menu>.<course>
|
|
||||||
Dim course3 = xml...<course>(2) |
|
||||||
Dim childAxis = xml...<course> |
|
||||||
For Each item In childAxis |
|
||||||
Console.WriteLine(item.@name) |
|
||||||
Next";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.Identifier, Tokens.Dot, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.Dot, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, |
|
||||||
Tokens.EOL, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.Identifier, Tokens.TripleDot, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.OpenParenthesis, Tokens.LiteralInteger, Tokens.CloseParenthesis, |
|
||||||
Tokens.EOL, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.Identifier, Tokens.TripleDot, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag, Tokens.EOL, Tokens.For, Tokens.Each, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.DotAt, Tokens.Identifier, Tokens.CloseParenthesis, Tokens.EOL, |
|
||||||
Tokens.Next); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GetXmlNamespace() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(x)"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.GetXmlNamespace, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.CloseParenthesis); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GetXmlNamespace2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(db-name)"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.GetXmlNamespace, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.CloseParenthesis); |
|
||||||
|
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlInSelect() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim data = From x In list Select <test>x</test>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Select, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenEndTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTag); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void IfExpressionTest() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = If(a <> 2, 4, 8)"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.If, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.NotEqual, Tokens.LiteralInteger, |
|
||||||
Tokens.Comma, Tokens.LiteralInteger, Tokens.Comma, Tokens.LiteralInteger, Tokens.CloseParenthesis); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void IfStatementTest() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("If a <> 2 Then Return"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.If, Tokens.Identifier, Tokens.NotEqual, Tokens.LiteralInteger, |
|
||||||
Tokens.Then, Tokens.Return); |
|
||||||
|
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Bug1() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test -->"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlComment); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Bug2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <?xml?><Data /><!-- test -->"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.XmlProcessingInstruction, Tokens.XmlOpenTag, Tokens.Identifier, |
|
||||||
Tokens.XmlCloseTagEmptyElement, Tokens.XmlComment); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Bug3() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexerForSnippet(new StringReader("New String() {}"), SnippetType.Expression); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.New, Tokens.String, Tokens.OpenParenthesis, |
|
||||||
Tokens.CloseParenthesis, Tokens.OpenCurlyBrace, Tokens.CloseCurlyBrace); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Bug4() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = From kvp As KeyValuePair(Of String, DataGridViewCellStyle) In styleCache.CellStyleCache _
|
|
||||||
Select includeStyle(kvp.Key, kvp.Value)")));
|
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.From, Tokens.Identifier, Tokens.As, Tokens.Identifier, |
|
||||||
Tokens.OpenParenthesis, Tokens.Of, Tokens.String, Tokens.Comma, Tokens.Identifier, Tokens.CloseParenthesis, |
|
||||||
Tokens.In, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, |
|
||||||
Tokens.Select, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.Identifier, Tokens.Dot, Tokens.Key, Tokens.Comma, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.CloseParenthesis); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void LessThanCheck() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test --><Data"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.XmlComment, Tokens.LessThan, Tokens.Identifier); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
#region Context Tests
|
|
||||||
[Test] |
|
||||||
public void MethodInvocation() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("DoSomething(<Test />, True)"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, Tokens.True, |
|
||||||
Tokens.CloseParenthesis); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AddHandlerStatement() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <Test />, True"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.AddHandler, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, Tokens.True); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AddHandlerStatement2() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <x />, <y />"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.AddHandler, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTagEmptyElement); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void RemoveHandlerStatement() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("RemoveHandler <x />, <Data>5</Data>"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.RemoveHandler, Tokens.XmlOpenTag, |
|
||||||
Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, |
|
||||||
Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ErrorHandlingStatement() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("On Error Resume Next\n" + |
|
||||||
"On Error GoTo -1\n" + |
|
||||||
"On Error GoTo 0\n" + |
|
||||||
"On Error GoTo Test\n" + |
|
||||||
"Error 5\n" + |
|
||||||
"Error <Test />\n" + |
|
||||||
"Resume Next\n" + |
|
||||||
"Resume Label\n" + |
|
||||||
"Resume 4"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.On, Tokens.Error, Tokens.Resume, Tokens.Next, Tokens.EOL, |
|
||||||
Tokens.On, Tokens.Error, Tokens.GoTo, Tokens.Minus, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.On, Tokens.Error, Tokens.GoTo, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.On, Tokens.Error, Tokens.GoTo, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Error, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.Error, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Resume, Tokens.Next, Tokens.EOL, |
|
||||||
Tokens.Resume, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Resume, Tokens.LiteralInteger |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ForLoopStatement() |
|
||||||
{ |
|
||||||
string statement = @"For <Test /> = <Test /> To <Test /> Step <Test />
|
|
||||||
Next <Test />, <Test /> |
|
||||||
|
|
||||||
For Each <Test /> In <Test /> |
|
||||||
Next <Test />";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.For, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, |
|
||||||
Tokens.Assign, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, |
|
||||||
Tokens.To, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, |
|
||||||
Tokens.Step, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Next, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.For, Tokens.Each, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, |
|
||||||
Tokens.In, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Next, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WhileLoopStatement() |
|
||||||
{ |
|
||||||
string statement = @"While <Test />
|
|
||||||
End While";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.While, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.While |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WhileLoopStatement2() |
|
||||||
{ |
|
||||||
string statement = @"Do While <Test />
|
|
||||||
Loop";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Do, Tokens.While, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Loop |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WhileLoopStatement3() |
|
||||||
{ |
|
||||||
string statement = @"Do
|
|
||||||
Loop While <Test />";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Do, Tokens.EOL, |
|
||||||
Tokens.Loop, Tokens.While, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UntilLoopStatement() |
|
||||||
{ |
|
||||||
string statement = @"Do Until <Test />
|
|
||||||
Loop";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Do, Tokens.Until, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Loop |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UntilLoopStatement2() |
|
||||||
{ |
|
||||||
string statement = @"Do
|
|
||||||
Loop Until <Test />";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Do, Tokens.EOL, |
|
||||||
Tokens.Loop, Tokens.Until, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void IfStatementLarge() |
|
||||||
{ |
|
||||||
string statement = @"If <Test /> Then
|
|
||||||
Else If <Test /> Then |
|
||||||
ElseIf <Test></Test> Then |
|
||||||
Else |
|
||||||
End If";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.If, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Then, Tokens.EOL, |
|
||||||
Tokens.Else, Tokens.If, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Then, Tokens.EOL, |
|
||||||
Tokens.ElseIf, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.Then, Tokens.EOL, |
|
||||||
Tokens.Else, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.If |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SelectStatement() |
|
||||||
{ |
|
||||||
string statement = @"Select Case <Test />
|
|
||||||
Case <Test />, <Test /> |
|
||||||
Case Else |
|
||||||
End Select";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Select, Tokens.Case, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Case, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Case, Tokens.Else, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Select |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TryStatement() |
|
||||||
{ |
|
||||||
string statement = @"Try
|
|
||||||
Catch x |
|
||||||
Catch y As Exception |
|
||||||
Catch When <Test /> |
|
||||||
Finally |
|
||||||
End Try";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Try, Tokens.EOL, |
|
||||||
Tokens.Catch, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Catch, Tokens.Identifier, Tokens.As, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Catch, Tokens.When, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Finally, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Try |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ThrowStatement() |
|
||||||
{ |
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Throw <Test />"))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Throw, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void BranchStatements() |
|
||||||
{ |
|
||||||
string statement = @"GoTo 5
|
|
||||||
GoTo LabelName |
|
||||||
Exit Do |
|
||||||
Exit For |
|
||||||
Exit While |
|
||||||
Exit Select |
|
||||||
Exit Sub |
|
||||||
Exit Function |
|
||||||
Exit Property |
|
||||||
Exit Try |
|
||||||
Continue Do |
|
||||||
Continue For |
|
||||||
Continue While |
|
||||||
Stop |
|
||||||
End |
|
||||||
Return |
|
||||||
Return 5 |
|
||||||
Return <Test />";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.GoTo, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.GoTo, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Do, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.For, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.While, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Select, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Sub, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Function, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Property, Tokens.EOL, |
|
||||||
Tokens.Exit, Tokens.Try, Tokens.EOL, |
|
||||||
Tokens.Continue, Tokens.Do, Tokens.EOL, |
|
||||||
Tokens.Continue, Tokens.For, Tokens.EOL, |
|
||||||
Tokens.Continue, Tokens.While, Tokens.EOL, |
|
||||||
Tokens.Stop, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.EOL, |
|
||||||
Tokens.Return, Tokens.EOL, |
|
||||||
Tokens.Return, Tokens.LiteralInteger, Tokens.EOL, |
|
||||||
Tokens.Return, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ArrayHandlingStatements() |
|
||||||
{ |
|
||||||
string statement = @"Erase <Test />
|
|
||||||
Erase <Test />, <Test /> |
|
||||||
ReDim Preserve <Test />";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Erase, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.Erase, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.Comma, |
|
||||||
Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.ReDim, Tokens.Preserve, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UsingStatement() |
|
||||||
{ |
|
||||||
string statement = @"Using <Test />
|
|
||||||
End Using";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement))); |
|
||||||
|
|
||||||
CheckHead(lexer); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.Using, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement, Tokens.EOL, |
|
||||||
Tokens.End, Tokens.Using |
|
||||||
); |
|
||||||
|
|
||||||
CheckFoot(lexer); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NewExpressionWithObjectInitializer() |
|
||||||
{ |
|
||||||
string code = @"New Common.ComboBoxItem With {.Item = _
|
|
||||||
Localizer.GetString(""Month"" & initParameters.SelectedDate.FirstDayOfPreviousMonth.Month) & "" "" & |
|
||||||
initParameters.SelectedDate.FirstDayOfPreviousMonth.Year, .Value = New Date(2010, initParameters.SelectedDate.FirstDayOfPreviousMonth.Month, 1)}";
|
|
||||||
|
|
||||||
VBLexer lexer = GenerateLexerForSnippet(new StringReader(code), SnippetType.Expression); |
|
||||||
|
|
||||||
CheckTokens(lexer, Tokens.New, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, |
|
||||||
Tokens.With, Tokens.OpenCurlyBrace, Tokens.Dot, Tokens.Identifier, Tokens.Assign, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.OpenParenthesis, Tokens.LiteralString, |
|
||||||
Tokens.ConcatString, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.CloseParenthesis, Tokens.ConcatString, |
|
||||||
Tokens.LiteralString, Tokens.ConcatString, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, |
|
||||||
Tokens.Dot, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.Comma, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Assign, Tokens.New, Tokens.Date, Tokens.OpenParenthesis, Tokens.LiteralInteger, |
|
||||||
Tokens.Comma, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.Dot, |
|
||||||
Tokens.Identifier, Tokens.Comma, Tokens.LiteralInteger, Tokens.CloseParenthesis, Tokens.CloseCurlyBrace); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
#region Helpers
|
|
||||||
VBLexer GenerateLexer(StringReader sr) |
|
||||||
{ |
|
||||||
return new VBLexer(sr); |
|
||||||
} |
|
||||||
|
|
||||||
VBLexer GenerateLexerForSnippet(StringReader sr, SnippetType type) |
|
||||||
{ |
|
||||||
var lexer = new VBLexer(sr); |
|
||||||
lexer.SetInitialContext(type); |
|
||||||
return lexer; |
|
||||||
} |
|
||||||
|
|
||||||
string TestStatement(string stmt) |
|
||||||
{ |
|
||||||
return "Class Test\n" + |
|
||||||
"Sub A\n" + |
|
||||||
stmt + "\n" + |
|
||||||
"End Sub\n" + |
|
||||||
"End Class"; |
|
||||||
} |
|
||||||
|
|
||||||
void CheckFoot(VBLexer lexer) |
|
||||||
{ |
|
||||||
CheckTokens(lexer, Tokens.EOL, Tokens.End, Tokens.Sub, Tokens.EOL, Tokens.End, Tokens.Class); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckHead(VBLexer lexer) |
|
||||||
{ |
|
||||||
CheckTokens(lexer, Tokens.Class, Tokens.Identifier, Tokens.EOL, |
|
||||||
Tokens.Sub, Tokens.Identifier, Tokens.EOL); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckTokens(VBLexer lexer, params int[] tokens) |
|
||||||
{ |
|
||||||
for (int i = 0; i < tokens.Length; i++) { |
|
||||||
int token = tokens[i]; |
|
||||||
Token t = lexer.NextToken(); |
|
||||||
int next = t.Kind; |
|
||||||
Assert.IsEmpty(lexer.Errors.ErrorOutput); |
|
||||||
Assert.AreEqual(token, next, "{2} of {3}: expected: \"{0}\", was: \"{1}\"; at {4}", Tokens.GetTokenString(token), Tokens.GetTokenString(next), i + 1, tokens.Length, t.Location); |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.CodeDom; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Visitors; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CodeDOMParenthesizedExpressionTest |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void TestParenthesizedExpression() |
|
||||||
{ |
|
||||||
object output = new ParenthesizedExpression(new PrimitiveExpression(5, "5")).AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.IsTrue(output is CodePrimitiveExpression); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.CodeDom; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Visitors; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CodeDOMPrimitiveExpressionsTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void TestPrimitiveExpression() |
|
||||||
{ |
|
||||||
object output = new PrimitiveExpression(5, "5").AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.IsTrue(output is CodePrimitiveExpression); |
|
||||||
Assert.AreEqual(((CodePrimitiveExpression)output).Value, 5); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,30 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.CodeDom; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Visitors; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CodeDOMTypeReferenceTest |
|
||||||
{ |
|
||||||
[TestAttribute] |
|
||||||
public void InnerClassTypeReferencTest() |
|
||||||
{ |
|
||||||
InnerClassTypeReference ictr = new InnerClassTypeReference( |
|
||||||
new TypeReference("OuterClass", new List<TypeReference> { new TypeReference("String") }), |
|
||||||
"InnerClass", |
|
||||||
new List<TypeReference> { new TypeReference("Int32"), new TypeReference("Int64") }); |
|
||||||
Assert.AreEqual("OuterClass<String>+InnerClass<Int32,Int64>", ictr.ToString()); |
|
||||||
CodeTypeOfExpression result = (CodeTypeOfExpression)new TypeOfExpression(ictr).AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.AreEqual("OuterClass`1+InnerClass`2", result.Type.BaseType); |
|
||||||
Assert.AreEqual(3, result.Type.TypeArguments.Count); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,59 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.CodeDom; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Visitors; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class InvocationExpressionsTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void IdentifierOnlyInvocation() |
|
||||||
{ |
|
||||||
// InitializeComponents();
|
|
||||||
SimpleNameExpression identifier = new SimpleNameExpression("InitializeComponents"); |
|
||||||
InvocationExpression invocation = new InvocationExpression(identifier, new List<Expression>()); |
|
||||||
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.IsTrue(output is CodeMethodInvokeExpression); |
|
||||||
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output; |
|
||||||
Assert.AreEqual("InitializeComponents", mie.Method.MethodName); |
|
||||||
Assert.IsTrue(mie.Method.TargetObject is CodeThisReferenceExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MethodOnThisReferenceInvocation() |
|
||||||
{ |
|
||||||
// InitializeComponents();
|
|
||||||
MemberReferenceExpression field = new MemberReferenceExpression(new ThisReferenceExpression(), "InitializeComponents"); |
|
||||||
InvocationExpression invocation = new InvocationExpression(field, new List<Expression>()); |
|
||||||
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.IsTrue(output is CodeMethodInvokeExpression); |
|
||||||
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output; |
|
||||||
Assert.AreEqual("InitializeComponents", mie.Method.MethodName); |
|
||||||
Assert.IsTrue(mie.Method.TargetObject is CodeThisReferenceExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InvocationOfStaticMethod() |
|
||||||
{ |
|
||||||
// System.Drawing.Color.FromArgb();
|
|
||||||
MemberReferenceExpression field = new MemberReferenceExpression(new SimpleNameExpression("System"), "Drawing"); |
|
||||||
field = new MemberReferenceExpression(field, "Color"); |
|
||||||
field = new MemberReferenceExpression(field, "FromArgb"); |
|
||||||
InvocationExpression invocation = new InvocationExpression(field, new List<Expression>()); |
|
||||||
object output = invocation.AcceptVisitor(new CodeDomVisitor(), null); |
|
||||||
Assert.IsTrue(output is CodeMethodInvokeExpression); |
|
||||||
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output; |
|
||||||
Assert.AreEqual("FromArgb", mie.Method.MethodName); |
|
||||||
Assert.IsTrue(mie.Method.TargetObject is CodeTypeReferenceExpression); |
|
||||||
Assert.AreEqual("System.Drawing.Color", (mie.Method.TargetObject as CodeTypeReferenceExpression).Type.BaseType); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,79 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
using System.IO; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.PrettyPrinter; |
|
||||||
|
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.PrettyPrinter |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class SpecialOutputVisitorTest |
|
||||||
{ |
|
||||||
void TestProgram(string program) |
|
||||||
{ |
|
||||||
VBParser parser = ParserFactory.CreateParser(new StringReader(program)); |
|
||||||
parser.Parse(); |
|
||||||
Assert.AreEqual("", parser.Errors.ErrorOutput); |
|
||||||
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor(); |
|
||||||
outputVisitor.Options.IndentationChar = ' '; |
|
||||||
outputVisitor.Options.TabSize = 2; |
|
||||||
outputVisitor.Options.IndentSize = 2; |
|
||||||
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(), |
|
||||||
outputVisitor)) { |
|
||||||
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null); |
|
||||||
} |
|
||||||
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput); |
|
||||||
Assert.AreEqual(program.Replace("\r", ""), outputVisitor.Text.TrimEnd().Replace("\r", "")); |
|
||||||
parser.Dispose(); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Enum() |
|
||||||
{ |
|
||||||
TestProgram("Enum Test\n" + |
|
||||||
" ' a\n" + |
|
||||||
" m1\n" + |
|
||||||
" ' b\n" + |
|
||||||
" m2\n" + |
|
||||||
" ' c\n" + |
|
||||||
"End Enum\n" + |
|
||||||
"' d"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CommentsInsideMethod() |
|
||||||
{ |
|
||||||
TestProgram(@"Public Class Class1
|
|
||||||
Private Function test(l As Integer, lvw As Integer) As Boolean |
|
||||||
' Begin |
|
||||||
Dim i As Integer = 1 |
|
||||||
Return False |
|
||||||
' End of method |
|
||||||
End Function |
|
||||||
End Class");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void BlankLines() |
|
||||||
{ |
|
||||||
TestProgram("Imports System\n" + |
|
||||||
"\n" + |
|
||||||
"Imports System.IO"); |
|
||||||
TestProgram("Imports System\n" + |
|
||||||
"\n" + |
|
||||||
"\n" + |
|
||||||
"Imports System.IO"); |
|
||||||
TestProgram("\n" + |
|
||||||
"' Some comment\n" + |
|
||||||
"\n" + |
|
||||||
"Imports System.IO"); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,670 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.PrettyPrinter; |
|
||||||
using ICSharpCode.NRefactory.VB.Visitors; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.PrettyPrinter |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class VBNetOutputTest |
|
||||||
{ |
|
||||||
void TestProgram(string program) |
|
||||||
{ |
|
||||||
VBParser parser = ParserFactory.CreateParser(new StringReader(program)); |
|
||||||
parser.Parse(); |
|
||||||
Assert.AreEqual("", parser.Errors.ErrorOutput); |
|
||||||
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor(); |
|
||||||
outputVisitor.Options.OutputByValModifier = true; |
|
||||||
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null); |
|
||||||
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput); |
|
||||||
Assert.AreEqual(StripWhitespace(program), StripWhitespace(outputVisitor.Text)); |
|
||||||
} |
|
||||||
|
|
||||||
string StripWhitespace(string text) |
|
||||||
{ |
|
||||||
text = text.Trim().Replace("\t", "").Replace("\r", "").Replace("\n", " ").Replace(" ", " "); |
|
||||||
while (text.Contains(" ")) { |
|
||||||
text = text.Replace(" ", " "); |
|
||||||
} |
|
||||||
return text; |
|
||||||
} |
|
||||||
|
|
||||||
void TestTypeMember(string program) |
|
||||||
{ |
|
||||||
TestProgram("Class A\n" + program + "\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
void TestStatement(string statement) |
|
||||||
{ |
|
||||||
TestTypeMember("Sub Method()\n" + statement + "\nEnd Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
void TestExpression(string expression) |
|
||||||
{ |
|
||||||
VBParser parser = ParserFactory.CreateParser(new StringReader(expression)); |
|
||||||
Expression e = parser.ParseExpression(); |
|
||||||
Assert.AreEqual("", parser.Errors.ErrorOutput); |
|
||||||
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor(); |
|
||||||
e.AcceptVisitor(outputVisitor, null); |
|
||||||
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput); |
|
||||||
Assert.AreEqual(StripWhitespace(expression), StripWhitespace(outputVisitor.Text)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Field() |
|
||||||
{ |
|
||||||
TestTypeMember("Private a As Integer"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Method() |
|
||||||
{ |
|
||||||
TestTypeMember("Sub Method()\nEnd Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void EnumWithBaseType() |
|
||||||
{ |
|
||||||
TestProgram("Public Enum Foo As UShort\nEnd Enum"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void PartialModifier() |
|
||||||
{ |
|
||||||
TestProgram("Public Partial Class Foo\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MustInheritClass() |
|
||||||
{ |
|
||||||
TestProgram("Public MustInherit Class Foo\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericClassDefinition() |
|
||||||
{ |
|
||||||
TestProgram("Public Class Foo(Of T As {IDisposable, ICloneable})\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericClassDefinitionWithBaseType() |
|
||||||
{ |
|
||||||
TestProgram("Public Class Foo(Of T As IDisposable)\nInherits BaseType\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericMethodDefinition() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Sub Foo(Of T As {IDisposable, ICloneable})(ByVal arg As T)\nEnd Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ArrayRank() |
|
||||||
{ |
|
||||||
TestStatement("Dim a As Object(,,)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ArrayInitialization() |
|
||||||
{ |
|
||||||
TestStatement("Dim a As Object() = New Object(10) {}"); |
|
||||||
TestTypeMember("Private MultiDim As Integer(,) = {{1, 2}, {1, 3}}"); |
|
||||||
TestExpression("New Integer(, ) {{1, 1}, {1, 1}}"); |
|
||||||
TestTypeMember("Private _titles As String() = New String() {}"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MethodCallWithOptionalArguments() |
|
||||||
{ |
|
||||||
TestExpression("M(, )"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void IfStatement() |
|
||||||
{ |
|
||||||
TestStatement("If a Then\n" + |
|
||||||
"\tm1()\n" + |
|
||||||
"ElseIf b Then\n" + |
|
||||||
"\tm2()\n" + |
|
||||||
"Else\n" + |
|
||||||
"\tm3()\n" + |
|
||||||
"End If"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ForNextLoop() |
|
||||||
{ |
|
||||||
TestStatement("For i = 0 To 10\n" + |
|
||||||
"Next"); |
|
||||||
TestStatement("For i As Long = 10 To 0 Step -1\n" + |
|
||||||
"Next"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void DoLoop() |
|
||||||
{ |
|
||||||
TestStatement("Do\n" + |
|
||||||
"Loop"); |
|
||||||
TestStatement("Do\n" + |
|
||||||
"Loop While Not (i = 10)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SelectCase() |
|
||||||
{ |
|
||||||
TestStatement(@"Select Case i
|
|
||||||
Case 0 |
|
||||||
Case 1 To 4 |
|
||||||
Case Else |
|
||||||
End Select");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UsingStatement() |
|
||||||
{ |
|
||||||
TestStatement(@"Using nf As New Font(), nf2 As New List(Of Font)(), nf3 = Nothing
|
|
||||||
Bla(nf) |
|
||||||
End Using");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UntypedVariable() |
|
||||||
{ |
|
||||||
TestStatement("Dim x = 0"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UntypedField() |
|
||||||
{ |
|
||||||
TestTypeMember("Dim x = 0"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Assignment() |
|
||||||
{ |
|
||||||
TestExpression("a = b"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SpecialIdentifiers() |
|
||||||
{ |
|
||||||
// Assembly, Ansi and Until are contextual keywords
|
|
||||||
// Custom is valid inside methods, but not valid for field names
|
|
||||||
TestExpression("Assembly = Ansi * [For] + Until - [Custom]"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void DictionaryAccess() |
|
||||||
{ |
|
||||||
TestExpression("c!key"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericMethodInvocation() |
|
||||||
{ |
|
||||||
TestExpression("GenericMethod(Of T)(arg)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SpecialIdentifierName() |
|
||||||
{ |
|
||||||
TestExpression("[Class]"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericDelegate() |
|
||||||
{ |
|
||||||
TestProgram("Public Delegate Function Predicate(Of T)(ByVal item As T) As String"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Enum() |
|
||||||
{ |
|
||||||
TestProgram("Enum MyTest\nRed\n Green\n Blue\nYellow\n End Enum"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void EnumWithInitializers() |
|
||||||
{ |
|
||||||
TestProgram("Enum MyTest\nRed = 1\n Green = 2\n Blue = 4\n Yellow = 8\n End Enum"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SyncLock() |
|
||||||
{ |
|
||||||
TestStatement("SyncLock a\nWork()\nEnd SyncLock"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Using() |
|
||||||
{ |
|
||||||
TestStatement("Using a As New A()\na.Work()\nEnd Using"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Cast() |
|
||||||
{ |
|
||||||
TestExpression("CType(a, T)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void DirectCast() |
|
||||||
{ |
|
||||||
TestExpression("DirectCast(a, T)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TryCast() |
|
||||||
{ |
|
||||||
TestExpression("TryCast(a, T)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void PrimitiveCast() |
|
||||||
{ |
|
||||||
TestExpression("CStr(a)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TypeOfIs() |
|
||||||
{ |
|
||||||
TestExpression("TypeOf a Is String"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void PropertyWithAccessorAccessModifiers() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Property ExpectsValue() As Boolean\n" + |
|
||||||
"\tPublic Get\n" + |
|
||||||
"\tEnd Get\n" + |
|
||||||
"\tProtected Set\n" + |
|
||||||
"\tEnd Set\n" + |
|
||||||
"End Property"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AutoProperty() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Property Value()"); |
|
||||||
TestTypeMember("Public Property Value() As Integer"); |
|
||||||
TestTypeMember("Public Property Value() As Integer = 5"); |
|
||||||
TestTypeMember("Public Property Value() As New List()"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AbstractProperty() |
|
||||||
{ |
|
||||||
TestTypeMember("Public MustOverride Property ExpectsValue() As Boolean"); |
|
||||||
TestTypeMember("Public MustOverride ReadOnly Property ExpectsValue() As Boolean"); |
|
||||||
TestTypeMember("Public MustOverride WriteOnly Property ExpectsValue() As Boolean"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AbstractMethod() |
|
||||||
{ |
|
||||||
TestTypeMember("Public MustOverride Sub Run()"); |
|
||||||
TestTypeMember("Public MustOverride Function Run() As Boolean"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InterfaceImplementingMethod() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Sub Run() Implements SomeInterface.Run\nEnd Sub"); |
|
||||||
TestTypeMember("Public Function Run() As Boolean Implements SomeInterface.Bla\nEnd Function"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NamedAttributeArgument() |
|
||||||
{ |
|
||||||
TestProgram("<Attribute(ArgName := \"value\")> _\n" + |
|
||||||
"Class Test\n" + |
|
||||||
"End Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ReturnTypeAttribute() |
|
||||||
{ |
|
||||||
TestTypeMember("Function A() As <Attribute> String\n" + |
|
||||||
"End Function"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AssemblyAttribute() |
|
||||||
{ |
|
||||||
TestProgram("<Assembly: CLSCompliant>"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ModuleAttribute() |
|
||||||
{ |
|
||||||
TestProgram("<Module: SuppressMessageAttribute>"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Interface() |
|
||||||
{ |
|
||||||
TestProgram("Interface ITest\n" + |
|
||||||
"Property GetterAndSetter() As Boolean\n" + |
|
||||||
"ReadOnly Property GetterOnly() As Boolean\n" + |
|
||||||
"WriteOnly Property SetterOnly() As Boolean\n" + |
|
||||||
"Sub InterfaceMethod()\n" + |
|
||||||
"Function InterfaceMethod2() As String\n" + |
|
||||||
"End Interface"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OnErrorStatement() |
|
||||||
{ |
|
||||||
TestStatement("On Error Resume Next"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OverloadedConversionOperators() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Shared Narrowing Operator CType(ByVal xmlNode As XmlNode) As TheBug\nEnd Operator"); |
|
||||||
TestTypeMember("Public Shared Widening Operator CType(ByVal bugNode As TheBug) As XmlNode\nEnd Operator"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OverloadedTrueFalseOperators() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Shared Operator IsTrue(ByVal a As TheBug) As Boolean\nEnd Operator"); |
|
||||||
TestTypeMember("Public Shared Operator IsFalse(ByVal a As TheBug) As Boolean\nEnd Operator"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OverloadedOperators() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Shared Operator +(ByVal bugNode As TheBug, ByVal bugNode2 As TheBug) As TheBug\nEnd Operator"); |
|
||||||
TestTypeMember("Public Shared Operator >>(ByVal bugNode As TheBug, ByVal b As Integer) As TheBug\nEnd Operator"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AttributeOnParameter() |
|
||||||
{ |
|
||||||
TestTypeMember("Sub Main(ByRef one As Integer, ByRef two As Integer, <Out> ByRef three As Integer)\nEnd Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void FieldWithoutType() |
|
||||||
{ |
|
||||||
TestTypeMember("Dim X"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UsingStatementForExistingVariable() |
|
||||||
{ |
|
||||||
TestStatement("Using obj\nEnd Using"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ContinueFor() |
|
||||||
{ |
|
||||||
TestStatement("Continue For"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ForNextStatementWithFieldLoopVariable() |
|
||||||
{ |
|
||||||
TestStatement("For Me.Field = 0 To 10\n" + |
|
||||||
"Next Me.Field"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WithStatement() |
|
||||||
{ |
|
||||||
TestStatement("With Ejes\n" + |
|
||||||
"\t.AddLine(New Point(Me.ClientSize.Width / 2, 0), (New Point(Me.ClientSize.Width / 2, Me.ClientSize.Height)))\n" + |
|
||||||
"End With"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NewConstraint() |
|
||||||
{ |
|
||||||
TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), New})\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void StructConstraint() |
|
||||||
{ |
|
||||||
TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), Structure})\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ClassConstraint() |
|
||||||
{ |
|
||||||
TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), Class})\nEnd Class"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Integer() |
|
||||||
{ |
|
||||||
TestExpression("16"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Double() |
|
||||||
{ |
|
||||||
TestExpression("1.0"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void HexadecimalInteger() |
|
||||||
{ |
|
||||||
TestExpression("&H10"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void HexadecimalMinusOne() |
|
||||||
{ |
|
||||||
TestExpression("&Hffffffff"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void TypeCharacters() |
|
||||||
{ |
|
||||||
TestExpression("347S"); |
|
||||||
TestExpression("347L"); |
|
||||||
TestExpression("347D"); |
|
||||||
TestExpression("347F"); |
|
||||||
TestExpression("347US"); |
|
||||||
TestExpression("347UI"); |
|
||||||
TestExpression("347UL"); |
|
||||||
TestExpression("\".\"C"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AddressOf() |
|
||||||
{ |
|
||||||
TestExpression("AddressOf Abc"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ChainedConstructorCall() |
|
||||||
{ |
|
||||||
TestExpression("MyBase.New()"); |
|
||||||
TestExpression("Me.New()"); |
|
||||||
TestExpression("MyClass.New()"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NewMethodCall() |
|
||||||
{ |
|
||||||
TestExpression("something.[New]()"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ObjectInitializer() |
|
||||||
{ |
|
||||||
TestExpression("New StringWriter() With { _\n" + |
|
||||||
" .NewLine = Environment.NewLine, _\n" + |
|
||||||
" .Encoding = Encoding.UTF8 _\n" + |
|
||||||
"}"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void EventDefinition() |
|
||||||
{ |
|
||||||
TestTypeMember("Public Event MyEvent(ByVal sender As Object)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Options() |
|
||||||
{ |
|
||||||
TestProgram("Option Strict On\n" + |
|
||||||
"Option Explicit On\n" + |
|
||||||
"Option Infer On\n" + |
|
||||||
"Option Compare Text"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void UntypedForeach() |
|
||||||
{ |
|
||||||
TestStatement("For Each x In myGuidArray\nNext"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MethodDefinitionWithOptionalParameter() |
|
||||||
{ |
|
||||||
TestTypeMember("Sub M(Optional ByVal msg As String = Nothing, Optional ByRef output As String = Nothing)\nEnd Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void Module() |
|
||||||
{ |
|
||||||
TestProgram("Module Test\n" + |
|
||||||
" Sub M()\n" + |
|
||||||
" End Sub\n" + |
|
||||||
"End Module"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void WithEvents() |
|
||||||
{ |
|
||||||
TestTypeMember("Dim WithEvents a As Button"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void FriendWithEventsField() |
|
||||||
{ |
|
||||||
TestTypeMember("Friend WithEvents Button1 As System.Windows.Forms.Button"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleFunctionLambda() |
|
||||||
{ |
|
||||||
TestExpression("Function(x) x * x"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleFunctionLambdaWithType() |
|
||||||
{ |
|
||||||
TestExpression("Function(x As Integer) x * x"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleSubLambdaWithType() |
|
||||||
{ |
|
||||||
TestExpression("Sub(x As Integer) Console.WriteLine(x)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void BlockSubLambdaWithType() |
|
||||||
{ |
|
||||||
TestExpression("Sub(x As Integer)\n" + |
|
||||||
" Console.WriteLine(x)\n" + |
|
||||||
"End Sub"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void BlockFunctionLambdaWithType() |
|
||||||
{ |
|
||||||
TestExpression("Function(x As Integer) As Integer\n" + |
|
||||||
" If x < 2 Then\n" + |
|
||||||
" Return x\n" + |
|
||||||
" End If\n" + |
|
||||||
" Return x * x\n" + |
|
||||||
"End Function"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlSimple() |
|
||||||
{ |
|
||||||
TestExpression("<?xml?>\n" + |
|
||||||
"<!-- test -->\n" + |
|
||||||
"<Test>\n" + |
|
||||||
" <A />\n" + |
|
||||||
" <B test='a' <%= test %> />\n" + |
|
||||||
"</Test>"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlNested() |
|
||||||
{ |
|
||||||
TestExpression(@"<menu>
|
|
||||||
<course name=""appetizer""> |
|
||||||
<dish>Shrimp Cocktail</dish> |
|
||||||
<dish>Escargot</dish> |
|
||||||
</course> |
|
||||||
<course name=""main""> |
|
||||||
<dish>Filet Mignon</dish> |
|
||||||
<dish>Garlic Potatoes</dish> |
|
||||||
<dish>Broccoli</dish> |
|
||||||
</course> |
|
||||||
<course name=""dessert""> |
|
||||||
<dish>Chocolate Cheesecake</dish> |
|
||||||
</course> |
|
||||||
</menu>");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlDocument() |
|
||||||
{ |
|
||||||
TestExpression(@"<?xml version=""1.0""?>
|
|
||||||
<menu> |
|
||||||
<course name=""appetizer""> |
|
||||||
<dish>Shrimp Cocktail</dish> |
|
||||||
<dish>Escargot</dish> |
|
||||||
</course> |
|
||||||
</menu>");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlNestedWithExpressions() |
|
||||||
{ |
|
||||||
TestExpression(@"<?xml version=""1.0""?>
|
|
||||||
<menu> |
|
||||||
<course name=""appetizer""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""appetizer"" _ |
|
||||||
Select <dish><%= m.Food %></dish> %> |
|
||||||
</course> |
|
||||||
<course name=""main""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""main"" _ |
|
||||||
Select <dish><%= m.Food %></dish> %> |
|
||||||
</course> |
|
||||||
<course name=""dessert""> |
|
||||||
<%= From m In menu _ |
|
||||||
Where m.Course = ""dessert"" _ |
|
||||||
Select <dish><%= m.Food %></dish> %> |
|
||||||
</course> |
|
||||||
</menu>");
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void XmlAccessExpressions() |
|
||||||
{ |
|
||||||
TestExpression("xml.<menu>.<course>"); |
|
||||||
TestExpression("xml...<course>"); |
|
||||||
TestExpression("xml...<course>(2)"); |
|
||||||
TestExpression("item.@name"); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,45 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class AddressOfExpressionTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void SimpleAddressOfExpressionTest() |
|
||||||
{ |
|
||||||
AddressOfExpression ae = ParseUtil.ParseExpression<AddressOfExpression>("AddressOf t"); |
|
||||||
Assert.IsNotNull(ae); |
|
||||||
Assert.IsInstanceOf(typeof(IdentifierExpression), ae.Expression); |
|
||||||
Assert.AreEqual("t", ((IdentifierExpression)ae.Expression).Identifier, "t"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GenericAddressOfExpressionTest() |
|
||||||
{ |
|
||||||
AddressOfExpression ae = ParseUtil.ParseExpression<AddressOfExpression>("AddressOf t(Of X)"); |
|
||||||
Assert.IsNotNull(ae); |
|
||||||
Assert.IsInstanceOf(typeof(IdentifierExpression), ae.Expression); |
|
||||||
Assert.AreEqual("t", ((IdentifierExpression)ae.Expression).Identifier, "t"); |
|
||||||
Assert.AreEqual(1, ((IdentifierExpression)ae.Expression).TypeArguments.Count); |
|
||||||
Assert.AreEqual("X", ((IdentifierExpression)ae.Expression).TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MemberReferenceAddressOfExpressionTest() |
|
||||||
{ |
|
||||||
AddressOfExpression ae = ParseUtil.ParseExpression<AddressOfExpression>("AddressOf Me.t(Of X)"); |
|
||||||
Assert.IsNotNull(ae); |
|
||||||
Assert.IsInstanceOf(typeof(MemberReferenceExpression), ae.Expression); |
|
||||||
Assert.AreEqual("t", ((MemberReferenceExpression)ae.Expression).MemberName, "t"); |
|
||||||
Assert.IsInstanceOf(typeof(ThisReferenceExpression), ((MemberReferenceExpression)ae.Expression).TargetObject); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,36 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ArrayCreateExpressionTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void ArrayCreateExpressionTest1() |
|
||||||
{ |
|
||||||
ArrayCreateExpression ace = ParseUtil.ParseExpression<ArrayCreateExpression>("new Integer() {1, 2, 3, 4}"); |
|
||||||
|
|
||||||
Assert.AreEqual("System.Int32", ace.CreateType.Type); |
|
||||||
Assert.AreEqual(0, ace.Arguments.Count); |
|
||||||
Assert.AreEqual(new int[] {0}, ace.CreateType.RankSpecifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ArrayCreateExpressionTest2() |
|
||||||
{ |
|
||||||
ArrayCreateExpression ace = ParseUtil.ParseExpression<ArrayCreateExpression>("New Integer(0 To 5){0, 1, 2, 3, 4, 5}"); |
|
||||||
|
|
||||||
Assert.AreEqual("System.Int32", ace.CreateType.Type); |
|
||||||
Assert.AreEqual(1, ace.Arguments.Count); |
|
||||||
Assert.AreEqual(5, (ace.Arguments[0] as PrimitiveExpression).Value); |
|
||||||
Assert.AreEqual(new int[] {0}, ace.CreateType.RankSpecifier); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,73 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class AssignmentExpressionTests |
|
||||||
{ |
|
||||||
void TestAssignmentExpression(string program, AssignmentOperatorType op) |
|
||||||
{ |
|
||||||
ExpressionStatement se = ParseUtil.ParseStatement<ExpressionStatement>(program); |
|
||||||
AssignmentExpression ae = se.Expression as AssignmentExpression; |
|
||||||
Assert.AreEqual(op, ae.Op); |
|
||||||
|
|
||||||
Assert.IsTrue(ae.Left is IdentifierExpression); |
|
||||||
Assert.IsTrue(ae.Right is IdentifierExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AssignTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a = b", AssignmentOperatorType.Assign); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AddTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a += b", AssignmentOperatorType.Add); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SubtractTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a -= b", AssignmentOperatorType.Subtract); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MultiplyTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a *= b", AssignmentOperatorType.Multiply); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void DivideTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a /= b", AssignmentOperatorType.Divide); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExclusiveOrTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a ^= b", AssignmentOperatorType.Power); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void StringConcatTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a &= b", AssignmentOperatorType.ConcatString); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ModulusTest() |
|
||||||
{ |
|
||||||
TestAssignmentExpression("a \\= b", AssignmentOperatorType.DivideInteger); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,24 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class BaseReferenceExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetBaseReferenceExpressionTest1() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("MyBase.myField"); |
|
||||||
Assert.IsTrue(fre.TargetObject is BaseReferenceExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,268 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.PrettyPrinter; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class BinaryOperatorExpressionTests |
|
||||||
{ |
|
||||||
void OperatorPrecedenceTest(string strongOperator, BinaryOperatorType strongOperatorType, |
|
||||||
string weakOperator, BinaryOperatorType weakOperatorType) |
|
||||||
{ |
|
||||||
string program = "a " + weakOperator + " b " + strongOperator + " c"; |
|
||||||
BinaryOperatorExpression boe; |
|
||||||
boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(weakOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
boe = (BinaryOperatorExpression)boe.Right; |
|
||||||
Assert.AreEqual(strongOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
|
|
||||||
program = "a " + strongOperator + " b " + weakOperator + " c"; |
|
||||||
boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(weakOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
boe = (BinaryOperatorExpression)boe.Left; |
|
||||||
Assert.AreEqual(strongOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
} |
|
||||||
|
|
||||||
void SameOperatorPrecedenceTest(string firstOperator, BinaryOperatorType firstOperatorType, |
|
||||||
string secondOperator, BinaryOperatorType secondOperatorType) |
|
||||||
{ |
|
||||||
string program = "a " + secondOperator + " b " + firstOperator + " c"; |
|
||||||
BinaryOperatorExpression boe; |
|
||||||
boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(firstOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
boe = (BinaryOperatorExpression)boe.Left; |
|
||||||
Assert.AreEqual(secondOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
|
|
||||||
program = "a " + firstOperator + " b " + secondOperator + " c"; |
|
||||||
boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(secondOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
boe = (BinaryOperatorExpression)boe.Left; |
|
||||||
Assert.AreEqual(firstOperatorType, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
} |
|
||||||
|
|
||||||
#region VB.NET
|
|
||||||
void VBNetTestBinaryOperatorExpressionTest(string program, BinaryOperatorType op) |
|
||||||
{ |
|
||||||
BinaryOperatorExpression boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(op, boe.Op); |
|
||||||
|
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is SimpleNameExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBOperatorPrecedenceTest() |
|
||||||
{ |
|
||||||
OperatorPrecedenceTest("^", BinaryOperatorType.Power, "*", BinaryOperatorType.Multiply); |
|
||||||
SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide); |
|
||||||
OperatorPrecedenceTest("/", BinaryOperatorType.Divide, "\\", BinaryOperatorType.DivideInteger); |
|
||||||
OperatorPrecedenceTest("\\", BinaryOperatorType.DivideInteger, "Mod", BinaryOperatorType.Modulus); |
|
||||||
OperatorPrecedenceTest("Mod", BinaryOperatorType.Modulus, "+", BinaryOperatorType.Add); |
|
||||||
SameOperatorPrecedenceTest("+", BinaryOperatorType.Add, "-", BinaryOperatorType.Subtract); |
|
||||||
OperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "&", BinaryOperatorType.Concat); |
|
||||||
OperatorPrecedenceTest("&", BinaryOperatorType.Concat, "<<", BinaryOperatorType.ShiftLeft); |
|
||||||
SameOperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, ">>", BinaryOperatorType.ShiftRight); |
|
||||||
OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("<>", BinaryOperatorType.InEquality, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("<", BinaryOperatorType.LessThan, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("<=", BinaryOperatorType.LessThanOrEqual, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest(">", BinaryOperatorType.GreaterThan, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest(">=", BinaryOperatorType.GreaterThanOrEqual, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("Like", BinaryOperatorType.Like, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("Is", BinaryOperatorType.ReferenceEquality, "=", BinaryOperatorType.Equality); |
|
||||||
SameOperatorPrecedenceTest("IsNot", BinaryOperatorType.ReferenceInequality, "=", BinaryOperatorType.Equality); |
|
||||||
OperatorPrecedenceTest("=", BinaryOperatorType.Equality, "And", BinaryOperatorType.BitwiseAnd); |
|
||||||
SameOperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "AndAlso", BinaryOperatorType.LogicalAnd); |
|
||||||
OperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "Or", BinaryOperatorType.BitwiseOr); |
|
||||||
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "OrElse", BinaryOperatorType.LogicalOr); |
|
||||||
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "Xor", BinaryOperatorType.ExclusiveOr); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetPowerTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.Power); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetConcatTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.Concat); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLogicalAndTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a AndAlso b", BinaryOperatorType.LogicalAnd); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetLogicalAndNotLazyTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a And b", BinaryOperatorType.BitwiseAnd); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLogicalOrTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a OrElse b", BinaryOperatorType.LogicalOr); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetLogicalOrNotLazyTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a Or b", BinaryOperatorType.BitwiseOr); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetExclusiveOrTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a Xor b", BinaryOperatorType.ExclusiveOr); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGreaterThanTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGreaterThanOrEqualTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetEqualityTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a = b", BinaryOperatorType.Equality); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetInEqualityTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a <> b", BinaryOperatorType.InEquality); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLessThanTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLessThanOrEqualTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetAddTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSubtractTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMultiplyTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetDivideTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetDivideIntegerTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a \\ b", BinaryOperatorType.DivideInteger); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetModulusTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a Mod b", BinaryOperatorType.Modulus); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetShiftLeftTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetShiftRightTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetISTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a is b", BinaryOperatorType.ReferenceEquality); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetISNotTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a IsNot b", BinaryOperatorType.ReferenceInequality); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLikeTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("a Like b", BinaryOperatorType.Like); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNullCoalescingTest() |
|
||||||
{ |
|
||||||
VBNetTestBinaryOperatorExpressionTest("If(a, b)", BinaryOperatorType.NullCoalescing); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetDictionaryAccess() |
|
||||||
{ |
|
||||||
BinaryOperatorExpression boe = ParseUtil.ParseExpression<BinaryOperatorExpression>("a!b"); |
|
||||||
Assert.AreEqual(BinaryOperatorType.DictionaryAccess, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left is SimpleNameExpression); |
|
||||||
Assert.IsTrue(boe.Right is PrimitiveExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetWithDictionaryAccess() |
|
||||||
{ |
|
||||||
BinaryOperatorExpression boe = ParseUtil.ParseExpression<BinaryOperatorExpression>("!b"); |
|
||||||
Assert.AreEqual(BinaryOperatorType.DictionaryAccess, boe.Op); |
|
||||||
Assert.IsTrue(boe.Left.IsNull); |
|
||||||
Assert.IsTrue(boe.Right is PrimitiveExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,181 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CastExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
void TestSpecializedCast(string castExpression, Type castType) |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>(castExpression); |
|
||||||
Assert.AreEqual(castType.FullName, ce.CastTo.Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.PrimitiveConversion, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("CType(o, MyObject)"); |
|
||||||
Assert.AreEqual("MyObject", ce.CastTo.Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.Conversion, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("CType(o, List(of T))"); |
|
||||||
Assert.AreEqual("List", ce.CastTo.Type); |
|
||||||
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.Conversion, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleDirectCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("DirectCast(o, MyObject)"); |
|
||||||
Assert.AreEqual("MyObject", ce.CastTo.Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericDirectCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("DirectCast(o, List(of T))"); |
|
||||||
Assert.AreEqual("List", ce.CastTo.Type); |
|
||||||
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleTryCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("TryCast(o, MyObject)"); |
|
||||||
Assert.AreEqual("MyObject", ce.CastTo.Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.TryCast, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericTryCastExpression() |
|
||||||
{ |
|
||||||
CastExpression ce = ParseUtil.ParseExpression<CastExpression>("TryCast(o, List(of T))"); |
|
||||||
Assert.AreEqual("List", ce.CastTo.Type); |
|
||||||
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
Assert.AreEqual(CastType.TryCast, ce.CastType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedBoolCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CBool(o)", typeof(System.Boolean)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedCharCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CChar(o)", typeof(System.Char)); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedStringCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CStr(o)", typeof(System.String)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedDateTimeCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CDate(o)", typeof(System.DateTime)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedDecimalCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CDec(o)", typeof(System.Decimal)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedSingleCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CSng(o)", typeof(System.Single)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedDoubleCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CDbl(o)", typeof(System.Double)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedByteCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CByte(o)", typeof(System.Byte)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedInt16CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CShort(o)", typeof(System.Int16)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedInt32CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CInt(o)", typeof(System.Int32)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedInt64CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CLng(o)", typeof(System.Int64)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedSByteCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CSByte(o)", typeof(System.SByte)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedUInt16CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CUShort(o)", typeof(System.UInt16)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedUInt32CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CUInt(o)", typeof(System.UInt32)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedUInt64CastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CULng(o)", typeof(System.UInt64)); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSpecializedObjectCastExpression() |
|
||||||
{ |
|
||||||
TestSpecializedCast("CObj(o)", typeof(System.Object)); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,24 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ClassReferenceExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetClassReferenceExpressionTest1() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("MyClass.myField"); |
|
||||||
Assert.IsTrue(fre.TargetObject is ClassReferenceExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,29 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ConditionalExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetConditionalExpressionTest() |
|
||||||
{ |
|
||||||
ConditionalExpression ce = ParseUtil.ParseExpression<ConditionalExpression>("If(x IsNot Nothing, x.Test, \"nothing\")"); |
|
||||||
|
|
||||||
Assert.IsTrue(ce.Condition is BinaryOperatorExpression); |
|
||||||
Assert.IsTrue(ce.TrueExpression is MemberReferenceExpression); |
|
||||||
Assert.IsTrue(ce.FalseExpression is PrimitiveExpression); |
|
||||||
} |
|
||||||
|
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,32 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class GlobalReferenceExpressionTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void VBNetGlobalReferenceExpressionTest() |
|
||||||
{ |
|
||||||
TypeReferenceExpression tre = ParseUtil.ParseExpression<TypeReferenceExpression>("Global.System"); |
|
||||||
Assert.IsTrue(tre.TypeReference.IsGlobal); |
|
||||||
Assert.AreEqual("System", tre.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGlobalTypeDeclaration() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As Global.System.String"); |
|
||||||
TypeReference typeRef = lvd.GetTypeForVariable(0); |
|
||||||
Assert.IsTrue(typeRef.IsGlobal); |
|
||||||
Assert.AreEqual("System.String", typeRef.Type); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,40 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class IdentifierExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetIdentifierExpressionTest1() |
|
||||||
{ |
|
||||||
IdentifierExpression ie = ParseUtil.ParseExpression<IdentifierExpression>("MyIdentifier"); |
|
||||||
Assert.AreEqual("MyIdentifier", ie.Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetIdentifierExpressionTest2() |
|
||||||
{ |
|
||||||
IdentifierExpression ie = ParseUtil.ParseExpression<IdentifierExpression>("[Public]"); |
|
||||||
Assert.AreEqual("Public", ie.Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetContextKeywordsTest() |
|
||||||
{ |
|
||||||
Assert.AreEqual("Assembly", ParseUtil.ParseExpression<IdentifierExpression>("Assembly").Identifier); |
|
||||||
Assert.AreEqual("Custom", ParseUtil.ParseExpression<IdentifierExpression>("Custom").Identifier); |
|
||||||
Assert.AreEqual("Off", ParseUtil.ParseExpression<IdentifierExpression>("Off").Identifier); |
|
||||||
Assert.AreEqual("Explicit", ParseUtil.ParseExpression<IdentifierExpression>("Explicit").Identifier); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,116 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class InvocationExpressionTests |
|
||||||
{ |
|
||||||
void CheckSimpleInvoke(InvocationExpression ie) |
|
||||||
{ |
|
||||||
Assert.AreEqual(0, ie.Arguments.Count); |
|
||||||
Assert.IsTrue(ie.TargetObject is SimpleNameExpression); |
|
||||||
Assert.AreEqual("myMethod", ((SimpleNameExpression)ie.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckGenericInvoke(InvocationExpression expr) |
|
||||||
{ |
|
||||||
Assert.AreEqual(1, expr.Arguments.Count); |
|
||||||
Assert.IsTrue(expr.TargetObject is SimpleNameExpression); |
|
||||||
SimpleNameExpression ident = (SimpleNameExpression)expr.TargetObject; |
|
||||||
Assert.AreEqual("myMethod", ident.Identifier); |
|
||||||
Assert.AreEqual(1, ident.TypeArguments.Count); |
|
||||||
Assert.AreEqual("System.Char", ident.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckGenericInvoke2(InvocationExpression expr) |
|
||||||
{ |
|
||||||
Assert.AreEqual(0, expr.Arguments.Count); |
|
||||||
Assert.IsTrue(expr.TargetObject is SimpleNameExpression); |
|
||||||
SimpleNameExpression ident = (SimpleNameExpression)expr.TargetObject; |
|
||||||
Assert.AreEqual("myMethod", ident.Identifier); |
|
||||||
Assert.AreEqual(2, ident.TypeArguments.Count); |
|
||||||
Assert.AreEqual("T", ident.TypeArguments[0].Type); |
|
||||||
Assert.IsFalse(ident.TypeArguments[0].IsKeyword); |
|
||||||
Assert.AreEqual("System.Boolean", ident.TypeArguments[1].Type); |
|
||||||
Assert.IsTrue(ident.TypeArguments[1].IsKeyword); |
|
||||||
} |
|
||||||
|
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleInvocationExpressionTest() |
|
||||||
{ |
|
||||||
CheckSimpleInvoke(ParseUtil.ParseExpression<InvocationExpression>("myMethod()")); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericInvocationExpressionTest() |
|
||||||
{ |
|
||||||
CheckGenericInvoke(ParseUtil.ParseExpression<InvocationExpression>("myMethod(Of Char)(\"a\"c)")); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericInvocation2ExpressionTest() |
|
||||||
{ |
|
||||||
CheckGenericInvoke2(ParseUtil.ParseExpression<InvocationExpression>("myMethod(Of T, Boolean)()")); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void PrimitiveExpression1Test() |
|
||||||
{ |
|
||||||
InvocationExpression ie = ParseUtil.ParseExpression<InvocationExpression>("546.ToString()"); |
|
||||||
Assert.AreEqual(0, ie.Arguments.Count); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBInvocationOnGenericType() |
|
||||||
{ |
|
||||||
InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("A(Of T).Foo()"); |
|
||||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
|
||||||
Assert.AreEqual("Foo", mre.MemberName); |
|
||||||
SimpleNameExpression tre = (SimpleNameExpression)mre.TargetObject; |
|
||||||
Assert.AreEqual("A", tre.Identifier); |
|
||||||
Assert.AreEqual("T", tre.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBInvocationOnInnerClassInGenericType() |
|
||||||
{ |
|
||||||
InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("A(Of T).B.Foo()"); |
|
||||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
|
||||||
Assert.AreEqual("Foo", mre.MemberName); |
|
||||||
MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject; |
|
||||||
Assert.AreEqual("B", mre2.MemberName); |
|
||||||
SimpleNameExpression tre = (SimpleNameExpression)mre2.TargetObject; |
|
||||||
Assert.AreEqual("A", tre.Identifier); |
|
||||||
Assert.AreEqual("T", tre.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBInvocationOnGenericInnerClassInGenericType() |
|
||||||
{ |
|
||||||
InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("A(Of T).B.C(Of U).Foo()"); |
|
||||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
|
||||||
Assert.AreEqual("Foo", mre.MemberName); |
|
||||||
|
|
||||||
MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject; |
|
||||||
Assert.AreEqual("C", mre2.MemberName); |
|
||||||
Assert.AreEqual("U", mre2.TypeArguments[0].Type); |
|
||||||
|
|
||||||
MemberReferenceExpression mre3 = (MemberReferenceExpression)mre2.TargetObject; |
|
||||||
Assert.AreEqual("B", mre3.MemberName); |
|
||||||
|
|
||||||
SimpleNameExpression tre = (SimpleNameExpression)mre3.TargetObject; |
|
||||||
Assert.AreEqual("A", tre.Identifier); |
|
||||||
Assert.AreEqual("T", tre.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,137 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LambdaExpressionTests |
|
||||||
{ |
|
||||||
static LambdaExpression Parse(string program) |
|
||||||
{ |
|
||||||
return ParseUtil.ParseExpression<LambdaExpression>(program); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void LambdaWithParameters() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Function(x As Boolean) x Or True"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
|
||||||
Assert.AreEqual("System.Boolean", e.Parameters[0].TypeReference.Type); |
|
||||||
Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression); |
|
||||||
Assert.IsTrue(e.ReturnType.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void LambdaWithoutParameters() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Function() x Or True"); |
|
||||||
Assert.AreEqual(0, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression); |
|
||||||
Assert.IsTrue(e.ReturnType.IsNull, "ReturnType"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void NestedLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Function(x As Boolean) Function(y As Boolean) x And y"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.ExpressionBody is LambdaExpression); |
|
||||||
Assert.IsTrue(e.ReturnType.IsNull, "ReturnType"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SubLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Sub(x As Integer) Console.WriteLine(x)"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.StatementBody is ExpressionStatement); |
|
||||||
Assert.IsNotNull(e.ReturnType); |
|
||||||
Assert.AreEqual("System.Void", e.ReturnType.Type); |
|
||||||
Assert.IsTrue(e.ReturnType.IsKeyword); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SubWithStatementLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Sub(x As Integer) Call Console.WriteLine(x)"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.StatementBody is ExpressionStatement); |
|
||||||
Assert.IsNotNull(e.ReturnType); |
|
||||||
Assert.AreEqual("System.Void", e.ReturnType.Type); |
|
||||||
Assert.IsTrue(e.ReturnType.IsKeyword); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MultilineSubLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Sub(x As Integer)\n" + |
|
||||||
" For i As Integer = 0 To x\n" + |
|
||||||
" Console.WriteLine(i)\n" + |
|
||||||
" Next\n" + |
|
||||||
"End Sub"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.StatementBody is BlockStatement); |
|
||||||
Assert.IsNotNull(e.ReturnType); |
|
||||||
Assert.AreEqual("System.Void", e.ReturnType.Type); |
|
||||||
Assert.IsTrue(e.ReturnType.IsKeyword); |
|
||||||
|
|
||||||
BlockStatement b = e.StatementBody as BlockStatement; |
|
||||||
|
|
||||||
Assert.AreEqual(1, b.Children.Count); |
|
||||||
Assert.IsTrue(b.Children[0] is ForNextStatement); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MultilineFunctionLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Function(x As Integer)\n" + |
|
||||||
" Dim prod As Integer = 1\n" + |
|
||||||
" For i As Integer = 1 To x\n" + |
|
||||||
" prod = prod * i\n" + |
|
||||||
" Next\n" + |
|
||||||
" Return prod\n" + |
|
||||||
"End Function"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.StatementBody is BlockStatement); |
|
||||||
Assert.IsTrue(e.ReturnType.IsNull); |
|
||||||
|
|
||||||
BlockStatement b = e.StatementBody as BlockStatement; |
|
||||||
|
|
||||||
Assert.AreEqual(3, b.Children.Count); |
|
||||||
Assert.IsTrue(b.Children[0] is LocalVariableDeclaration); |
|
||||||
Assert.IsTrue(b.Children[1] is ForNextStatement); |
|
||||||
Assert.IsTrue(b.Children[2] is ReturnStatement); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MultilineFunctionWithReturnTypeLambda() |
|
||||||
{ |
|
||||||
LambdaExpression e = Parse("Function(x As Integer) As Integer\n" + |
|
||||||
" Dim prod As Integer = 1\n" + |
|
||||||
" For i As Integer = 1 To x\n" + |
|
||||||
" prod = prod * i\n" + |
|
||||||
" Next\n" + |
|
||||||
" Return prod\n" + |
|
||||||
"End Function"); |
|
||||||
Assert.AreEqual(1, e.Parameters.Count); |
|
||||||
Assert.IsTrue(e.StatementBody is BlockStatement); |
|
||||||
Assert.IsNotNull(e.ReturnType); |
|
||||||
Assert.AreEqual("System.Int32", e.ReturnType.Type); |
|
||||||
Assert.IsTrue(e.ReturnType.IsKeyword); |
|
||||||
|
|
||||||
BlockStatement b = e.StatementBody as BlockStatement; |
|
||||||
|
|
||||||
Assert.AreEqual(3, b.Children.Count); |
|
||||||
Assert.IsTrue(b.Children[0] is LocalVariableDeclaration); |
|
||||||
Assert.IsTrue(b.Children[1] is ForNextStatement); |
|
||||||
Assert.IsTrue(b.Children[2] is ReturnStatement); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,82 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class MemberReferenceExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleFieldReferenceExpressionTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("myTargetObject.myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsTrue(fre.TargetObject is SimpleNameExpression); |
|
||||||
Assert.AreEqual("myTargetObject", ((SimpleNameExpression)fre.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetFieldReferenceExpressionWithoutTargetTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>(".myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsTrue(fre.TargetObject.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericFieldReferenceExpressionTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("SomeClass(of string).myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsInstanceOf(typeof(SimpleNameExpression), fre.TargetObject); |
|
||||||
TypeReference tr = ((SimpleNameExpression)fre.TargetObject).TypeArguments[0]; |
|
||||||
Assert.AreEqual("System.String", tr.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetFullNamespaceGenericFieldReferenceExpressionTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("System.Subnamespace.SomeClass(of string).myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsInstanceOf(typeof(MemberReferenceExpression), fre.TargetObject); |
|
||||||
|
|
||||||
MemberReferenceExpression inner = (MemberReferenceExpression)fre.TargetObject; |
|
||||||
Assert.AreEqual("SomeClass", inner.MemberName); |
|
||||||
Assert.AreEqual(1, inner.TypeArguments.Count); |
|
||||||
Assert.AreEqual("System.String", inner.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGlobalFullNamespaceGenericFieldReferenceExpressionTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("Global.System.Subnamespace.SomeClass(of string).myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsInstanceOf(typeof(MemberReferenceExpression), fre.TargetObject); |
|
||||||
MemberReferenceExpression inner = (MemberReferenceExpression)fre.TargetObject; |
|
||||||
|
|
||||||
Assert.AreEqual("SomeClass", inner.MemberName); |
|
||||||
Assert.AreEqual(1, inner.TypeArguments.Count); |
|
||||||
Assert.AreEqual("System.String", inner.TypeArguments[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNestedGenericFieldReferenceExpressionTest() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("MyType(of string).InnerClass(of integer).myField"); |
|
||||||
Assert.AreEqual("myField", fre.MemberName); |
|
||||||
Assert.IsInstanceOf(typeof(MemberReferenceExpression), fre.TargetObject); |
|
||||||
|
|
||||||
MemberReferenceExpression inner = (MemberReferenceExpression)fre.TargetObject; |
|
||||||
Assert.AreEqual("InnerClass", inner.MemberName); |
|
||||||
} |
|
||||||
|
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,114 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ObjectCreateExpressionTests |
|
||||||
{ |
|
||||||
void CheckSimpleObjectCreateExpression(ObjectCreateExpression oce) |
|
||||||
{ |
|
||||||
Assert.AreEqual("MyObject", oce.CreateType.Type); |
|
||||||
Assert.AreEqual(3, oce.Parameters.Count); |
|
||||||
Assert.IsTrue(oce.ObjectInitializer.IsNull); |
|
||||||
|
|
||||||
for (int i = 0; i < oce.Parameters.Count; ++i) { |
|
||||||
Assert.IsTrue(oce.Parameters[i] is PrimitiveExpression); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
Expression CheckPropertyInitializationExpression(Expression e, string name) |
|
||||||
{ |
|
||||||
Assert.IsInstanceOf(typeof(MemberInitializerExpression), e); |
|
||||||
Assert.AreEqual(name, ((MemberInitializerExpression)e).Name); |
|
||||||
return ((MemberInitializerExpression)e).Expression; |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetAnonymousType() |
|
||||||
{ |
|
||||||
ObjectCreateExpression oce = ParseUtil.ParseExpression<ObjectCreateExpression>( |
|
||||||
"New With {.Id = 1, .Name= \"Bill Gates\" }"); |
|
||||||
|
|
||||||
Assert.IsTrue(oce.CreateType.IsNull); |
|
||||||
Assert.AreEqual(0, oce.Parameters.Count); |
|
||||||
Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count); |
|
||||||
|
|
||||||
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "Id")); |
|
||||||
Assert.IsInstanceOf(typeof(MemberInitializerExpression), oce.ObjectInitializer.CreateExpressions[1]); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetAnonymousTypeWithoutProperty() |
|
||||||
{ |
|
||||||
ObjectCreateExpression oce = ParseUtil.ParseExpression<ObjectCreateExpression>("New With { c }"); |
|
||||||
|
|
||||||
Assert.IsTrue(oce.CreateType.IsNull); |
|
||||||
Assert.AreEqual(0, oce.Parameters.Count); |
|
||||||
Assert.AreEqual(1, oce.ObjectInitializer.CreateExpressions.Count); |
|
||||||
|
|
||||||
Assert.IsInstanceOf(typeof(SimpleNameExpression), oce.ObjectInitializer.CreateExpressions[0]); |
|
||||||
Assert.AreEqual("c", (oce.ObjectInitializer.CreateExpressions[0] as SimpleNameExpression).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleObjectCreateExpressionTest() |
|
||||||
{ |
|
||||||
CheckSimpleObjectCreateExpression(ParseUtil.ParseExpression<ObjectCreateExpression>("New MyObject(1, 2, 3)")); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetInvalidTypeArgumentListObjectCreateExpressionTest() |
|
||||||
{ |
|
||||||
// this test was written because this bug caused the AbstractDomVisitor to crash
|
|
||||||
|
|
||||||
InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("WriteLine(New SomeGenericType(Of Integer, )())", true); |
|
||||||
Assert.IsTrue(expr.TargetObject is SimpleNameExpression); |
|
||||||
Assert.AreEqual("WriteLine", ((SimpleNameExpression)expr.TargetObject).Identifier); |
|
||||||
Assert.AreEqual(1, expr.Arguments.Count); // here a second null parameter was added incorrectly
|
|
||||||
|
|
||||||
Assert.IsTrue(expr.Arguments[0] is ObjectCreateExpression); |
|
||||||
TypeReference typeRef = ((ObjectCreateExpression)expr.Arguments[0]).CreateType; |
|
||||||
Assert.AreEqual("SomeGenericType", typeRef.Type); |
|
||||||
Assert.AreEqual(1, typeRef.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", typeRef.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMemberInitializationTest() |
|
||||||
{ |
|
||||||
ObjectCreateExpression oce = ParseUtil.ParseExpression<ObjectCreateExpression>("new Contact() With { .FirstName = \"Bill\", .LastName = \"Gates\" }"); |
|
||||||
Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count); |
|
||||||
|
|
||||||
Assert.AreEqual("FirstName", ((MemberInitializerExpression)oce.ObjectInitializer.CreateExpressions[0]).Name); |
|
||||||
Assert.AreEqual("LastName", ((MemberInitializerExpression)oce.ObjectInitializer.CreateExpressions[1]).Name); |
|
||||||
|
|
||||||
Assert.IsInstanceOf(typeof(PrimitiveExpression), ((MemberInitializerExpression)oce.ObjectInitializer.CreateExpressions[0]).Expression); |
|
||||||
Assert.IsInstanceOf(typeof(PrimitiveExpression), ((MemberInitializerExpression)oce.ObjectInitializer.CreateExpressions[1]).Expression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNullableObjectCreateExpressionTest() |
|
||||||
{ |
|
||||||
ObjectCreateExpression oce = ParseUtil.ParseExpression<ObjectCreateExpression>("New Integer?"); |
|
||||||
Assert.AreEqual("System.Nullable", oce.CreateType.Type); |
|
||||||
Assert.AreEqual(1, oce.CreateType.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", oce.CreateType.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNullableObjectArrayCreateExpressionTest() |
|
||||||
{ |
|
||||||
ObjectCreateExpression oce = ParseUtil.ParseExpression<ObjectCreateExpression>("New Integer?()"); |
|
||||||
Assert.AreEqual("System.Nullable", oce.CreateType.Type); |
|
||||||
Assert.AreEqual(1, oce.CreateType.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", oce.CreateType.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,26 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ParenthesizedExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetPrimitiveParenthesizedExpression() |
|
||||||
{ |
|
||||||
ParenthesizedExpression p = ParseUtil.ParseExpression<ParenthesizedExpression>("((1))"); |
|
||||||
Assert.IsTrue(p.Expression is ParenthesizedExpression); |
|
||||||
p = p.Expression as ParenthesizedExpression;; |
|
||||||
Assert.IsTrue(p.Expression is PrimitiveExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class PrimitiveExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void PrimitiveExpression1Test() |
|
||||||
{ |
|
||||||
InvocationExpression ie = ParseUtil.ParseExpression<InvocationExpression>("546.ToString()"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,635 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using System.Linq; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class QueryExpressionTests |
|
||||||
{ |
|
||||||
void RunTest(string expression, int expectedCount, Action<QueryExpression> constraint, params Type[] expectedTypes) |
|
||||||
{ |
|
||||||
var expr = ParseUtil.ParseExpression<QueryExpression>(expression); |
|
||||||
|
|
||||||
Assert.AreEqual(expectedCount, expr.Clauses.Count); |
|
||||||
|
|
||||||
for (int i = 0; i < expectedTypes.Length; i++) { |
|
||||||
Assert.IsTrue(expectedTypes[i] == expr.Clauses[i].GetType()); |
|
||||||
} |
|
||||||
|
|
||||||
constraint(expr); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SimpleQueryTest() |
|
||||||
{ |
|
||||||
RunTest("From o In db.Orders Select o.OrderID", 2, |
|
||||||
expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("o", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is MemberReferenceExpression); |
|
||||||
var inExpr = var1.Expression as MemberReferenceExpression; |
|
||||||
Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db"); |
|
||||||
|
|
||||||
Assert.AreEqual(1, selectClause.Variables.Count); |
|
||||||
Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression); |
|
||||||
var member = selectClause.Variables[0].Expression as MemberReferenceExpression; |
|
||||||
|
|
||||||
Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o"); |
|
||||||
}, |
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause) |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SkipTakeQueryTest() |
|
||||||
{ |
|
||||||
RunTest("From o In db.Orders Select o.OrderID Skip 10 Take 5", 4, |
|
||||||
expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause; |
|
||||||
var skipClause = expr.Clauses[2] as QueryExpressionPartitionVBClause; |
|
||||||
var takeClause = expr.Clauses[3] as QueryExpressionPartitionVBClause; |
|
||||||
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("o", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is MemberReferenceExpression); |
|
||||||
var inExpr = var1.Expression as MemberReferenceExpression; |
|
||||||
Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db"); |
|
||||||
|
|
||||||
Assert.AreEqual(1, selectClause.Variables.Count); |
|
||||||
Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression); |
|
||||||
var member = selectClause.Variables[0].Expression as MemberReferenceExpression; |
|
||||||
|
|
||||||
Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o"); |
|
||||||
|
|
||||||
Assert.AreEqual(QueryExpressionPartitionType.Skip, skipClause.PartitionType); |
|
||||||
Assert.IsTrue(skipClause.Expression is PrimitiveExpression && |
|
||||||
(skipClause.Expression as PrimitiveExpression).StringValue == "10"); |
|
||||||
|
|
||||||
Assert.AreEqual(QueryExpressionPartitionType.Take, takeClause.PartitionType); |
|
||||||
Assert.IsTrue(takeClause.Expression is PrimitiveExpression && |
|
||||||
(takeClause.Expression as PrimitiveExpression).StringValue == "5"); |
|
||||||
}, |
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause), |
|
||||||
typeof(QueryExpressionPartitionVBClause), typeof(QueryExpressionPartitionVBClause) |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SkipWhileTakeWhileQueryTest() |
|
||||||
{ |
|
||||||
RunTest("From o In db.Orders Select o.OrderID Skip While o.OrderId > 2 Take While o.OrderId < 5", 4, |
|
||||||
expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause; |
|
||||||
var skipClause = expr.Clauses[2] as QueryExpressionPartitionVBClause; |
|
||||||
var takeClause = expr.Clauses[3] as QueryExpressionPartitionVBClause; |
|
||||||
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("o", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is MemberReferenceExpression); |
|
||||||
var inExpr = var1.Expression as MemberReferenceExpression; |
|
||||||
Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db"); |
|
||||||
|
|
||||||
Assert.AreEqual(1, selectClause.Variables.Count); |
|
||||||
Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression); |
|
||||||
var member = selectClause.Variables[0].Expression as MemberReferenceExpression; |
|
||||||
|
|
||||||
Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o"); |
|
||||||
|
|
||||||
Assert.AreEqual(QueryExpressionPartitionType.SkipWhile, skipClause.PartitionType); |
|
||||||
Assert.IsTrue(skipClause.Expression is BinaryOperatorExpression); |
|
||||||
|
|
||||||
Assert.AreEqual(QueryExpressionPartitionType.TakeWhile, takeClause.PartitionType); |
|
||||||
Assert.IsTrue(takeClause.Expression is BinaryOperatorExpression); |
|
||||||
}, |
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause), |
|
||||||
typeof(QueryExpressionPartitionVBClause), typeof(QueryExpressionPartitionVBClause) |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void MultipleValuesSelectTest() |
|
||||||
{ |
|
||||||
RunTest(@"From i In list Select i, x2 = i^2", |
|
||||||
2, expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("i", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list"); |
|
||||||
|
|
||||||
Assert.AreEqual(2, selectClause.Variables.Count); |
|
||||||
|
|
||||||
var selectExpr1 = selectClause.Variables[0]; |
|
||||||
var selectExpr2 = selectClause.Variables[1]; |
|
||||||
|
|
||||||
Assert.IsEmpty(selectExpr1.Identifier); |
|
||||||
Assert.IsTrue(selectExpr1.Expression is IdentifierExpression && |
|
||||||
(selectExpr1.Expression as IdentifierExpression).Identifier == "i"); |
|
||||||
|
|
||||||
Assert.AreEqual("x2", selectExpr2.Identifier); |
|
||||||
Assert.IsTrue(selectExpr2.Type.IsNull); |
|
||||||
Assert.IsTrue(selectExpr2.Expression is BinaryOperatorExpression); |
|
||||||
|
|
||||||
var binOp = selectExpr2.Expression as BinaryOperatorExpression; |
|
||||||
|
|
||||||
Assert.AreEqual(BinaryOperatorType.Power, binOp.Op); |
|
||||||
Assert.IsTrue(binOp.Left is IdentifierExpression && (binOp.Left as IdentifierExpression).Identifier == "i"); |
|
||||||
Assert.IsTrue(binOp.Right is PrimitiveExpression && (binOp.Right as PrimitiveExpression).StringValue == "2"); |
|
||||||
}, |
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause) |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GroupTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause; |
|
||||||
var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var fromVar1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("p", fromVar1.Identifier); |
|
||||||
Assert.IsTrue(fromVar1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "products"); |
|
||||||
|
|
||||||
Assert.AreEqual(1, groupClause.GroupVariables.Count); |
|
||||||
Assert.AreEqual(1, groupClause.ByVariables.Count); |
|
||||||
Assert.AreEqual(1, groupClause.IntoVariables.Count); |
|
||||||
|
|
||||||
var gv = groupClause.GroupVariables.First(); |
|
||||||
var bv = groupClause.ByVariables.First(); |
|
||||||
var iv = groupClause.IntoVariables.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(gv.Expression is IdentifierExpression && (gv.Expression as IdentifierExpression).Identifier == "p"); |
|
||||||
Assert.IsTrue(bv.Expression is MemberReferenceExpression && |
|
||||||
(bv.Expression as MemberReferenceExpression).MemberName == "Category"); |
|
||||||
Assert.IsTrue((bv.Expression as MemberReferenceExpression).TargetObject is IdentifierExpression && |
|
||||||
((bv.Expression as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "p"); |
|
||||||
Assert.IsTrue(iv.Expression is IdentifierExpression && |
|
||||||
(iv.Expression as IdentifierExpression).Identifier == "Group"); |
|
||||||
|
|
||||||
Assert.AreEqual(2, selectClause.Variables.Count); |
|
||||||
|
|
||||||
var var1 = selectClause.Variables.First(); |
|
||||||
var var2 = selectClause.Variables.Skip(1).First(); |
|
||||||
|
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression && |
|
||||||
(var1.Expression as IdentifierExpression).Identifier == "Category"); |
|
||||||
Assert.IsTrue(var2.Expression is InvocationExpression && |
|
||||||
(var2.Expression as InvocationExpression).TargetObject is MemberReferenceExpression && |
|
||||||
((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "Average" && |
|
||||||
((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression && |
|
||||||
(((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "Group"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From p In products _
|
|
||||||
Group p By p.Category Into Group _ |
|
||||||
Select Category, AveragePrice = Group.Average(Function(p) p.UnitPrice)", 3, constraint,
|
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionSelectVBClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void LetTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause; |
|
||||||
var letClause = expr.Clauses[2] as QueryExpressionLetClause; |
|
||||||
var selectClause = expr.Clauses[3] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var fromVar1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("p", fromVar1.Identifier); |
|
||||||
Assert.IsTrue(fromVar1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "products"); |
|
||||||
|
|
||||||
// Group By Into
|
|
||||||
Assert.AreEqual(1, groupClause.GroupVariables.Count); |
|
||||||
Assert.AreEqual(1, groupClause.ByVariables.Count); |
|
||||||
Assert.AreEqual(1, groupClause.IntoVariables.Count); |
|
||||||
|
|
||||||
var gv = groupClause.GroupVariables.First(); |
|
||||||
var bv = groupClause.ByVariables.First(); |
|
||||||
var iv = groupClause.IntoVariables.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(gv.Expression is IdentifierExpression && (gv.Expression as IdentifierExpression).Identifier == "p"); |
|
||||||
CheckMemberReferenceExpression(bv.Expression, "Category", "p"); |
|
||||||
Assert.IsTrue(iv.Expression is IdentifierExpression && |
|
||||||
(iv.Expression as IdentifierExpression).Identifier == "Group"); |
|
||||||
|
|
||||||
// Let
|
|
||||||
Assert.AreEqual(1, letClause.Variables.Count); |
|
||||||
|
|
||||||
var letVariable = letClause.Variables.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("minPrice", letVariable.Identifier); |
|
||||||
Assert.IsTrue(letVariable.Expression is InvocationExpression); |
|
||||||
CheckMemberReferenceExpression((letVariable.Expression as InvocationExpression).TargetObject, "Min", "Group"); |
|
||||||
|
|
||||||
// Select
|
|
||||||
Assert.AreEqual(2, selectClause.Variables.Count); |
|
||||||
|
|
||||||
var var1 = selectClause.Variables.First(); |
|
||||||
var var2 = selectClause.Variables.Skip(1).First(); |
|
||||||
|
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression && |
|
||||||
(var1.Expression as IdentifierExpression).Identifier == "Category"); |
|
||||||
Assert.IsTrue(var2.Expression is InvocationExpression); |
|
||||||
CheckMemberReferenceExpression((var2.Expression as InvocationExpression).TargetObject, "Where", "Group"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From p In products _
|
|
||||||
Group p By p.Category Into Group _ |
|
||||||
Let minPrice = Group.Min(Function(p) p.UnitPrice) _ |
|
||||||
Select Category, CheapestProducts = Group.Where(Function(p) p.UnitPrice = minPrice)", 4, constraint,
|
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionLetClause), typeof(QueryExpressionSelectVBClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CrossJoinTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var joinClause = expr.Clauses[1] as QueryExpressionJoinVBClause; |
|
||||||
var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var fromVar1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("c", fromVar1.Identifier); |
|
||||||
Assert.IsTrue(fromVar1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "categories"); |
|
||||||
|
|
||||||
// Join In On Equals
|
|
||||||
var inClause = joinClause.JoinVariable as CollectionRangeVariable; |
|
||||||
|
|
||||||
Assert.AreEqual("p", inClause.Identifier); |
|
||||||
Assert.IsTrue(inClause.Expression is IdentifierExpression && |
|
||||||
(inClause.Expression as IdentifierExpression).Identifier == "products"); |
|
||||||
|
|
||||||
Assert.IsTrue(joinClause.SubJoin.IsNull); |
|
||||||
|
|
||||||
Assert.AreEqual(1, joinClause.Conditions.Count); |
|
||||||
|
|
||||||
var condition1 = joinClause.Conditions.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(condition1.LeftSide is IdentifierExpression && (condition1.LeftSide as IdentifierExpression).Identifier == "c"); |
|
||||||
|
|
||||||
CheckMemberReferenceExpression(condition1.RightSide, "Category", "p"); |
|
||||||
|
|
||||||
// Select
|
|
||||||
Assert.AreEqual(2, selectClause.Variables.Count); |
|
||||||
|
|
||||||
var var1 = selectClause.Variables.First(); |
|
||||||
var var2 = selectClause.Variables.Skip(1).First(); |
|
||||||
|
|
||||||
Assert.AreEqual("Category", var1.Identifier); |
|
||||||
Assert.IsEmpty(var2.Identifier); |
|
||||||
|
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression && |
|
||||||
(var1.Expression as IdentifierExpression).Identifier == "c"); |
|
||||||
CheckMemberReferenceExpression(var2.Expression, "ProductName", "p"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From c In categories _
|
|
||||||
Join p In products On c Equals p.Category _ |
|
||||||
Select Category = c, p.ProductName", 3, constraint,
|
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionJoinVBClause), typeof(QueryExpressionSelectVBClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OrderByTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var orderClause = expr.Clauses[1] as QueryExpressionOrderClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("i", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list"); |
|
||||||
|
|
||||||
// Order By
|
|
||||||
Assert.AreEqual(1, orderClause.Orderings.Count); |
|
||||||
|
|
||||||
var ordering1 = orderClause.Orderings.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(ordering1.Criteria is IdentifierExpression && |
|
||||||
(ordering1.Criteria as IdentifierExpression).Identifier == "i"); |
|
||||||
Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering1.Direction); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From i In list Order By i", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OrderByTest2() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var orderClause = expr.Clauses[1] as QueryExpressionOrderClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("i", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list"); |
|
||||||
|
|
||||||
// Order By
|
|
||||||
Assert.AreEqual(1, orderClause.Orderings.Count); |
|
||||||
|
|
||||||
var ordering1 = orderClause.Orderings.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(ordering1.Criteria is IdentifierExpression && |
|
||||||
(ordering1.Criteria as IdentifierExpression).Identifier == "i"); |
|
||||||
Assert.AreEqual(QueryExpressionOrderingDirection.Ascending, ordering1.Direction); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From i In list Order By i Ascending", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OrderByTest3() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var orderClause = expr.Clauses[1] as QueryExpressionOrderClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("i", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list"); |
|
||||||
|
|
||||||
// Order By
|
|
||||||
Assert.AreEqual(1, orderClause.Orderings.Count); |
|
||||||
|
|
||||||
var ordering1 = orderClause.Orderings.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(ordering1.Criteria is IdentifierExpression && |
|
||||||
(ordering1.Criteria as IdentifierExpression).Identifier == "i"); |
|
||||||
Assert.AreEqual(QueryExpressionOrderingDirection.Descending, ordering1.Direction); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From i In list Order By i Descending", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void OrderByThenByTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var orderClause = expr.Clauses[1] as QueryExpressionOrderClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("d", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "digits"); |
|
||||||
|
|
||||||
// Order By
|
|
||||||
Assert.AreEqual(2, orderClause.Orderings.Count); |
|
||||||
|
|
||||||
var ordering1 = orderClause.Orderings.First(); |
|
||||||
var ordering2 = orderClause.Orderings.Skip(1).First(); |
|
||||||
|
|
||||||
CheckMemberReferenceExpression(ordering1.Criteria, "Length", "d"); |
|
||||||
|
|
||||||
Assert.IsTrue(ordering2.Criteria is IdentifierExpression && |
|
||||||
(ordering2.Criteria as IdentifierExpression).Identifier == "d"); |
|
||||||
|
|
||||||
Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering1.Direction); |
|
||||||
Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering2.Direction); |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From d In digits _
|
|
||||||
Order By d.Length, d", 2, constraint,
|
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void DistinctTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(1, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("d", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "digits"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From d In digits Distinct", 2, constraint, |
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionDistinctClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void AggregateTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var clause = expr.Clauses[0] as QueryExpressionAggregateClause; |
|
||||||
|
|
||||||
Assert.AreEqual("p", clause.Source.Identifier); |
|
||||||
CheckMemberReferenceExpression(clause.Source.Expression, "GetProcesses", "Process"); |
|
||||||
|
|
||||||
Assert.AreEqual(1, clause.IntoVariables.Count); |
|
||||||
|
|
||||||
var into1 = clause.IntoVariables.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("virtualMemory", into1.Identifier); |
|
||||||
|
|
||||||
Assert.IsTrue(into1.Expression is InvocationExpression && |
|
||||||
(into1.Expression as InvocationExpression).TargetObject is IdentifierExpression && |
|
||||||
((into1.Expression as InvocationExpression).TargetObject as IdentifierExpression).Identifier == "Sum"); |
|
||||||
Assert.AreEqual(1, (into1.Expression as InvocationExpression).Arguments.Count); |
|
||||||
CheckMemberReferenceExpression((into1.Expression as InvocationExpression).Arguments.First(), "VirtualMemorySize64", "p"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"Aggregate p In Process.GetProcesses _
|
|
||||||
Into virtualMemory = Sum(p.VirtualMemorySize64)", 1, constraint, typeof(QueryExpressionAggregateClause));
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void GroupJoinTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause1 = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var groupJoinClause = expr.Clauses[1] as QueryExpressionGroupJoinVBClause; |
|
||||||
var fromClause2 = expr.Clauses[2] as QueryExpressionFromClause; |
|
||||||
var selectClause = expr.Clauses[3] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
// From 1
|
|
||||||
Assert.AreEqual(1, fromClause1.Sources.Count); |
|
||||||
|
|
||||||
var var1 = fromClause1.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("s", var1.Identifier); |
|
||||||
Assert.IsTrue(var1.Expression is IdentifierExpression && |
|
||||||
(var1.Expression as IdentifierExpression).Identifier == "fileList"); |
|
||||||
|
|
||||||
// From 2
|
|
||||||
Assert.AreEqual(1, fromClause2.Sources.Count); |
|
||||||
|
|
||||||
var var2 = fromClause2.Sources.First(); |
|
||||||
|
|
||||||
Assert.AreEqual("p", var2.Identifier); |
|
||||||
Assert.IsTrue(var2.Expression is IdentifierExpression && |
|
||||||
(var2.Expression as IdentifierExpression).Identifier == "Group"); |
|
||||||
|
|
||||||
// Select
|
|
||||||
Assert.AreEqual(1, selectClause.Variables.Count); |
|
||||||
|
|
||||||
var var3 = selectClause.Variables.First(); |
|
||||||
|
|
||||||
Assert.IsEmpty(var3.Identifier); |
|
||||||
Assert.IsTrue(var3.Expression is IdentifierExpression && |
|
||||||
(var3.Expression as IdentifierExpression).Identifier == "s"); |
|
||||||
|
|
||||||
// Group Join
|
|
||||||
var joinClause = groupJoinClause.JoinClause; |
|
||||||
|
|
||||||
// Join In On Equals
|
|
||||||
var inClause = joinClause.JoinVariable as CollectionRangeVariable; |
|
||||||
|
|
||||||
Assert.AreEqual("p", inClause.Identifier); |
|
||||||
Assert.IsTrue(inClause.Expression is IdentifierExpression && |
|
||||||
(inClause.Expression as IdentifierExpression).Identifier == "IMAGES"); |
|
||||||
|
|
||||||
Assert.IsTrue(joinClause.SubJoin.IsNull); |
|
||||||
|
|
||||||
Assert.AreEqual(1, joinClause.Conditions.Count); |
|
||||||
|
|
||||||
var condition1 = joinClause.Conditions.First(); |
|
||||||
|
|
||||||
Assert.IsTrue(condition1.LeftSide is InvocationExpression); |
|
||||||
Assert.IsTrue((condition1.LeftSide as InvocationExpression).TargetObject is MemberReferenceExpression); |
|
||||||
Assert.IsTrue(((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "ToUpper"); |
|
||||||
Assert.IsTrue(((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is MemberReferenceExpression); |
|
||||||
Assert.IsTrue((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).MemberName == "Extension"); |
|
||||||
Assert.IsTrue((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression); |
|
||||||
Assert.IsTrue(((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "s"); |
|
||||||
|
|
||||||
Assert.IsTrue(condition1.RightSide is InvocationExpression); |
|
||||||
Assert.IsTrue((condition1.RightSide as InvocationExpression).TargetObject is MemberReferenceExpression); |
|
||||||
Assert.IsTrue(((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "ToUpper"); |
|
||||||
Assert.IsTrue(((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression); |
|
||||||
Assert.IsTrue((((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "p"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From s In fileList _
|
|
||||||
Group Join p In IMAGES On s.Extension.ToUpper() Equals p.ToUpper() Into Group _ |
|
||||||
From p In Group _ |
|
||||||
Select s", 4, constraint,
|
|
||||||
typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupJoinVBClause), typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void SelectManyTest() |
|
||||||
{ |
|
||||||
Action<QueryExpression> constraint = expr => { |
|
||||||
var fromClause = expr.Clauses[0] as QueryExpressionFromClause; |
|
||||||
var whereClause = expr.Clauses[1] as QueryExpressionWhereClause; |
|
||||||
var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause; |
|
||||||
|
|
||||||
// From
|
|
||||||
Assert.AreEqual(2, fromClause.Sources.Count); |
|
||||||
|
|
||||||
var fromVar1 = fromClause.Sources.First(); |
|
||||||
var fromVar2 = fromClause.Sources.Skip(1).First(); |
|
||||||
|
|
||||||
Assert.AreEqual("c", fromVar1.Identifier); |
|
||||||
Assert.IsTrue(fromVar1.Expression is IdentifierExpression); |
|
||||||
Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "customers"); |
|
||||||
|
|
||||||
Assert.AreEqual("o", fromVar2.Identifier); |
|
||||||
CheckMemberReferenceExpression(fromVar2.Expression, "Orders", "c"); |
|
||||||
|
|
||||||
// Where
|
|
||||||
Assert.IsTrue(whereClause.Condition is BinaryOperatorExpression); |
|
||||||
Assert.IsTrue((whereClause.Condition as BinaryOperatorExpression).Op == BinaryOperatorType.LessThan); |
|
||||||
CheckMemberReferenceExpression((whereClause.Condition as BinaryOperatorExpression).Left, "Total", "o"); |
|
||||||
Assert.IsTrue((whereClause.Condition as BinaryOperatorExpression).Right is PrimitiveExpression); |
|
||||||
Assert.IsTrue((double)((whereClause.Condition as BinaryOperatorExpression).Right as PrimitiveExpression).Value == 500.0); |
|
||||||
|
|
||||||
// Select
|
|
||||||
foreach (var v in selectClause.Variables) { |
|
||||||
Assert.IsEmpty(v.Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
var var1 = selectClause.Variables.First(); |
|
||||||
var var2 = selectClause.Variables.Skip(1).First(); |
|
||||||
var var3 = selectClause.Variables.Skip(2).First(); |
|
||||||
|
|
||||||
CheckMemberReferenceExpression(var1.Expression, "CustomerID", "c"); |
|
||||||
CheckMemberReferenceExpression(var2.Expression, "OrderID", "o"); |
|
||||||
CheckMemberReferenceExpression(var3.Expression, "Total", "o"); |
|
||||||
}; |
|
||||||
|
|
||||||
RunTest(@"From c In customers, o In c.Orders _
|
|
||||||
Where o.Total < 500.0 _ |
|
||||||
Select c.CustomerID, o.OrderID, o.Total", 3, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionWhereClause), typeof(QueryExpressionSelectVBClause));
|
|
||||||
} |
|
||||||
|
|
||||||
void CheckMemberReferenceExpression(Expression expr, string memberName, string targetObjectIdentifier) |
|
||||||
{ |
|
||||||
Assert.IsTrue(expr is MemberReferenceExpression); |
|
||||||
Assert.IsTrue((expr as MemberReferenceExpression).MemberName == memberName && |
|
||||||
(expr as MemberReferenceExpression).TargetObject is IdentifierExpression && |
|
||||||
((expr as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == targetObjectIdentifier); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ThisReferenceExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetThisReferenceExpressionTest1() |
|
||||||
{ |
|
||||||
ThisReferenceExpression ie = ParseUtil.ParseExpression<ThisReferenceExpression>("Me"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,87 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TypeOfExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBSimpleTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(MyNamespace.N1.MyType)"); |
|
||||||
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBGlobalTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(Global.System.Console)"); |
|
||||||
Assert.AreEqual("System.Console", toe.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBPrimitiveTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(integer)"); |
|
||||||
Assert.AreEqual("System.Int32", toe.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBVoidTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(void)"); |
|
||||||
Assert.AreEqual("void", toe.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBArrayTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(MyType())"); |
|
||||||
Assert.AreEqual("MyType", toe.TypeReference.Type); |
|
||||||
Assert.AreEqual(new int[] {0}, toe.TypeReference.RankSpecifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBGenericTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(MyNamespace.N1.MyType(Of string))"); |
|
||||||
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); |
|
||||||
Assert.AreEqual("System.String", toe.TypeReference.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBUnboundTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(MyType(Of ,))"); |
|
||||||
Assert.AreEqual("MyType", toe.TypeReference.Type); |
|
||||||
Assert.IsTrue(toe.TypeReference.GenericTypes[0].IsNull); |
|
||||||
Assert.IsTrue(toe.TypeReference.GenericTypes[1].IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNestedGenericTypeOfExpressionTest() |
|
||||||
{ |
|
||||||
TypeOfExpression toe = ParseUtil.ParseExpression<TypeOfExpression>("GetType(MyType(Of string).InnerClass(of integer).InnerInnerClass)"); |
|
||||||
InnerClassTypeReference ic = (InnerClassTypeReference)toe.TypeReference; |
|
||||||
Assert.AreEqual("InnerInnerClass", ic.Type); |
|
||||||
Assert.AreEqual(0, ic.GenericTypes.Count); |
|
||||||
ic = (InnerClassTypeReference)ic.BaseType; |
|
||||||
Assert.AreEqual("InnerClass", ic.Type); |
|
||||||
Assert.AreEqual(1, ic.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual("MyType", ic.BaseType.Type); |
|
||||||
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,34 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TypeOfIsExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleTypeOfIsExpression() |
|
||||||
{ |
|
||||||
TypeOfIsExpression ce = ParseUtil.ParseExpression<TypeOfIsExpression>("TypeOf o Is MyObject"); |
|
||||||
Assert.AreEqual("MyObject", ce.TypeReference.Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericTypeOfIsExpression() |
|
||||||
{ |
|
||||||
TypeOfIsExpression ce = ParseUtil.ParseExpression<TypeOfIsExpression>("TypeOf o Is List(of T)"); |
|
||||||
Assert.AreEqual("List", ce.TypeReference.Type); |
|
||||||
Assert.AreEqual("T", ce.TypeReference.GenericTypes[0].Type); |
|
||||||
Assert.IsTrue(ce.Expression is SimpleNameExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,47 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TypeReferenceExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBIntReferenceExpression() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("inTeGer.MaxValue"); |
|
||||||
Assert.AreEqual("MaxValue", fre.MemberName); |
|
||||||
Assert.AreEqual("System.Int32", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBStandaloneIntReferenceExpression() |
|
||||||
{ |
|
||||||
TypeReferenceExpression tre = ParseUtil.ParseExpression<TypeReferenceExpression>("inTeGer"); |
|
||||||
Assert.AreEqual("System.Int32", tre.TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBObjectReferenceExpression() |
|
||||||
{ |
|
||||||
MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("Object.ReferenceEquals"); |
|
||||||
Assert.AreEqual("ReferenceEquals", fre.MemberName); |
|
||||||
Assert.AreEqual("System.Object", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBStandaloneObjectReferenceExpression() |
|
||||||
{ |
|
||||||
TypeReferenceExpression tre = ParseUtil.ParseExpression<TypeReferenceExpression>("obJect"); |
|
||||||
Assert.AreEqual("System.Object", tre.TypeReference.Type); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,61 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class UnaryOperatorExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
void VBNetTestUnaryOperatorExpressionTest(string program, UnaryOperatorType op) |
|
||||||
{ |
|
||||||
UnaryOperatorExpression uoe = ParseUtil.ParseExpression<UnaryOperatorExpression>(program); |
|
||||||
Assert.AreEqual(op, uoe.Op); |
|
||||||
|
|
||||||
Assert.IsTrue(uoe.Expression is SimpleNameExpression); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNotTest() |
|
||||||
{ |
|
||||||
VBNetTestUnaryOperatorExpressionTest("Not a", UnaryOperatorType.Not); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetInEqualsNotTest() |
|
||||||
{ |
|
||||||
BinaryOperatorExpression e = ParseUtil.ParseExpression<BinaryOperatorExpression>("b <> Not a"); |
|
||||||
Assert.AreEqual(BinaryOperatorType.InEquality, e.Op); |
|
||||||
UnaryOperatorExpression ue = (UnaryOperatorExpression)e.Right; |
|
||||||
Assert.AreEqual(UnaryOperatorType.Not, ue.Op); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNotEqualTest() |
|
||||||
{ |
|
||||||
UnaryOperatorExpression e = ParseUtil.ParseExpression<UnaryOperatorExpression>("Not a = b"); |
|
||||||
Assert.AreEqual(UnaryOperatorType.Not, e.Op); |
|
||||||
BinaryOperatorExpression boe = (BinaryOperatorExpression)e.Expression; |
|
||||||
Assert.AreEqual(BinaryOperatorType.Equality, boe.Op); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetPlusTest() |
|
||||||
{ |
|
||||||
VBNetTestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMinusTest() |
|
||||||
{ |
|
||||||
VBNetTestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,255 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class XmlExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleCommentTest() |
|
||||||
{ |
|
||||||
XmlContentExpression content = ParseUtil.ParseExpression<XmlContentExpression>("<!-- test -->"); |
|
||||||
Assert.AreEqual(XmlContentType.Comment, content.Type); |
|
||||||
Assert.AreEqual(" test ", content.Content); |
|
||||||
Assert.AreEqual(new Location(1,1), content.StartLocation); |
|
||||||
Assert.AreEqual(new Location(14,1), content.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimplePreprocessingInstructionTest() |
|
||||||
{ |
|
||||||
XmlContentExpression content = ParseUtil.ParseExpression<XmlContentExpression>("<?xml version='1.0'?>"); |
|
||||||
Assert.AreEqual(XmlContentType.ProcessingInstruction, content.Type); |
|
||||||
Assert.AreEqual("xml version='1.0'", content.Content); |
|
||||||
Assert.AreEqual(new Location(1,1), content.StartLocation); |
|
||||||
Assert.AreEqual(new Location(22,1), content.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleCDataTest() |
|
||||||
{ |
|
||||||
XmlContentExpression content = ParseUtil.ParseExpression<XmlContentExpression>("<![CDATA[<simple> <cdata>]]>"); |
|
||||||
Assert.AreEqual(XmlContentType.CData, content.Type); |
|
||||||
Assert.AreEqual("<simple> <cdata>", content.Content); |
|
||||||
Assert.AreEqual(new Location(1,1), content.StartLocation); |
|
||||||
Assert.AreEqual(new Location(29,1), content.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleEmptyElementTest() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test />"); |
|
||||||
Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
Assert.IsEmpty(element.Attributes); |
|
||||||
Assert.IsEmpty(element.Children); |
|
||||||
Assert.AreEqual(new Location(1,1), element.StartLocation); |
|
||||||
Assert.AreEqual(new Location(9,1), element.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleEmptyElementWithAttributeTest() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test id='0' />"); |
|
||||||
Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
Assert.IsNotEmpty(element.Attributes); |
|
||||||
Assert.AreEqual(1, element.Attributes.Count); |
|
||||||
Assert.IsTrue(element.Attributes[0] is XmlAttributeExpression); |
|
||||||
XmlAttributeExpression attribute = element.Attributes[0] as XmlAttributeExpression; |
|
||||||
Assert.AreEqual("id", attribute.Name); |
|
||||||
Assert.IsTrue(attribute.IsLiteralValue); |
|
||||||
Assert.IsTrue(attribute.ExpressionValue.IsNull); |
|
||||||
Assert.AreEqual("0", attribute.LiteralValue); |
|
||||||
Assert.AreEqual(new Location(7,1), attribute.StartLocation); |
|
||||||
Assert.AreEqual(new Location(13,1), attribute.EndLocation); |
|
||||||
Assert.IsEmpty(element.Children); |
|
||||||
Assert.AreEqual(new Location(1,1), element.StartLocation); |
|
||||||
Assert.AreEqual(new Location(16,1), element.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleEmptyElementWithAttributesTest() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test id='0' name=<%= name %> <%= contentData %> />"); Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
Assert.IsNotEmpty(element.Attributes); |
|
||||||
Assert.AreEqual(3, element.Attributes.Count); |
|
||||||
|
|
||||||
Assert.IsTrue(element.Attributes[0] is XmlAttributeExpression); |
|
||||||
XmlAttributeExpression attribute = element.Attributes[0] as XmlAttributeExpression; |
|
||||||
Assert.AreEqual("id", attribute.Name); |
|
||||||
Assert.IsTrue(attribute.IsLiteralValue); |
|
||||||
Assert.IsTrue(attribute.ExpressionValue.IsNull); |
|
||||||
Assert.AreEqual("0", attribute.LiteralValue); |
|
||||||
Assert.AreEqual(new Location(7,1), attribute.StartLocation); |
|
||||||
Assert.AreEqual(new Location(13,1), attribute.EndLocation); |
|
||||||
|
|
||||||
Assert.IsTrue(element.Attributes[1] is XmlAttributeExpression); |
|
||||||
XmlAttributeExpression attribute2 = element.Attributes[1] as XmlAttributeExpression; |
|
||||||
Assert.AreEqual("name", attribute2.Name); |
|
||||||
Assert.IsFalse(attribute2.IsLiteralValue); |
|
||||||
Assert.IsFalse(attribute2.ExpressionValue.IsNull); |
|
||||||
|
|
||||||
Assert.IsTrue(attribute2.ExpressionValue is IdentifierExpression); |
|
||||||
IdentifierExpression identifier = attribute2.ExpressionValue as IdentifierExpression; |
|
||||||
Assert.AreEqual("name", identifier.Identifier); |
|
||||||
Assert.AreEqual(new Location(23,1), identifier.StartLocation); |
|
||||||
Assert.AreEqual(new Location(27,1), identifier.EndLocation); |
|
||||||
|
|
||||||
Assert.AreEqual(new Location(14,1), attribute2.StartLocation); |
|
||||||
Assert.AreEqual(new Location(30,1), attribute2.EndLocation); |
|
||||||
|
|
||||||
Assert.IsTrue(element.Attributes[2] is XmlEmbeddedExpression); |
|
||||||
XmlEmbeddedExpression attribute3 = element.Attributes[2] as XmlEmbeddedExpression; |
|
||||||
|
|
||||||
Assert.IsTrue(attribute3.InlineVBExpression is IdentifierExpression); |
|
||||||
IdentifierExpression identifier2 = attribute3.InlineVBExpression as IdentifierExpression; |
|
||||||
|
|
||||||
Assert.AreEqual("contentData", identifier2.Identifier); |
|
||||||
Assert.AreEqual(new Location(35,1), identifier2.StartLocation); |
|
||||||
Assert.AreEqual(new Location(46,1), identifier2.EndLocation); |
|
||||||
|
|
||||||
Assert.AreEqual(new Location(31,1), attribute3.StartLocation); |
|
||||||
Assert.AreEqual(new Location(49,1), attribute3.EndLocation); |
|
||||||
|
|
||||||
Assert.IsEmpty(element.Children); |
|
||||||
Assert.AreEqual(new Location(1,1), element.StartLocation); |
|
||||||
Assert.AreEqual(new Location(52,1), element.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetElementWithAttributeTest() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test id='0'>\n" + |
|
||||||
" <Item />\n" + |
|
||||||
" <Item />\n" + |
|
||||||
"</Test>"); |
|
||||||
Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
|
|
||||||
Assert.IsNotEmpty(element.Attributes); |
|
||||||
Assert.AreEqual(1, element.Attributes.Count); |
|
||||||
Assert.IsTrue(element.Attributes[0] is XmlAttributeExpression); |
|
||||||
XmlAttributeExpression attribute = element.Attributes[0] as XmlAttributeExpression; |
|
||||||
Assert.AreEqual("id", attribute.Name); |
|
||||||
Assert.IsTrue(attribute.IsLiteralValue); |
|
||||||
Assert.IsTrue(attribute.ExpressionValue.IsNull); |
|
||||||
Assert.AreEqual("0", attribute.LiteralValue); |
|
||||||
Assert.AreEqual(new Location(7,1), attribute.StartLocation); |
|
||||||
Assert.AreEqual(new Location(13,1), attribute.EndLocation); |
|
||||||
|
|
||||||
Assert.IsNotEmpty(element.Children); |
|
||||||
Assert.AreEqual(5, element.Children.Count); |
|
||||||
|
|
||||||
CheckContent(element.Children[0], "\n\t", XmlContentType.Text, new Location(14,1), new Location(2,2)); |
|
||||||
CheckContent(element.Children[2], "\n\t", XmlContentType.Text, new Location(10,2), new Location(2,3)); |
|
||||||
CheckContent(element.Children[4], "\n", XmlContentType.Text, new Location(10,3), new Location(1,4)); |
|
||||||
|
|
||||||
CheckElement(element.Children[1], "Item", new Location(2,2), new Location(10,2)); |
|
||||||
CheckElement(element.Children[3], "Item", new Location(2,3), new Location(10,3)); |
|
||||||
|
|
||||||
Assert.AreEqual(new Location(1,1), element.StartLocation); |
|
||||||
Assert.AreEqual(new Location(8,4), element.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetElementWithMixedContentTest() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test id='0'>\n" + |
|
||||||
" <!-- test -->\n" + |
|
||||||
" <Item />\n" + |
|
||||||
" <Item />\n" + |
|
||||||
" <![CDATA[<cdata> section]]>\n" + |
|
||||||
"</Test>"); |
|
||||||
Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
|
|
||||||
Assert.IsNotEmpty(element.Attributes); |
|
||||||
Assert.AreEqual(1, element.Attributes.Count); |
|
||||||
Assert.IsTrue(element.Attributes[0] is XmlAttributeExpression); |
|
||||||
XmlAttributeExpression attribute = element.Attributes[0] as XmlAttributeExpression; |
|
||||||
Assert.AreEqual("id", attribute.Name); |
|
||||||
Assert.IsTrue(attribute.IsLiteralValue); |
|
||||||
Assert.IsTrue(attribute.ExpressionValue.IsNull); |
|
||||||
Assert.AreEqual("0", attribute.LiteralValue); |
|
||||||
Assert.AreEqual(new Location(7,1), attribute.StartLocation); |
|
||||||
Assert.AreEqual(new Location(13,1), attribute.EndLocation); |
|
||||||
|
|
||||||
Assert.IsNotEmpty(element.Children); |
|
||||||
Assert.AreEqual(9, element.Children.Count); |
|
||||||
|
|
||||||
CheckContent(element.Children[0], "\n\t", XmlContentType.Text, new Location(14,1), new Location(2,2)); |
|
||||||
CheckContent(element.Children[2], "\n\t", XmlContentType.Text, new Location(15,2), new Location(2,3)); |
|
||||||
CheckContent(element.Children[4], "\n\t", XmlContentType.Text, new Location(10,3), new Location(2,4)); |
|
||||||
CheckContent(element.Children[6], "\n\t", XmlContentType.Text, new Location(10,4), new Location(2,5)); |
|
||||||
CheckContent(element.Children[7], "<cdata> section", XmlContentType.CData, new Location(2,5), new Location(29,5)); |
|
||||||
CheckContent(element.Children[8], "\n", XmlContentType.Text, new Location(29,5), new Location(1,6)); |
|
||||||
|
|
||||||
CheckContent(element.Children[1], " test ", XmlContentType.Comment, new Location(2,2), new Location(15,2)); |
|
||||||
CheckElement(element.Children[3], "Item", new Location(2,3), new Location(10,3)); |
|
||||||
CheckElement(element.Children[5], "Item", new Location(2,4), new Location(10,4)); |
|
||||||
|
|
||||||
Assert.AreEqual(new Location(1,1), element.StartLocation); |
|
||||||
Assert.AreEqual(new Location(8,6), element.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetElementWithMixedContentTest2() |
|
||||||
{ |
|
||||||
XmlElementExpression element = ParseUtil.ParseExpression<XmlElementExpression>("<Test> aaaa </Test>"); |
|
||||||
Assert.IsFalse(element.NameIsExpression); |
|
||||||
Assert.AreEqual("Test", element.XmlName); |
|
||||||
|
|
||||||
Assert.IsNotEmpty(element.Children); |
|
||||||
Assert.AreEqual(1, element.Children.Count); |
|
||||||
|
|
||||||
CheckContent(element.Children[0], " aaaa ", XmlContentType.Text, new Location(7,1), new Location(14,1)); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetProcessingInstructionAndCommentAtEndTest() |
|
||||||
{ |
|
||||||
XmlDocumentExpression document = ParseUtil.ParseExpression<XmlDocumentExpression>("<Test />\n" + |
|
||||||
"<!-- test -->\n" + |
|
||||||
"<?target some text?>"); |
|
||||||
Assert.IsNotEmpty(document.Expressions); |
|
||||||
Assert.AreEqual(3, document.Expressions.Count); |
|
||||||
|
|
||||||
CheckElement(document.Expressions[0], "Test", new Location(1,1), new Location(9,1)); |
|
||||||
CheckContent(document.Expressions[1], " test ", XmlContentType.Comment, new Location(1,2), new Location(14,2)); |
|
||||||
CheckContent(document.Expressions[2], "target some text", XmlContentType.ProcessingInstruction, new Location(1,3), new Location(21,3)); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
void CheckElement(AstNode node, string name, AstLocation start, AstLocation end) |
|
||||||
{ |
|
||||||
Assert.IsTrue(node is XmlElementExpression); |
|
||||||
XmlElementExpression expr = node as XmlElementExpression; |
|
||||||
Assert.IsEmpty(expr.Attributes); |
|
||||||
Assert.IsEmpty(expr.Children); |
|
||||||
Assert.IsFalse(expr.NameIsExpression); |
|
||||||
Assert.AreEqual(name, expr.XmlName); |
|
||||||
Assert.AreEqual(start, expr.StartLocation); |
|
||||||
Assert.AreEqual(end, expr.EndLocation); |
|
||||||
} |
|
||||||
|
|
||||||
void CheckContent(AstNode node, string content, XmlContentType type, AstLocation start, AstLocation end) |
|
||||||
{ |
|
||||||
Assert.IsTrue(node is XmlContentExpression); |
|
||||||
XmlContentExpression expr = node as XmlContentExpression; |
|
||||||
Assert.AreEqual(type, expr.Type); |
|
||||||
Assert.AreEqual(content, expr.Content); |
|
||||||
Assert.AreEqual(start, expr.StartLocation); |
|
||||||
Assert.AreEqual(end, expr.EndLocation); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,101 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class XmlMemberAccessExpressionTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleElementReferenceTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>("xml.<ns:MyElement>"); |
|
||||||
Assert.AreEqual("ns:MyElement", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Element, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject is IdentifierExpression); |
|
||||||
Assert.AreEqual("xml", ((IdentifierExpression)xmae.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleAttributeReferenceTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>("xml.@attribute"); |
|
||||||
Assert.AreEqual("attribute", xmae.Identifier); |
|
||||||
Assert.IsFalse(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Attribute, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject is IdentifierExpression); |
|
||||||
Assert.AreEqual("xml", ((IdentifierExpression)xmae.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetXmlNameAttributeReferenceTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>("xml.@<ns:attribute>"); |
|
||||||
Assert.AreEqual("ns:attribute", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Attribute, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject is IdentifierExpression); |
|
||||||
Assert.AreEqual("xml", ((IdentifierExpression)xmae.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleDescendentsReferenceTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>("xml...<ns:Element>"); |
|
||||||
Assert.AreEqual("ns:Element", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Descendents, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject is IdentifierExpression); |
|
||||||
Assert.AreEqual("xml", ((IdentifierExpression)xmae.TargetObject).Identifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleElementReferenceWithDotTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>(".<ns:MyElement>"); |
|
||||||
Assert.AreEqual("ns:MyElement", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Element, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleAttributeReferenceWithDotTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>(".@attribute"); |
|
||||||
Assert.AreEqual("attribute", xmae.Identifier); |
|
||||||
Assert.IsFalse(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Attribute, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetXmlNameAttributeReferenceWithDotTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>(".@<ns:attribute>"); |
|
||||||
Assert.AreEqual("ns:attribute", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Attribute, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleDescendentsReferenceWithDotTest() |
|
||||||
{ |
|
||||||
XmlMemberAccessExpression xmae = ParseUtil.ParseExpression<XmlMemberAccessExpression>("...<ns:Element>"); |
|
||||||
Assert.AreEqual("ns:Element", xmae.Identifier); |
|
||||||
Assert.IsTrue(xmae.IsXmlIdentifier); |
|
||||||
Assert.AreEqual(XmlAxisType.Descendents, xmae.AxisType); |
|
||||||
Assert.IsTrue(xmae.TargetObject.IsNull); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,74 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class AttributeSectionTests |
|
||||||
{ |
|
||||||
// [Test]
|
|
||||||
// public void AttributeOnStructure()
|
|
||||||
// {
|
|
||||||
// string program = @"
|
|
||||||
//<StructLayout( LayoutKind.Explicit )> _
|
|
||||||
//Public Structure MyUnion
|
|
||||||
//
|
|
||||||
// <FieldOffset( 0 )> Public i As Integer
|
|
||||||
// < FieldOffset( 0 )> Public d As Double
|
|
||||||
//
|
|
||||||
//End Structure 'MyUnion
|
|
||||||
//";
|
|
||||||
// TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
// Assert.AreEqual("StructLayout", decl.Attributes[0].Attributes[0].Type);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void AttributeOnModule()
|
|
||||||
// {
|
|
||||||
// string program = @"
|
|
||||||
//<HideModule> _
|
|
||||||
//Public Module MyExtra
|
|
||||||
//
|
|
||||||
// Public i As Integer
|
|
||||||
// Public d As Double
|
|
||||||
//
|
|
||||||
//End Module
|
|
||||||
//";
|
|
||||||
// TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
// Assert.AreEqual("HideModule", decl.Attributes[0].Attributes[0].Type);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void GlobalAttribute()
|
|
||||||
// {
|
|
||||||
// string program = @"<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
|
|
||||||
//Public Class Form1
|
|
||||||
//
|
|
||||||
//End Class";
|
|
||||||
// TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
// Assert.AreEqual("Microsoft.VisualBasic.CompilerServices.DesignerGenerated", decl.Attributes[0].Attributes[0].Type);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void AssemblyAttribute()
|
|
||||||
// {
|
|
||||||
// string program = @"<assembly: System.Attribute()>";
|
|
||||||
// AttributeSection decl = ParseUtil.ParseGlobal<AttributeSection>(program);
|
|
||||||
// Assert.AreEqual(new Location(1, 1), decl.StartLocation);
|
|
||||||
// Assert.AreEqual("assembly", decl.AttributeTarget);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void ModuleAttributeTargetEscaped()
|
|
||||||
// {
|
|
||||||
// // check that this doesn't crash the parser:
|
|
||||||
// ParseUtil.ParseGlobal<AttributeSection>("<[Module]: SuppressMessageAttribute>", true);
|
|
||||||
// }
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,43 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class NamespaceDeclarationTests |
|
||||||
{ |
|
||||||
// #region VB.NET
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetSimpleNamespaceTest()
|
|
||||||
// {
|
|
||||||
// string program = "Namespace TestNamespace" + Environment.NewLine +
|
|
||||||
// "End Namespace" +Environment.NewLine;
|
|
||||||
// NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
|
|
||||||
// Assert.AreEqual("TestNamespace", ns.Name);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetJuggedNamespaceTest()
|
|
||||||
// {
|
|
||||||
// string program = "Namespace N1 'TestNamespace\n" +
|
|
||||||
// " Namespace N2 ' Declares a namespace named N2 within N1.\n" +
|
|
||||||
// " End Namespace\n" +
|
|
||||||
// "End Namespace\n";
|
|
||||||
//
|
|
||||||
// NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("N1", ns.Name);
|
|
||||||
//
|
|
||||||
// Assert.IsTrue(ns.Children[0] is NamespaceDeclaration);
|
|
||||||
//
|
|
||||||
// ns = (NamespaceDeclaration)ns.Children[0];
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("N2", ns.Name);
|
|
||||||
// }
|
|
||||||
// #endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,113 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class OptionStatementTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void InvalidOptionSyntax() |
|
||||||
{ |
|
||||||
string program = "Option\n"; |
|
||||||
ParseUtil.ParseGlobal<OptionStatement>(program, true); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void StrictOption() |
|
||||||
{ |
|
||||||
string program = "Option Strict On\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Strict, |
|
||||||
OptionValue = OptionValue.On |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void ExplicitOption() |
|
||||||
{ |
|
||||||
string program = "Option Explicit Off\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Explicit, |
|
||||||
OptionValue = OptionValue.Off |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CompareBinaryOption() |
|
||||||
{ |
|
||||||
string program = "Option Compare Binary\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Compare, |
|
||||||
OptionValue = OptionValue.Binary |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void CompareTextOption() |
|
||||||
{ |
|
||||||
string program = "Option Compare Text\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Compare, |
|
||||||
OptionValue = OptionValue.Text |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InferOnOption() |
|
||||||
{ |
|
||||||
string program = "Option Infer On\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Infer, |
|
||||||
OptionValue = OptionValue.On |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InferOffOption() |
|
||||||
{ |
|
||||||
string program = "Option Infer Off\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Infer, |
|
||||||
OptionValue = OptionValue.Off |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InferOption() |
|
||||||
{ |
|
||||||
string program = "Option Infer\n"; |
|
||||||
|
|
||||||
var node = new OptionStatement { |
|
||||||
OptionType = OptionType.Infer, |
|
||||||
OptionValue = OptionValue.On |
|
||||||
}; |
|
||||||
|
|
||||||
ParseUtil.AssertGlobal(program, node); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,203 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TypeDeclarationTests |
|
||||||
{ |
|
||||||
// #region VB.NET
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetSimpleClassTypeDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string program = "Class TestClass\n" +
|
|
||||||
// "End Class\n";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestClass", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual(1, td.StartLocation.Line, "start line");
|
|
||||||
// Assert.AreEqual(1, td.BodyStartLocation.Line, "bodystart line");
|
|
||||||
// Assert.AreEqual(16, td.BodyStartLocation.Column, "bodystart col");
|
|
||||||
// Assert.AreEqual(2, td.EndLocation.Line, "end line");
|
|
||||||
// Assert.AreEqual(10, td.EndLocation.Column, "end col");
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetMissingBaseClassTest()
|
|
||||||
// {
|
|
||||||
// // SD2-1499: test that this invalid code doesn't crash
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>("public class test inherits", true);
|
|
||||||
// Assert.AreEqual(0, td.BaseTypes.Count);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetEnumWithBaseClassDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string program = "Enum TestEnum As Byte\n" +
|
|
||||||
// "End Enum\n";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestEnum", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Enum, td.Type);
|
|
||||||
// Assert.AreEqual("System.Byte", td.BaseTypes[0].Type);
|
|
||||||
// Assert.AreEqual(0, td.Children.Count);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetEnumOnSingleLine()
|
|
||||||
// {
|
|
||||||
// string program = "Enum TestEnum : A : B = 1 : C : End Enum";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestEnum", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Enum, td.Type);
|
|
||||||
// Assert.AreEqual(3, td.Children.Count);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetEnumOnSingleLine2()
|
|
||||||
// {
|
|
||||||
// string program = "Enum TestEnum : A : : B = 1 :: C : End Enum";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestEnum", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Enum, td.Type);
|
|
||||||
// Assert.AreEqual(3, td.Children.Count);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetEnumWithSystemBaseClassDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string program = "Enum TestEnum As System.UInt16\n" +
|
|
||||||
// "End Enum\n";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestEnum", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Enum, td.Type);
|
|
||||||
// Assert.AreEqual("System.UInt16", td.BaseTypes[0].Type);
|
|
||||||
// Assert.AreEqual(0, td.Children.Count);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
|
|
||||||
// {
|
|
||||||
// string program = "Class TestClass\n" +
|
|
||||||
// "End Class";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestClass", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual(1, td.StartLocation.Line, "start line");
|
|
||||||
// Assert.AreEqual(2, td.EndLocation.Line, "end line");
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetSimpleClassTypeDeclarationWithColon()
|
|
||||||
// {
|
|
||||||
// string program = "Class TestClass\n" +
|
|
||||||
// " : \n" +
|
|
||||||
// "End Class";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestClass", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetSimplePartialClassTypeDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string program = "Partial Class TestClass\n" +
|
|
||||||
// "End Class\n";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestClass", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual(Modifiers.Partial, td.Modifier);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetPartialPublicClass()
|
|
||||||
// {
|
|
||||||
// string program = "Partial Public Class TestClass\nEnd Class\n";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("TestClass", td.Name);
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual(Modifiers.Partial | Modifiers.Public, td.Modifier);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetGenericClassTypeDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string declr = @"
|
|
||||||
//Public Class Test(Of T)
|
|
||||||
//
|
|
||||||
//End Class
|
|
||||||
//";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual("Test", td.Name);
|
|
||||||
// Assert.AreEqual(Modifiers.Public, td.Modifier);
|
|
||||||
// Assert.AreEqual(0, td.BaseTypes.Count);
|
|
||||||
// Assert.AreEqual(1, td.Templates.Count);
|
|
||||||
// Assert.AreEqual("T", td.Templates[0].Name);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetGenericClassWithConstraint()
|
|
||||||
// {
|
|
||||||
// string declr = @"
|
|
||||||
//Public Class Test(Of T As IMyInterface)
|
|
||||||
//
|
|
||||||
//End Class
|
|
||||||
//";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual("Test", td.Name);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(1, td.Templates.Count);
|
|
||||||
// Assert.AreEqual("T", td.Templates[0].Name);
|
|
||||||
// Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// [Test]
|
|
||||||
// public void VBNetComplexGenericClassTypeDeclarationTest()
|
|
||||||
// {
|
|
||||||
// string declr = @"
|
|
||||||
//Public Class Generic(Of T As MyNamespace.IMyInterface, S As {G(Of T()), IAnotherInterface})
|
|
||||||
// Implements System.IComparable
|
|
||||||
//
|
|
||||||
//End Class
|
|
||||||
//";
|
|
||||||
// TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(ClassType.Class, td.Type);
|
|
||||||
// Assert.AreEqual("Generic", td.Name);
|
|
||||||
// Assert.AreEqual(Modifiers.Public, td.Modifier);
|
|
||||||
// Assert.AreEqual(1, td.BaseTypes.Count);
|
|
||||||
// Assert.AreEqual("System.IComparable", td.BaseTypes[0].Type);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(2, td.Templates.Count);
|
|
||||||
// Assert.AreEqual("T", td.Templates[0].Name);
|
|
||||||
// Assert.AreEqual("MyNamespace.IMyInterface", td.Templates[0].Bases[0].Type);
|
|
||||||
//
|
|
||||||
// Assert.AreEqual("S", td.Templates[1].Name);
|
|
||||||
// Assert.AreEqual(2, td.Templates[1].Bases.Count);
|
|
||||||
// Assert.AreEqual("G", td.Templates[1].Bases[0].Type);
|
|
||||||
// Assert.AreEqual(1, td.Templates[1].Bases[0].GenericTypes.Count);
|
|
||||||
// Assert.IsTrue(td.Templates[1].Bases[0].GenericTypes[0].IsArrayType);
|
|
||||||
// Assert.AreEqual("T", td.Templates[1].Bases[0].GenericTypes[0].Type);
|
|
||||||
// Assert.AreEqual(new int[] {0}, td.Templates[1].Bases[0].GenericTypes[0].RankSpecifier);
|
|
||||||
// Assert.AreEqual("IAnotherInterface", td.Templates[1].Bases[1].Type);
|
|
||||||
// }
|
|
||||||
// #endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,108 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using System.Linq; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.PatternMatching; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
public class ParseUtil |
|
||||||
{ |
|
||||||
public static T ParseGlobal<T>(string code, bool expectErrors = false) where T : AstNode |
|
||||||
{ |
|
||||||
VBParser parser = new VBParser(); |
|
||||||
CompilationUnit cu = parser.Parse(new StringReader(code)); |
|
||||||
|
|
||||||
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors"); |
|
||||||
|
|
||||||
AstNode node = cu.Children.Single(); |
|
||||||
Type type = typeof(T); |
|
||||||
Assert.IsTrue(type.IsAssignableFrom(node.GetType()), String.Format("Parsed node was {0} instead of {1} ({2})", node.GetType(), type, node)); |
|
||||||
return (T)node; |
|
||||||
} |
|
||||||
|
|
||||||
public static void AssertGlobal(string code, AstNode expectedNode) |
|
||||||
{ |
|
||||||
var node = ParseGlobal<AstNode>(code); |
|
||||||
if (!expectedNode.IsMatch(node)) { |
|
||||||
Assert.Fail("Expected '{0}' but was '{1}'", ToVB(expectedNode), ToVB(node)); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// public static T ParseStatement<T>(string stmt, bool expectErrors = false) where T : AstNode
|
|
||||||
// {
|
|
||||||
// VBParser parser = new VBParser();
|
|
||||||
// var statements = parser.ParseStatements(new StringReader(stmt));
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
|
|
||||||
//
|
|
||||||
// AstNode statement = statements.Single();
|
|
||||||
// Type type = typeof(T);
|
|
||||||
// Assert.IsTrue(type.IsAssignableFrom(statement.GetType()), String.Format("Parsed statement was {0} instead of {1} ({2})", statement.GetType(), type, statement));
|
|
||||||
// return (T)statement;
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// public static void AssertStatement(string code, VB.Ast.Statement expectedStmt)
|
|
||||||
// {
|
|
||||||
// var stmt = ParseStatement<VB.Ast.Statement>(code);
|
|
||||||
// if (!expectedStmt.IsMatch(stmt)) {
|
|
||||||
// Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedStmt), ToCSharp(stmt));
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// public static T ParseExpression<T>(string expr, bool expectErrors = false) where T : AstNode
|
|
||||||
// {
|
|
||||||
// VBParser parser = new VBParser();
|
|
||||||
// AstNode parsedExpression = parser.ParseExpression(new StringReader(expr));
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
|
|
||||||
// if (expectErrors && parsedExpression == null)
|
|
||||||
// return default (T);
|
|
||||||
// Type type = typeof(T);
|
|
||||||
// Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
|
|
||||||
// return (T)parsedExpression;
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// public static void AssertExpression(string code, VB.Ast.Expression expectedExpr)
|
|
||||||
// {
|
|
||||||
// var expr = ParseExpression<CSharp.Expression>(code);
|
|
||||||
// if (!expectedExpr.IsMatch(expr)) {
|
|
||||||
// Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedExpr), ToCSharp(expr));
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// public static T ParseTypeMember<T>(string expr, bool expectErrors = false) where T : AttributedNode
|
|
||||||
// {
|
|
||||||
// VBParser parser = new VBParser();
|
|
||||||
// var members = parser.ParseTypeMembers(new StringReader(expr));
|
|
||||||
//
|
|
||||||
// Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
|
|
||||||
//
|
|
||||||
// AttributedNode m = members.Single();
|
|
||||||
// Type type = typeof(T);
|
|
||||||
// Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
|
|
||||||
// return (T)m;
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// public static void AssertTypeMember(string code, VB.Ast.AttributedNode expectedMember)
|
|
||||||
// {
|
|
||||||
// var member = ParseTypeMember<VB.Ast.AttributedNode>(code);
|
|
||||||
// if (!expectedMember.IsMatch(member)) {
|
|
||||||
// Assert.Fail("Expected '{0}' but was '{1}'", ToVB(expectedMember), ToVB(member));
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
static string ToVB(AstNode node) |
|
||||||
{ |
|
||||||
StringWriter w = new StringWriter(); |
|
||||||
node.AcceptVisitor(new OutputVisitor(w, new VBFormattingOptions()), null); |
|
||||||
return w.ToString(); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using System; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class SnippetParserTests |
|
||||||
{ |
|
||||||
// [Test]
|
|
||||||
// public void InvalidExpressionSyntax()
|
|
||||||
// {
|
|
||||||
// // SD2-1584: ensure we don't crash on this invalid VB code
|
|
||||||
// SnippetParser parser = new SnippetParser();
|
|
||||||
// INode node = parser.Parse("i == 5");
|
|
||||||
// Assert.IsTrue(parser.Errors.Count > 0);
|
|
||||||
// }
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class AddHandlerStatementTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void AddHandlerTest() |
|
||||||
{ |
|
||||||
AddHandlerStatement addHandlerStatement = ParseUtil.ParseStatement<AddHandlerStatement>("AddHandler Obj.Ev_Event, AddressOf EventHandler"); |
|
||||||
// TODO : extend tests
|
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class BlockStatementTests |
|
||||||
{ |
|
||||||
// TODO create BlockStatementTests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ContinueStatementTests |
|
||||||
{ |
|
||||||
// TODO : add ContinueStatementTests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class DoLoopStatementTests |
|
||||||
{ |
|
||||||
// TODO write some DoLoopStatement tests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,29 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class EndStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetEndStatementTest() |
|
||||||
{ |
|
||||||
EndStatement endStatement = ParseUtil.ParseStatement<EndStatement>("End"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetEndStatementInIfThenTest2() |
|
||||||
{ |
|
||||||
IfElseStatement endStatement = ParseUtil.ParseStatement<IfElseStatement>("IF a THEN End"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class EraseStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetEraseStatementTest() |
|
||||||
{ |
|
||||||
EraseStatement eraseStatement = ParseUtil.ParseStatement<EraseStatement>("Erase a, b, c"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ErrorStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetErrorStatementTest() |
|
||||||
{ |
|
||||||
ErrorStatement errorStatement = ParseUtil.ParseStatement<ErrorStatement>("Error a"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ExpressionStatementTests |
|
||||||
{ |
|
||||||
// TODO : Create ExpressionStatementTests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,29 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ForNextStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetForNextStatementTest() |
|
||||||
{ |
|
||||||
ForNextStatement forNextStatement = ParseUtil.ParseStatement<ForNextStatement>("For i=0 To 10 Step 2 : Next i"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetForNextStatementWithComplexExpressionTest() |
|
||||||
{ |
|
||||||
ForNextStatement forNextStatement = ParseUtil.ParseStatement<ForNextStatement>("For SomeMethod().Property = 0 To 10 : Next SomeMethod().Property"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,25 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ForeachStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetForeachStatementTest() |
|
||||||
{ |
|
||||||
ForeachStatement foreachStmt = ParseUtil.ParseStatement<ForeachStatement>("For Each i As Integer In myColl : Next"); |
|
||||||
// TODO : Extend test.
|
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,24 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class GotoStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetGotoStatementTest() |
|
||||||
{ |
|
||||||
GotoStatement gotoStmt = ParseUtil.ParseStatement<GotoStatement>("GoTo myLabel"); |
|
||||||
Assert.AreEqual("myLabel", gotoStmt.Label); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,142 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class IfElseStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleIfStatementTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN END"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count); |
|
||||||
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 0, "false count != 0:" + ifElseStatement.FalseStatement.Count); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is EndStatement, "Statement was: " + ifElseStatement.TrueStatement[0]); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetSimpleIfStatementTest2() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN\n END\n END IF"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count); |
|
||||||
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 0, "false count != 0:" + ifElseStatement.FalseStatement.Count); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.TrueStatement[0]); |
|
||||||
} |
|
||||||
|
|
||||||
// test for SD2-1201
|
|
||||||
[Test] |
|
||||||
public void VBNetIfStatementLocationTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN\n" + |
|
||||||
"DoIt()\n" + |
|
||||||
"ElseIf False Then\n" + |
|
||||||
"DoIt()\n" + |
|
||||||
"End If"); |
|
||||||
Assert.AreEqual(3, (ifElseStatement.StartLocation).Line); |
|
||||||
Assert.AreEqual(7, (ifElseStatement.EndLocation).Line); |
|
||||||
Assert.AreEqual(5, (ifElseStatement.ElseIfSections[0].StartLocation).Line); |
|
||||||
Assert.AreEqual(6, (ifElseStatement.ElseIfSections[0].EndLocation).Line); |
|
||||||
Assert.IsNotNull(ifElseStatement.ElseIfSections[0].Parent); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetElseIfStatementTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN\n" + |
|
||||||
"END\n" + |
|
||||||
"ElseIf False Then\n" + |
|
||||||
"Stop\n" + |
|
||||||
"End If"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count); |
|
||||||
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 0, "false count != 0:" + ifElseStatement.FalseStatement.Count); |
|
||||||
Assert.IsFalse((bool)(ifElseStatement.ElseIfSections[0].Condition as PrimitiveExpression).Value); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.TrueStatement[0]); |
|
||||||
Assert.IsTrue(ifElseStatement.ElseIfSections[0].EmbeddedStatement.Children[0] is StopStatement, "Statement was: " + ifElseStatement.ElseIfSections[0].EmbeddedStatement.Children[0]); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetElse_IfStatementTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN\n" + |
|
||||||
"END\n" + |
|
||||||
"Else If False Then\n" + |
|
||||||
"Stop\n" + |
|
||||||
"End If"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count); |
|
||||||
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 0, "false count != 0:" + ifElseStatement.FalseStatement.Count); |
|
||||||
Assert.IsFalse((bool)(ifElseStatement.ElseIfSections[0].Condition as PrimitiveExpression).Value); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.TrueStatement[0]); |
|
||||||
Assert.IsTrue(ifElseStatement.ElseIfSections[0].EmbeddedStatement.Children[0] is StopStatement, "Statement was: " + ifElseStatement.ElseIfSections[0].EmbeddedStatement.Children[0]); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetMultiStatementIfStatementTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN Stop : b"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.AreEqual(2, ifElseStatement.TrueStatement.Count, "true count"); |
|
||||||
Assert.AreEqual(0, ifElseStatement.FalseStatement.Count, "false count"); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is StopStatement); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[1] is ExpressionStatement); |
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void VBNetMultiStatementIfStatementWithEndStatementTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN Stop : End : b"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.AreEqual(3, ifElseStatement.TrueStatement.Count, "true count"); |
|
||||||
Assert.AreEqual(0, ifElseStatement.FalseStatement.Count, "false count"); |
|
||||||
|
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[0] is StopStatement); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[1] is EndStatement); |
|
||||||
Assert.IsTrue(ifElseStatement.TrueStatement[2] is ExpressionStatement); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetIfWithEmptyElseTest() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN a Else"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.AreEqual(1, ifElseStatement.TrueStatement.Count, "true count"); |
|
||||||
Assert.AreEqual(0, ifElseStatement.FalseStatement.Count, "false count"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetIfWithMultipleColons() |
|
||||||
{ |
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN a : : b"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.AreEqual(2, ifElseStatement.TrueStatement.Count, "true count"); |
|
||||||
Assert.AreEqual(0, ifElseStatement.FalseStatement.Count, "false count"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetIfWithSingleLineElse() |
|
||||||
{ |
|
||||||
// This isn't legal according to the VB spec, but the MS VB compiler seems to allow it.
|
|
||||||
IfElseStatement ifElseStatement = ParseUtil.ParseStatement<IfElseStatement>("If True THEN\n" + |
|
||||||
" x()\n" + |
|
||||||
"Else y()\n" + |
|
||||||
"End If"); |
|
||||||
Assert.IsFalse(ifElseStatement.Condition.IsNull); |
|
||||||
Assert.AreEqual(1, ifElseStatement.TrueStatement.Count, "true count"); |
|
||||||
Assert.AreEqual(1, ifElseStatement.FalseStatement.Count, "false count"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,26 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LabelStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetLabelStatementTest() |
|
||||||
{ |
|
||||||
MethodDeclaration method = ParseUtil.ParseTypeMember<MethodDeclaration>("Sub Test \n myLabel: Console.WriteLine() \n End Sub"); |
|
||||||
Assert.AreEqual(2, method.Body.Children.Count); |
|
||||||
LabelStatement labelStmt = (LabelStatement)method.Body.Children[0]; |
|
||||||
Assert.AreEqual("myLabel", labelStmt.Label); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,204 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LocalVariableDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalVariableDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As Integer = 5"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("a", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(5, ((PrimitiveExpression)lvd.Variables[0].Initializer).Value); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalVariableNamedOverrideDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim override As Integer = 5"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("override", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(5, ((PrimitiveExpression)lvd.Variables[0].Initializer).Value); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalArrayDeclarationWithInitializationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a(10) As Integer"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("a", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(new int[] { 0 } , type.RankSpecifier); |
|
||||||
ArrayCreateExpression ace = (ArrayCreateExpression)lvd.Variables[0].Initializer; |
|
||||||
Assert.AreEqual(new int[] { 0 } , ace.CreateType.RankSpecifier); |
|
||||||
Assert.AreEqual(1, ace.Arguments.Count); |
|
||||||
Assert.AreEqual(10, ((PrimitiveExpression)ace.Arguments[0]).Value); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalArrayDeclarationWithInitializationAndLowerBoundTest() |
|
||||||
{ |
|
||||||
// VB.NET allows only "0" as lower bound
|
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a(0 To 10) As Integer"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("a", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(new int[] { 0 } , type.RankSpecifier); |
|
||||||
ArrayCreateExpression ace = (ArrayCreateExpression)lvd.Variables[0].Initializer; |
|
||||||
Assert.AreEqual(new int[] { 0 } , ace.CreateType.RankSpecifier); |
|
||||||
Assert.AreEqual(1, ace.Arguments.Count); |
|
||||||
Assert.AreEqual(10, ((PrimitiveExpression)ace.Arguments[0]).Value); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalArrayDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a() As Integer"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("a", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(new int[] { 0 } , type.RankSpecifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetLocalJaggedArrayDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a(10)() As Integer"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("a", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.Int32", type.Type); |
|
||||||
Assert.AreEqual(new int[] { 0, 0 } , type.RankSpecifier); |
|
||||||
ArrayCreateExpression ace = (ArrayCreateExpression)lvd.Variables[0].Initializer; |
|
||||||
Assert.AreEqual(new int[] {0, 0}, ace.CreateType.RankSpecifier); |
|
||||||
Assert.AreEqual(1, ace.Arguments.Count); |
|
||||||
Assert.AreEqual(10, ((PrimitiveExpression)ace.Arguments[0]).Value); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetComplexGenericLocalVariableDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim where As Generic(Of Printable, G(Of Printable()))"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
Assert.AreEqual("where", lvd.Variables[0].Name); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("Generic", type.Type); |
|
||||||
Assert.AreEqual(2, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("Printable", type.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count); |
|
||||||
Assert.AreEqual("G", type.GenericTypes[1].Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes[1].GenericTypes.Count); |
|
||||||
Assert.AreEqual("Printable", type.GenericTypes[1].GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericWithArrayLocalVariableDeclarationTest1() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As G(Of Integer)()"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("G", type.Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count); |
|
||||||
Assert.IsFalse(type.GenericTypes[0].IsArrayType); |
|
||||||
Assert.AreEqual(new int[] { 0 }, type.RankSpecifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericWithArrayLocalVariableDeclarationTest2() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As G(Of Integer())"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("G", type.Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count); |
|
||||||
Assert.IsFalse(type.IsArrayType); |
|
||||||
Assert.AreEqual(1, type.GenericTypes[0].RankSpecifier.Length); |
|
||||||
Assert.AreEqual(0, type.GenericTypes[0].RankSpecifier[0]); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericLocalVariableDeclarationTest2() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As G(Of G(Of Integer))"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("G", type.Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("G", type.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes[0].GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericLocalVariableDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As G(Of Integer)"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("G", type.Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericLocalVariableInitializationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a As New G(Of Integer)"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("G", type.Type); |
|
||||||
Assert.AreEqual(1, type.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type); |
|
||||||
// TODO: Check initializer
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetNestedGenericLocalVariableDeclarationTest() |
|
||||||
{ |
|
||||||
LocalVariableDeclaration lvd = ParseUtil.ParseStatement<LocalVariableDeclaration>("Dim a as MyType(of string).InnerClass(of integer).InnerInnerClass"); |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
InnerClassTypeReference ic = (InnerClassTypeReference)lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("InnerInnerClass", ic.Type); |
|
||||||
Assert.AreEqual(0, ic.GenericTypes.Count); |
|
||||||
ic = (InnerClassTypeReference)ic.BaseType; |
|
||||||
Assert.AreEqual("InnerClass", ic.Type); |
|
||||||
Assert.AreEqual(1, ic.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type); |
|
||||||
Assert.AreEqual("MyType", ic.BaseType.Type); |
|
||||||
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count); |
|
||||||
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetDimInSingleLineIf() |
|
||||||
{ |
|
||||||
IfElseStatement ifes = ParseUtil.ParseStatement<IfElseStatement>("If a Then Dim b As String"); |
|
||||||
LocalVariableDeclaration lvd = (LocalVariableDeclaration)ifes.TrueStatement[0]; |
|
||||||
Assert.AreEqual(1, lvd.Variables.Count); |
|
||||||
TypeReference type = lvd.GetTypeForVariable(0); |
|
||||||
Assert.AreEqual("System.String", type.Type); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class LockStatementTests |
|
||||||
{ |
|
||||||
// TODO : write some tests on SyncLock
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class OnErrorStatementTest |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetOnErrorStatementTest() |
|
||||||
{ |
|
||||||
OnErrorStatement onErrorStatement = ParseUtil.ParseStatement<OnErrorStatement>("On Error Goto err"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class RaiseEventStatementTest |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetRaiseEventStatementTest() |
|
||||||
{ |
|
||||||
RaiseEventStatement raiseEventStatement = ParseUtil.ParseStatement<RaiseEventStatement>("RaiseEvent MyEvent(a, 5, (6))"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,77 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ReDimStatementTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void VBNetReDimStatementTest() |
|
||||||
{ |
|
||||||
ReDimStatement reDimStatement = ParseUtil.ParseStatement<ReDimStatement>("ReDim Preserve MyArray(15)"); |
|
||||||
Assert.AreEqual(1, reDimStatement.ReDimClauses.Count); |
|
||||||
Assert.AreSame(reDimStatement, reDimStatement.ReDimClauses[0].Parent); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetReDimStatementTest2() |
|
||||||
{ |
|
||||||
ReDimStatement reDimStatement = ParseUtil.ParseStatement<ReDimStatement>("ReDim calCheckData(channelNum, lambdaNum).ShiftFromLastFullCalPixels(CalCheckPeak.HighWavelength)"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetBigReDimStatementTest() |
|
||||||
{ |
|
||||||
string program = @"
|
|
||||||
Class X |
|
||||||
Sub x |
|
||||||
ReDim sU(m - 1, n - 1) |
|
||||||
ReDim sW(n - 1) |
|
||||||
ReDim sV(n - 1, n - 1) |
|
||||||
ReDim rv1(n - 1) |
|
||||||
ReDim sMt(iNrCols - 1, 0) |
|
||||||
ReDim Preserve sMt(iNrCols - 1, iRowNr) |
|
||||||
ReDim sM(iRowNr - 1, iNrCols - 1) |
|
||||||
If (IsNothing(ColLengths)) Then ReDim ColLengths(0) |
|
||||||
If (ColLengths.Length = (SubItem + 1)) Then ReDim Preserve ColLengths(SubItem + 1) |
|
||||||
ReDim sTransform(2, iTransformType - 1) |
|
||||||
ReDim Preserve _Items(_Count) |
|
||||||
ReDim Preserve _Items(nCapacity) |
|
||||||
ReDim Preserve _Items(0 To _Count) |
|
||||||
ReDim Preserve _Items(0 To nCapacity) |
|
||||||
ReDim sU(m - 1, n - 1) |
|
||||||
ReDim sW(n - 1) |
|
||||||
ReDim sV(n - 1, n - 1) |
|
||||||
ReDim rv1(n - 1) |
|
||||||
ReDim sMt(iNrCols - 1, 0) |
|
||||||
ReDim Preserve sMt(iNrCols - 1, iRowNr) |
|
||||||
ReDim sM(iRowNr - 1, iNrCols - 1) |
|
||||||
If (IsNothing(ColLengths)) Then ReDim ColLengths(0) |
|
||||||
If (ColLengths.Length = (SubItem + 1)) Then ReDim Preserve ColLengths(SubItem + 1) |
|
||||||
ReDim sTransform(2, iTransformType - 1) |
|
||||||
ReDim Preserve Samples(Samples.GetUpperBound(0) + 1) |
|
||||||
ReDim Samples(0) |
|
||||||
ReDim BaseCssContent(BaseCssContentRows - 1) |
|
||||||
ReDim mabtRxBuf(Bytes2Read - 1) |
|
||||||
ReDim Preserve primarykey(primarykey.Length) |
|
||||||
ReDim Preserve IntArray(10, 10, 15) |
|
||||||
ReDim X(10, 10) |
|
||||||
ReDim Preserve IntArray(0 To 10, 10, 0 To 20) |
|
||||||
ReDim Preserve IntArray(10, 10, 15) |
|
||||||
ReDim X(0 To 10, 0 To 10) |
|
||||||
ReDim GetMe().IntArray(0 To 10, 10, 0 To 20) |
|
||||||
ReDim GetMe(ExplicitParameter := 3).IntArray(0 To 10, 10, 0 To 20) |
|
||||||
ReDim SomeType(Of Integer).IntArray(0 To 10, 10, 0 To 20) |
|
||||||
End Sub |
|
||||||
End Class";
|
|
||||||
TypeDeclaration typeDeclaration = ParseUtil.ParseGlobal<TypeDeclaration>(program); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class RemoveHandlerStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetRemoveHandlerTest() |
|
||||||
{ |
|
||||||
RemoveHandlerStatement removeHandlerStatement = ParseUtil.ParseStatement<RemoveHandlerStatement>("RemoveHandler MyHandler, AddressOf MyMethod"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ResumeStatementTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void ResumeStatementTest() |
|
||||||
{ |
|
||||||
ResumeStatement resumeStatement = ParseUtil.ParseStatement<ResumeStatement>("Resume"); |
|
||||||
} |
|
||||||
|
|
||||||
// TODO : write some more
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,32 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ReturnStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetEmptyReturnStatementTest() |
|
||||||
{ |
|
||||||
ReturnStatement returnStatement = ParseUtil.ParseStatement<ReturnStatement>("Return"); |
|
||||||
Assert.IsTrue(returnStatement.Expression.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetReturnStatementTest() |
|
||||||
{ |
|
||||||
ReturnStatement returnStatement = ParseUtil.ParseStatement<ReturnStatement>("Return 5"); |
|
||||||
Assert.IsFalse(returnStatement.Expression.IsNull); |
|
||||||
Assert.IsTrue(returnStatement.Expression is PrimitiveExpression); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class StopStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetStopStatementTest() |
|
||||||
{ |
|
||||||
StopStatement stopStatement = ParseUtil.ParseStatement<StopStatement>("Stop"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,34 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class SwitchStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBSwitchStatementTest() |
|
||||||
{ |
|
||||||
SwitchStatement switchStmt = ParseUtil.ParseStatement<SwitchStatement>("Select Case a\n Case 4, 5\n Case 6\n Case Else\n End Select"); |
|
||||||
Assert.AreEqual("a", ((SimpleNameExpression)switchStmt.SwitchExpression).Identifier); |
|
||||||
// TODO: Extend test
|
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void InvalidVBSwitchStatementTest() |
|
||||||
{ |
|
||||||
SwitchStatement switchStmt = ParseUtil.ParseStatement<SwitchStatement>("Select Case a\n Case \n End Select", true); |
|
||||||
Assert.AreEqual("a", ((SimpleNameExpression)switchStmt.SwitchExpression).Identifier); |
|
||||||
SwitchSection sec = switchStmt.SwitchSections[0]; |
|
||||||
Assert.AreEqual(0, sec.SwitchLabels.Count); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ThrowStatementTests |
|
||||||
{ |
|
||||||
// TODO : ThrowStatementTests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class TryCatchStatementTests |
|
||||||
{ |
|
||||||
// TODO : TryCatchStatementTests
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,47 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class UsingStatementTests |
|
||||||
{ |
|
||||||
[Test] |
|
||||||
public void UsingStatement() |
|
||||||
{ |
|
||||||
string usingText = @"
|
|
||||||
Using nf As New System.Drawing.Font(""Arial"", 12.0F, FontStyle.Bold) |
|
||||||
c.Font = nf |
|
||||||
c.Text = ""This is 12-point Arial bold"" |
|
||||||
End Using";
|
|
||||||
UsingStatement usingStmt = ParseUtil.ParseStatement<UsingStatement>(usingText); |
|
||||||
// TODO : Extend test.
|
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void UsingStatement2() |
|
||||||
{ |
|
||||||
string usingText = @"
|
|
||||||
Using nf As Font = New Font() |
|
||||||
Bla(nf) |
|
||||||
End Using";
|
|
||||||
UsingStatement usingStmt = ParseUtil.ParseStatement<UsingStatement>(usingText); |
|
||||||
// TODO : Extend test.
|
|
||||||
} |
|
||||||
[Test] |
|
||||||
public void UsingStatement3() |
|
||||||
{ |
|
||||||
string usingText = @"
|
|
||||||
Using nf As New Font(), nf2 As New List(Of Font)(), nf3 = Nothing |
|
||||||
Bla(nf) |
|
||||||
End Using";
|
|
||||||
UsingStatement usingStmt = ParseUtil.ParseStatement<UsingStatement>(usingText); |
|
||||||
// TODO : Extend test.
|
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class WithStatementTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetWithStatementTest() |
|
||||||
{ |
|
||||||
WithStatement withStatement = ParseUtil.ParseStatement<WithStatement>("With MyObj : End With"); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,34 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class ConstructorDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetConstructorDeclarationTest1() |
|
||||||
{ |
|
||||||
string program = @"Sub New()
|
|
||||||
End Sub";
|
|
||||||
ConstructorDeclaration cd = ParseUtil.ParseTypeMember<ConstructorDeclaration>(program); |
|
||||||
Assert.IsTrue(cd.ConstructorInitializer.IsNull); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetConstructorDeclarationTest2() |
|
||||||
{ |
|
||||||
ConstructorDeclaration cd = ParseUtil.ParseTypeMember<ConstructorDeclaration>("Sub New(x As Integer, Optional y As String) \nEnd Sub"); |
|
||||||
Assert.AreEqual(2, cd.Parameters.Count); |
|
||||||
Assert.AreEqual("System.Int32", cd.Parameters[0].TypeReference.Type); |
|
||||||
Assert.AreEqual("System.String", cd.Parameters[1].TypeReference.Type); |
|
||||||
Assert.AreEqual(ParameterModifiers.Optional, cd.Parameters[1].ParamModifier & ParameterModifiers.Optional); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,44 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using NUnit.Framework; |
|
||||||
using ICSharpCode.NRefactory.VB.Parser; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class CustomEventTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetCustomEventsStatementTest() |
|
||||||
{ |
|
||||||
string code = @" Public Custom Event TestEvent As EventHandler
|
|
||||||
AddHandler(ByVal value As EventHandler) |
|
||||||
Handlers = CType([Delegate].Combine(Handlers, value), _ |
|
||||||
EventHandler) |
|
||||||
End AddHandler |
|
||||||
|
|
||||||
RemoveHandler(ByVal value as EventHandler) |
|
||||||
Handlers = CType([Delegate].Remove(Handlers, value), _ |
|
||||||
EventHandler) |
|
||||||
End RemoveHandler |
|
||||||
|
|
||||||
RaiseEvent(ByVal sender As Object, ByVal e As EventArgs) |
|
||||||
Dim TempHandlers As EventHandler = Handlers |
|
||||||
|
|
||||||
If TempHandlers IsNot Nothing Then |
|
||||||
TempHandlers(sender, e) |
|
||||||
End If |
|
||||||
End RaiseEvent |
|
||||||
End Event";
|
|
||||||
EventDeclaration customEventDecl = ParseUtil.ParseTypeMember<EventDeclaration>(code); |
|
||||||
Assert.IsNotNull(customEventDecl); |
|
||||||
Assert.AreEqual("TestEvent", customEventDecl.Name); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,28 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class DeclareDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetDeclareDeclarationTest() |
|
||||||
{ |
|
||||||
string program = "Declare Ansi Function GetUserName Lib \"advapi32.dll\" Alias \"GetUserNameA\" (ByVal lpBuffer As String, ByRef nSize As Integer) As Integer\n"; |
|
||||||
DeclareDeclaration dd = ParseUtil.ParseTypeMember<DeclareDeclaration>(program); |
|
||||||
Assert.AreEqual("System.Int32", dd.TypeReference.Type); |
|
||||||
Assert.AreEqual("GetUserName", dd.Name); |
|
||||||
Assert.AreEqual("advapi32.dll", dd.Library); |
|
||||||
Assert.AreEqual("GetUserNameA", dd.Alias); |
|
||||||
Assert.AreEqual(CharsetModifier.Ansi, dd.Charset); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,25 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class EventDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleEventDeclarationTest() |
|
||||||
{ |
|
||||||
EventDeclaration ed = ParseUtil.ParseTypeMember<EventDeclaration>("event MyEvent(x as Integer)"); |
|
||||||
Assert.AreEqual(1, ed.Parameters.Count); |
|
||||||
Assert.AreEqual("MyEvent", ed.Name); |
|
||||||
Assert.IsFalse(ed.HasAddRegion); |
|
||||||
Assert.IsFalse(ed.HasRemoveRegion); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,74 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class FieldDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleFieldDeclarationTest() |
|
||||||
{ |
|
||||||
FieldDeclaration fd = ParseUtil.ParseTypeMember<FieldDeclaration>("myField As Integer(,,,)"); |
|
||||||
Assert.AreEqual(1, fd.Fields.Count); |
|
||||||
|
|
||||||
Assert.AreEqual("System.Int32", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("System.Int32", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("myField", ((VariableDeclaration)fd.Fields[0]).Name); |
|
||||||
Assert.AreEqual(new int[] { 3 } , ((VariableDeclaration)fd.Fields[0]).TypeReference.RankSpecifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMultiFieldDeclarationTest() |
|
||||||
{ |
|
||||||
FieldDeclaration fd = ParseUtil.ParseTypeMember<FieldDeclaration>("a, b As String"); |
|
||||||
Assert.AreEqual(2, fd.Fields.Count); |
|
||||||
|
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type); |
|
||||||
Assert.IsFalse(((VariableDeclaration)fd.Fields[0]).TypeReference.IsArrayType); |
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[1]).TypeReference.Type); |
|
||||||
Assert.IsFalse(((VariableDeclaration)fd.Fields[1]).TypeReference.IsArrayType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMultiFieldsOnSingleLineTest() |
|
||||||
{ |
|
||||||
string program = "Class TestClass : Dim a : Dim b : End Class"; |
|
||||||
TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program); |
|
||||||
|
|
||||||
Assert.AreEqual(2, td.Children.Count); |
|
||||||
Assert.IsTrue(td.Children[0] is FieldDeclaration); |
|
||||||
Assert.IsTrue(td.Children[1] is FieldDeclaration); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMultiFieldDeclarationTest2() |
|
||||||
{ |
|
||||||
FieldDeclaration fd = ParseUtil.ParseTypeMember<FieldDeclaration>("Dim a, b() As String"); |
|
||||||
Assert.AreEqual(2, fd.Fields.Count); |
|
||||||
|
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[1]).TypeReference.Type); |
|
||||||
Assert.IsFalse(((VariableDeclaration)fd.Fields[0]).TypeReference.IsArrayType); |
|
||||||
Assert.IsTrue(((VariableDeclaration)fd.Fields[1]).TypeReference.IsArrayType); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMultiFieldDeclarationTest3() |
|
||||||
{ |
|
||||||
FieldDeclaration fd = ParseUtil.ParseTypeMember<FieldDeclaration>("Dim a(), b As String"); |
|
||||||
Assert.AreEqual(2, fd.Fields.Count); |
|
||||||
|
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[1]).TypeReference.Type); |
|
||||||
Assert.IsTrue(((VariableDeclaration)fd.Fields[0]).TypeReference.IsArrayType); |
|
||||||
Assert.IsFalse(((VariableDeclaration)fd.Fields[1]).TypeReference.IsArrayType); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,199 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class MethodDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetDefiningPartialMethodDeclarationTest() |
|
||||||
{ |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(@"Partial Sub MyMethod()
|
|
||||||
End Sub");
|
|
||||||
Assert.AreEqual(0, md.Parameters.Count); |
|
||||||
Assert.AreEqual("MyMethod", md.Name); |
|
||||||
Assert.IsFalse(md.IsExtensionMethod); |
|
||||||
Assert.AreEqual(Modifiers.Partial, md.Modifier); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMethodWithModifiersRegionTest() |
|
||||||
{ |
|
||||||
const string program = @"public shared sub MyMethod()
|
|
||||||
OtherMethod() |
|
||||||
end sub";
|
|
||||||
|
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program); |
|
||||||
Assert.AreEqual(Modifiers.Public | Modifiers.Static, md.Modifier); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); |
|
||||||
Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y"); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetFunctionMethodDeclarationTest() |
|
||||||
{ |
|
||||||
const string program = @"public function MyFunction() as Integer
|
|
||||||
return 1 |
|
||||||
end function";
|
|
||||||
|
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program); |
|
||||||
Assert.AreEqual(Modifiers.Public, md.Modifier); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X"); |
|
||||||
Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSubroutineMethodDeclarationTest() |
|
||||||
{ |
|
||||||
const string program = @"public Sub MyMethod()
|
|
||||||
OtherMethod() |
|
||||||
end Sub";
|
|
||||||
|
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program); |
|
||||||
Assert.AreEqual(Modifiers.Public, md.Modifier); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); |
|
||||||
Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X"); |
|
||||||
Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y"); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericFunctionMethodDeclarationTest() |
|
||||||
{ |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>("function MyMethod(Of T)(a As T) As Double\nEnd Function"); |
|
||||||
Assert.AreEqual("System.Double", md.TypeReference.Type); |
|
||||||
Assert.AreEqual(1, md.Parameters.Count); |
|
||||||
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); |
|
||||||
|
|
||||||
Assert.AreEqual(1, md.Templates.Count); |
|
||||||
Assert.AreEqual("T", md.Templates[0].Name); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericMethodDeclarationTest() |
|
||||||
{ |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>("Function MyMethod(Of T)(a As T) As T\nEnd Function "); |
|
||||||
Assert.AreEqual("T", md.TypeReference.Type); |
|
||||||
Assert.AreEqual(1, md.Parameters.Count); |
|
||||||
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); |
|
||||||
|
|
||||||
Assert.AreEqual(1, md.Templates.Count); |
|
||||||
Assert.AreEqual("T", md.Templates[0].Name); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericMethodDeclarationWithConstraintTest() |
|
||||||
{ |
|
||||||
string program = "Function MyMethod(Of T As { ISomeInterface })(a As T) As T\n End Function"; |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program); |
|
||||||
Assert.AreEqual("T", md.TypeReference.Type); |
|
||||||
Assert.AreEqual(1, md.Parameters.Count); |
|
||||||
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); |
|
||||||
|
|
||||||
Assert.AreEqual(1, md.Templates.Count); |
|
||||||
Assert.AreEqual("T", md.Templates[0].Name); |
|
||||||
Assert.AreEqual(1, md.Templates[0].Bases.Count); |
|
||||||
Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetExtensionMethodDeclaration() |
|
||||||
{ |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>( |
|
||||||
@"<Extension> _
|
|
||||||
Sub Print(s As String) |
|
||||||
Console.WriteLine(s) |
|
||||||
End Sub");
|
|
||||||
|
|
||||||
Assert.AreEqual("Print", md.Name); |
|
||||||
|
|
||||||
// IsExtensionMethod is only valid for c#.
|
|
||||||
// Assert.IsTrue(md.IsExtensionMethod);
|
|
||||||
|
|
||||||
Assert.AreEqual("s", md.Parameters[0].ParameterName); |
|
||||||
Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericMethodInInterface() |
|
||||||
{ |
|
||||||
const string program = @"Interface MyInterface
|
|
||||||
Function MyMethod(Of T As {ISomeInterface})(a As T) As T |
|
||||||
End Interface";
|
|
||||||
TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program); |
|
||||||
MethodDeclaration md = (MethodDeclaration)td.Children[0]; |
|
||||||
Assert.AreEqual("T", md.TypeReference.Type); |
|
||||||
Assert.AreEqual(1, md.Parameters.Count); |
|
||||||
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); |
|
||||||
|
|
||||||
Assert.AreEqual(1, md.Templates.Count); |
|
||||||
Assert.AreEqual("T", md.Templates[0].Name); |
|
||||||
Assert.AreEqual(1, md.Templates[0].Bases.Count); |
|
||||||
Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetGenericVoidMethodInInterface() |
|
||||||
{ |
|
||||||
const string program = @"interface MyInterface
|
|
||||||
Sub MyMethod(Of T As {ISomeInterface})(a as T) |
|
||||||
End Interface |
|
||||||
";
|
|
||||||
TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program); |
|
||||||
MethodDeclaration md = (MethodDeclaration)td.Children[0]; |
|
||||||
Assert.AreEqual("System.Void", md.TypeReference.Type); |
|
||||||
Assert.AreEqual(1, md.Parameters.Count); |
|
||||||
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); |
|
||||||
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); |
|
||||||
|
|
||||||
Assert.AreEqual(1, md.Templates.Count); |
|
||||||
Assert.AreEqual("T", md.Templates[0].Name); |
|
||||||
Assert.AreEqual(1, md.Templates[0].Bases.Count); |
|
||||||
Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMethodWithHandlesClause() |
|
||||||
{ |
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>( |
|
||||||
@"Public Sub MyMethod(sender As Object, e As EventArgs) Handles x.y
|
|
||||||
End Sub");
|
|
||||||
Assert.AreEqual(new string[] { "x.y" }, md.HandlesClause.ToArray()); |
|
||||||
|
|
||||||
md = ParseUtil.ParseTypeMember<MethodDeclaration>( |
|
||||||
@"Public Sub MyMethod() Handles Me.FormClosing
|
|
||||||
End Sub");
|
|
||||||
Assert.AreEqual(new string[] { "Me.FormClosing" }, md.HandlesClause.ToArray()); |
|
||||||
|
|
||||||
md = ParseUtil.ParseTypeMember<MethodDeclaration>( |
|
||||||
@"Public Sub MyMethod() Handles MyBase.Event, Button1.Click
|
|
||||||
End Sub");
|
|
||||||
Assert.AreEqual(new string[] { "MyBase.Event", "Button1.Click" }, md.HandlesClause.ToArray()); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetMethodWithTypeCharactersTest() |
|
||||||
{ |
|
||||||
const string program = @"Public Function Func!(ByVal Param&)
|
|
||||||
Func! = CSingle(Param&) |
|
||||||
End Function";
|
|
||||||
|
|
||||||
MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program); |
|
||||||
Assert.AreEqual(Modifiers.Public, md.Modifier); |
|
||||||
} |
|
||||||
|
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,30 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class OperatorDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetImplictOperatorDeclarationTest() |
|
||||||
{ |
|
||||||
string programm = @"Public Shared Operator + (ByVal v As Complex) As Complex
|
|
||||||
Return v |
|
||||||
End Operator";
|
|
||||||
|
|
||||||
OperatorDeclaration od = ParseUtil.ParseTypeMember<OperatorDeclaration>(programm); |
|
||||||
Assert.IsFalse(od.IsConversionOperator); |
|
||||||
Assert.AreEqual(1, od.Parameters.Count); |
|
||||||
Assert.AreEqual(ConversionType.None, od.ConversionType); |
|
||||||
Assert.AreEqual("Complex", od.TypeReference.Type); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,107 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.IO; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
using NUnit.Framework; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Tests.Ast |
|
||||||
{ |
|
||||||
[TestFixture] |
|
||||||
public class PropertyDeclarationTests |
|
||||||
{ |
|
||||||
#region VB.NET
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleGetSetPropertyDeclarationTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("Property MyProperty As Integer \n Get \n End Get \n Set \n End Set\nEnd Property"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleGetPropertyDeclarationTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("ReadOnly Property MyProperty \nGet\nEnd Get\nEnd Property"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsFalse(pd.HasSetRegion); |
|
||||||
Assert.IsTrue((pd.Modifier & Modifiers.ReadOnly) == Modifiers.ReadOnly); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleSetPropertyDeclarationTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("WriteOnly Property MyProperty \n Set\nEnd Set\nEnd Property "); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsFalse(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.IsTrue((pd.Modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetAutoPropertyTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("Property MyProperty"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer, Expression.Null); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetReadOnlyAutoPropertyTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("ReadOnly Property MyProperty"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsFalse(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer, Expression.Null); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetWriteOnlyAutoPropertyTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("WriteOnly Property MyProperty"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsFalse(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer, Expression.Null); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleInitializerAutoPropertyTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("Property MyProperty = 5"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer.ToString(), new PrimitiveExpression(5).ToString()); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleInitializerAutoPropertyWithTypeTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("Property MyProperty As Integer = 5"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.AreEqual("System.Int32", pd.TypeReference.Type); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer.ToString(), new PrimitiveExpression(5).ToString()); |
|
||||||
} |
|
||||||
|
|
||||||
[Test] |
|
||||||
public void VBNetSimpleObjectInitializerAutoPropertyTest() |
|
||||||
{ |
|
||||||
PropertyDeclaration pd = ParseUtil.ParseTypeMember<PropertyDeclaration>("Property MyProperty As New List"); |
|
||||||
Assert.AreEqual("MyProperty", pd.Name); |
|
||||||
Assert.AreEqual("List", pd.TypeReference.Type); |
|
||||||
Assert.IsTrue(pd.HasGetRegion); |
|
||||||
Assert.IsTrue(pd.HasSetRegion); |
|
||||||
Assert.AreEqual(pd.Initializer.ToString(), new ObjectCreateExpression(new TypeReference("List"), null).ToString()); |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,559 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections; |
|
||||||
using System.Collections.Generic; |
|
||||||
using System.Diagnostics; |
|
||||||
using System.Linq; |
|
||||||
using System.Threading; |
|
||||||
using ICSharpCode.NRefactory.PatternMatching; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB |
|
||||||
{ |
|
||||||
public abstract class AstNode : AbstractAnnotatable, PatternMatching.INode |
|
||||||
{ |
|
||||||
#region Null
|
|
||||||
public static readonly AstNode Null = new NullAstNode (); |
|
||||||
|
|
||||||
sealed class NullAstNode : AstNode |
|
||||||
{ |
|
||||||
public override bool IsNull { |
|
||||||
get { |
|
||||||
return true; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return default (S); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
return other == null || other.IsNull; |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
#region PatternPlaceholder
|
|
||||||
public static implicit operator AstNode(PatternMatching.Pattern pattern) |
|
||||||
{ |
|
||||||
return pattern != null ? new PatternPlaceholder(pattern) : null; |
|
||||||
} |
|
||||||
|
|
||||||
sealed class PatternPlaceholder : AstNode, PatternMatching.INode |
|
||||||
{ |
|
||||||
readonly PatternMatching.Pattern child; |
|
||||||
|
|
||||||
public PatternPlaceholder(PatternMatching.Pattern child) |
|
||||||
{ |
|
||||||
this.child = child; |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitPatternPlaceholder(this, child, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
return child.DoMatch(other, match); |
|
||||||
} |
|
||||||
|
|
||||||
bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo) |
|
||||||
{ |
|
||||||
return child.DoMatchCollection(role, pos, match, backtrackingInfo); |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
AstNode parent; |
|
||||||
AstNode prevSibling; |
|
||||||
AstNode nextSibling; |
|
||||||
AstNode firstChild; |
|
||||||
AstNode lastChild; |
|
||||||
Role role = RootRole; |
|
||||||
|
|
||||||
public virtual bool IsNull { |
|
||||||
get { |
|
||||||
return false; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public virtual TextLocation StartLocation { |
|
||||||
get { |
|
||||||
var child = firstChild; |
|
||||||
if (child == null) |
|
||||||
return TextLocation.Empty; |
|
||||||
return child.StartLocation; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public virtual TextLocation EndLocation { |
|
||||||
get { |
|
||||||
var child = lastChild; |
|
||||||
if (child == null) |
|
||||||
return TextLocation.Empty; |
|
||||||
return child.EndLocation; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode Parent { |
|
||||||
get { return parent; } |
|
||||||
} |
|
||||||
|
|
||||||
public Role Role { |
|
||||||
get { return role; } |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode NextSibling { |
|
||||||
get { return nextSibling; } |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode PrevSibling { |
|
||||||
get { return prevSibling; } |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode FirstChild { |
|
||||||
get { return firstChild; } |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode LastChild { |
|
||||||
get { return lastChild; } |
|
||||||
} |
|
||||||
|
|
||||||
public IEnumerable<AstNode> Children { |
|
||||||
get { |
|
||||||
AstNode next; |
|
||||||
for (AstNode cur = firstChild; cur != null; cur = next) { |
|
||||||
Debug.Assert(cur.parent == this); |
|
||||||
// Remember next before yielding cur.
|
|
||||||
// This allows removing/replacing nodes while iterating through the list.
|
|
||||||
next = cur.nextSibling; |
|
||||||
yield return cur; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Gets the ancestors of this node (excluding this node itself)
|
|
||||||
/// </summary>
|
|
||||||
public IEnumerable<AstNode> Ancestors { |
|
||||||
get { |
|
||||||
for (AstNode cur = parent; cur != null; cur = cur.parent) { |
|
||||||
yield return cur; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Gets all descendants of this node (excluding this node itself).
|
|
||||||
/// </summary>
|
|
||||||
public IEnumerable<AstNode> Descendants { |
|
||||||
get { |
|
||||||
return Utils.TreeTraversal.PreOrder(this.Children, n => n.Children); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Gets all descendants of this node (including this node itself).
|
|
||||||
/// </summary>
|
|
||||||
public IEnumerable<AstNode> DescendantsAndSelf { |
|
||||||
get { |
|
||||||
return Utils.TreeTraversal.PreOrder(this, n => n.Children); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Gets the first child with the specified role.
|
|
||||||
/// Returns the role's null object if the child is not found.
|
|
||||||
/// </summary>
|
|
||||||
public T GetChildByRole<T>(Role<T> role) where T : AstNode |
|
||||||
{ |
|
||||||
if (role == null) |
|
||||||
throw new ArgumentNullException("role"); |
|
||||||
for (var cur = firstChild; cur != null; cur = cur.nextSibling) { |
|
||||||
if (cur.role == role) |
|
||||||
return (T)cur; |
|
||||||
} |
|
||||||
return role.NullObject; |
|
||||||
} |
|
||||||
|
|
||||||
public AstNodeCollection<T> GetChildrenByRole<T>(Role<T> role) where T : AstNode |
|
||||||
{ |
|
||||||
return new AstNodeCollection<T>(this, role); |
|
||||||
} |
|
||||||
|
|
||||||
protected void SetChildByRole<T>(Role<T> role, T newChild) where T : AstNode |
|
||||||
{ |
|
||||||
AstNode oldChild = GetChildByRole(role); |
|
||||||
if (oldChild.IsNull) |
|
||||||
AddChild(newChild, role); |
|
||||||
else |
|
||||||
oldChild.ReplaceWith(newChild); |
|
||||||
} |
|
||||||
|
|
||||||
public void AddChild<T>(T child, Role<T> role) where T : AstNode |
|
||||||
{ |
|
||||||
if (role == null) |
|
||||||
throw new ArgumentNullException("role"); |
|
||||||
if (child == null || child.IsNull) |
|
||||||
return; |
|
||||||
if (this.IsNull) |
|
||||||
throw new InvalidOperationException("Cannot add children to null nodes"); |
|
||||||
if (child.parent != null) |
|
||||||
throw new ArgumentException ("Node is already used in another tree.", "child"); |
|
||||||
AddChildUnsafe(child, role); |
|
||||||
} |
|
||||||
|
|
||||||
internal void AddChildUntyped(AstNode child, Role role) |
|
||||||
{ |
|
||||||
if (role == null) |
|
||||||
throw new ArgumentNullException("role"); |
|
||||||
if (child == null || child.IsNull) |
|
||||||
return; |
|
||||||
if (this.IsNull) |
|
||||||
throw new InvalidOperationException("Cannot add children to null nodes"); |
|
||||||
if (child.parent != null) |
|
||||||
throw new ArgumentException ("Node is already used in another tree.", "child"); |
|
||||||
AddChildUnsafe(child, role); |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Adds a child without performing any safety checks.
|
|
||||||
/// </summary>
|
|
||||||
void AddChildUnsafe(AstNode child, Role role) |
|
||||||
{ |
|
||||||
child.parent = this; |
|
||||||
child.role = role; |
|
||||||
if (firstChild == null) { |
|
||||||
lastChild = firstChild = child; |
|
||||||
} else { |
|
||||||
lastChild.nextSibling = child; |
|
||||||
child.prevSibling = lastChild; |
|
||||||
lastChild = child; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public void InsertChildBefore<T>(AstNode nextSibling, T child, Role<T> role) where T : AstNode |
|
||||||
{ |
|
||||||
if (role == null) |
|
||||||
throw new ArgumentNullException("role"); |
|
||||||
if (nextSibling == null || nextSibling.IsNull) { |
|
||||||
AddChild(child, role); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
if (child == null || child.IsNull) |
|
||||||
return; |
|
||||||
if (child.parent != null) |
|
||||||
throw new ArgumentException ("Node is already used in another tree.", "child"); |
|
||||||
if (nextSibling.parent != this) |
|
||||||
throw new ArgumentException ("NextSibling is not a child of this node.", "nextSibling"); |
|
||||||
// No need to test for "Cannot add children to null nodes",
|
|
||||||
// as there isn't any valid nextSibling in null nodes.
|
|
||||||
InsertChildBeforeUnsafe(nextSibling, child, role); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
void InsertChildBeforeUnsafe(AstNode nextSibling, AstNode child, Role role) |
|
||||||
{ |
|
||||||
child.parent = this; |
|
||||||
child.role = role; |
|
||||||
child.nextSibling = nextSibling; |
|
||||||
child.prevSibling = nextSibling.prevSibling; |
|
||||||
|
|
||||||
if (nextSibling.prevSibling != null) { |
|
||||||
Debug.Assert(nextSibling.prevSibling.nextSibling == nextSibling); |
|
||||||
nextSibling.prevSibling.nextSibling = child; |
|
||||||
} else { |
|
||||||
Debug.Assert(firstChild == nextSibling); |
|
||||||
firstChild = child; |
|
||||||
} |
|
||||||
nextSibling.prevSibling = child; |
|
||||||
} |
|
||||||
|
|
||||||
public void InsertChildAfter<T>(AstNode prevSibling, T child, Role<T> role) where T : AstNode |
|
||||||
{ |
|
||||||
InsertChildBefore((prevSibling == null || prevSibling.IsNull) ? firstChild : prevSibling.nextSibling, child, role); |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Removes this node from its parent.
|
|
||||||
/// </summary>
|
|
||||||
public void Remove() |
|
||||||
{ |
|
||||||
if (parent != null) { |
|
||||||
if (prevSibling != null) { |
|
||||||
Debug.Assert(prevSibling.nextSibling == this); |
|
||||||
prevSibling.nextSibling = nextSibling; |
|
||||||
} else { |
|
||||||
Debug.Assert(parent.firstChild == this); |
|
||||||
parent.firstChild = nextSibling; |
|
||||||
} |
|
||||||
if (nextSibling != null) { |
|
||||||
Debug.Assert(nextSibling.prevSibling == this); |
|
||||||
nextSibling.prevSibling = prevSibling; |
|
||||||
} else { |
|
||||||
Debug.Assert(parent.lastChild == this); |
|
||||||
parent.lastChild = prevSibling; |
|
||||||
} |
|
||||||
parent = null; |
|
||||||
role = Roles.Root; |
|
||||||
prevSibling = null; |
|
||||||
nextSibling = null; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Replaces this node with the new node.
|
|
||||||
/// </summary>
|
|
||||||
public void ReplaceWith(AstNode newNode) |
|
||||||
{ |
|
||||||
if (newNode == null || newNode.IsNull) { |
|
||||||
Remove(); |
|
||||||
return; |
|
||||||
} |
|
||||||
if (newNode == this) |
|
||||||
return; // nothing to do...
|
|
||||||
if (parent == null) { |
|
||||||
throw new InvalidOperationException(this.IsNull ? "Cannot replace the null nodes" : "Cannot replace the root node"); |
|
||||||
} |
|
||||||
// Because this method doesn't statically check the new node's type with the role,
|
|
||||||
// we perform a runtime test:
|
|
||||||
if (!role.IsValid(newNode)) { |
|
||||||
throw new ArgumentException (string.Format("The new node '{0}' is not valid in the role {1}", newNode.GetType().Name, role.ToString()), "newNode"); |
|
||||||
} |
|
||||||
if (newNode.parent != null) { |
|
||||||
// newNode is used within this tree?
|
|
||||||
if (newNode.Ancestors.Contains(this)) { |
|
||||||
// e.g. "parenthesizedExpr.ReplaceWith(parenthesizedExpr.Expression);"
|
|
||||||
// enable automatic removal
|
|
||||||
newNode.Remove(); |
|
||||||
} else { |
|
||||||
throw new ArgumentException ("Node is already used in another tree.", "newNode"); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
newNode.parent = parent; |
|
||||||
newNode.role = role; |
|
||||||
newNode.prevSibling = prevSibling; |
|
||||||
newNode.nextSibling = nextSibling; |
|
||||||
if (parent != null) { |
|
||||||
if (prevSibling != null) { |
|
||||||
Debug.Assert(prevSibling.nextSibling == this); |
|
||||||
prevSibling.nextSibling = newNode; |
|
||||||
} else { |
|
||||||
Debug.Assert(parent.firstChild == this); |
|
||||||
parent.firstChild = newNode; |
|
||||||
} |
|
||||||
if (nextSibling != null) { |
|
||||||
Debug.Assert(nextSibling.prevSibling == this); |
|
||||||
nextSibling.prevSibling = newNode; |
|
||||||
} else { |
|
||||||
Debug.Assert(parent.lastChild == this); |
|
||||||
parent.lastChild = newNode; |
|
||||||
} |
|
||||||
parent = null; |
|
||||||
prevSibling = null; |
|
||||||
nextSibling = null; |
|
||||||
role = Roles.Root; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode ReplaceWith(Func<AstNode, AstNode> replaceFunction) |
|
||||||
{ |
|
||||||
if (replaceFunction == null) |
|
||||||
throw new ArgumentNullException("replaceFunction"); |
|
||||||
if (parent == null) { |
|
||||||
throw new InvalidOperationException(this.IsNull ? "Cannot replace the null nodes" : "Cannot replace the root node"); |
|
||||||
} |
|
||||||
AstNode oldParent = parent; |
|
||||||
AstNode oldSuccessor = nextSibling; |
|
||||||
Role oldRole = role; |
|
||||||
Remove(); |
|
||||||
AstNode replacement = replaceFunction(this); |
|
||||||
if (oldSuccessor != null && oldSuccessor.parent != oldParent) |
|
||||||
throw new InvalidOperationException("replace function changed nextSibling of node being replaced?"); |
|
||||||
if (!(replacement == null || replacement.IsNull)) { |
|
||||||
if (replacement.parent != null) |
|
||||||
throw new InvalidOperationException("replace function must return the root of a tree"); |
|
||||||
if (!oldRole.IsValid(replacement)) { |
|
||||||
throw new InvalidOperationException (string.Format("The new node '{0}' is not valid in the role {1}", replacement.GetType().Name, oldRole.ToString())); |
|
||||||
} |
|
||||||
|
|
||||||
if (oldSuccessor != null) |
|
||||||
oldParent.InsertChildBeforeUnsafe(oldSuccessor, replacement, oldRole); |
|
||||||
else |
|
||||||
oldParent.AddChildUnsafe(replacement, oldRole); |
|
||||||
} |
|
||||||
return replacement; |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Clones the whole subtree starting at this AST node.
|
|
||||||
/// </summary>
|
|
||||||
/// <remarks>Annotations are copied over to the new nodes; and any annotations implementating ICloneable will be cloned.</remarks>
|
|
||||||
public AstNode Clone() |
|
||||||
{ |
|
||||||
AstNode copy = (AstNode)MemberwiseClone(); |
|
||||||
// First, reset the shallow pointer copies
|
|
||||||
copy.parent = null; |
|
||||||
copy.role = Roles.Root; |
|
||||||
copy.firstChild = null; |
|
||||||
copy.lastChild = null; |
|
||||||
copy.prevSibling = null; |
|
||||||
copy.nextSibling = null; |
|
||||||
|
|
||||||
// Then perform a deep copy:
|
|
||||||
for (AstNode cur = firstChild; cur != null; cur = cur.nextSibling) { |
|
||||||
copy.AddChildUnsafe(cur.Clone(), cur.role); |
|
||||||
} |
|
||||||
|
|
||||||
// Finally, clone the annotation, if necessary
|
|
||||||
copy.CloneAnnotations(); |
|
||||||
|
|
||||||
return copy; |
|
||||||
} |
|
||||||
|
|
||||||
public override void AddAnnotation (object annotation) |
|
||||||
{ |
|
||||||
if (this.IsNull) |
|
||||||
throw new InvalidOperationException("Cannot add annotations to the null node"); |
|
||||||
base.AddAnnotation (annotation); |
|
||||||
} |
|
||||||
|
|
||||||
public abstract S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data); |
|
||||||
|
|
||||||
#region Pattern Matching
|
|
||||||
protected static bool MatchString(string name1, string name2) |
|
||||||
{ |
|
||||||
return string.IsNullOrEmpty(name1) || string.Equals(name1, name2, StringComparison.OrdinalIgnoreCase); |
|
||||||
} |
|
||||||
|
|
||||||
protected static bool MatchStringXml(string name1, string name2) |
|
||||||
{ |
|
||||||
return string.IsNullOrEmpty(name1) || string.Equals(name1, name2, StringComparison.Ordinal); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal abstract bool DoMatch(AstNode other, PatternMatching.Match match); |
|
||||||
|
|
||||||
bool PatternMatching.INode.DoMatch(PatternMatching.INode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
AstNode o = other as AstNode; |
|
||||||
// try matching if other is null, or if other is an AstNode
|
|
||||||
return (other == null || o != null) && DoMatch(o, match); |
|
||||||
} |
|
||||||
|
|
||||||
bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo) |
|
||||||
{ |
|
||||||
AstNode o = pos as AstNode; |
|
||||||
return (pos == null || o != null) && DoMatch (o, match); |
|
||||||
} |
|
||||||
|
|
||||||
PatternMatching.INode PatternMatching.INode.NextSibling { |
|
||||||
get { return nextSibling; } |
|
||||||
} |
|
||||||
|
|
||||||
PatternMatching.INode PatternMatching.INode.FirstChild { |
|
||||||
get { return firstChild; } |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
public AstNode GetNextNode () |
|
||||||
{ |
|
||||||
if (NextSibling != null) |
|
||||||
return NextSibling; |
|
||||||
if (Parent != null) |
|
||||||
return Parent.GetNextNode (); |
|
||||||
return null; |
|
||||||
} |
|
||||||
|
|
||||||
public AstNode GetPrevNode () |
|
||||||
{ |
|
||||||
if (PrevSibling != null) |
|
||||||
return PrevSibling; |
|
||||||
if (Parent != null) |
|
||||||
return Parent.GetPrevNode (); |
|
||||||
return null; |
|
||||||
} |
|
||||||
|
|
||||||
// filters all non VB nodes (comments, white spaces or pre processor directives)
|
|
||||||
public AstNode GetVBNodeBefore (AstNode node) |
|
||||||
{ |
|
||||||
var n = node.PrevSibling; |
|
||||||
while (n != null) { |
|
||||||
if (n.Role != Roles.Comment) |
|
||||||
return n; |
|
||||||
n = n.GetPrevNode (); |
|
||||||
} |
|
||||||
return null; |
|
||||||
} |
|
||||||
|
|
||||||
// the Root role must be available when creating the null nodes, so we can't put it in the Roles class
|
|
||||||
static readonly Role<AstNode> RootRole = new Role<AstNode>("Root"); |
|
||||||
|
|
||||||
public static class Roles |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// Root of an abstract syntax tree.
|
|
||||||
/// </summary>
|
|
||||||
public static readonly Role<AstNode> Root = RootRole; |
|
||||||
|
|
||||||
// some pre defined constants for common roles
|
|
||||||
public static readonly Role<Identifier> Identifier = new Role<Identifier>("Identifier", Ast.Identifier.Null); |
|
||||||
public static readonly Role<XmlIdentifier> XmlIdentifier = new Role<XmlIdentifier>("XmlIdentifier", Ast.XmlIdentifier.Null); |
|
||||||
public static readonly Role<XmlLiteralString> XmlLiteralString = new Role<XmlLiteralString>("XmlLiteralString", Ast.XmlLiteralString.Null); |
|
||||||
|
|
||||||
public static readonly Role<BlockStatement> Body = new Role<BlockStatement>("Body", Ast.BlockStatement.Null); |
|
||||||
public static readonly Role<ParameterDeclaration> Parameter = new Role<ParameterDeclaration>("Parameter"); |
|
||||||
public static readonly Role<Expression> Argument = new Role<Expression>("Argument", Ast.Expression.Null); |
|
||||||
public static readonly Role<AstType> Type = new Role<AstType>("Type", AstType.Null); |
|
||||||
public static readonly Role<Expression> Expression = new Role<Expression>("Expression", Ast.Expression.Null); |
|
||||||
public static readonly Role<Expression> TargetExpression = new Role<Expression>("Target", Ast.Expression.Null); |
|
||||||
public readonly static Role<Expression> Condition = new Role<Expression>("Condition", Ast.Expression.Null); |
|
||||||
//
|
|
||||||
public static readonly Role<TypeParameterDeclaration> TypeParameter = new Role<TypeParameterDeclaration>("TypeParameter"); |
|
||||||
public static readonly Role<AstType> TypeArgument = new Role<AstType>("TypeArgument", AstType.Null); |
|
||||||
// public static readonly Role<VariableInitializer> Variable = new Role<VariableInitializer>("Variable");
|
|
||||||
// public static readonly Role<Statement> EmbeddedStatement = new Role<Statement>("EmbeddedStatement", CSharp.Statement.Null);
|
|
||||||
//
|
|
||||||
public static readonly Role<VBTokenNode> Keyword = new Role<VBTokenNode>("Keyword", VBTokenNode.Null); |
|
||||||
// public static readonly Role<VBTokenNode> InKeyword = new Role<VBTokenNode>("InKeyword", VBTokenNode.Null);
|
|
||||||
|
|
||||||
// some pre defined constants for most used punctuation
|
|
||||||
public static readonly Role<VBTokenNode> LPar = new Role<VBTokenNode>("LPar", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> RPar = new Role<VBTokenNode>("RPar", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> LBracket = new Role<VBTokenNode>("LBracket", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> RBracket = new Role<VBTokenNode>("RBracket", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> LBrace = new Role<VBTokenNode>("LBrace", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> RBrace = new Role<VBTokenNode>("RBrace", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> LChevron = new Role<VBTokenNode>("LChevron", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> RChevron = new Role<VBTokenNode>("RChevron", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> Comma = new Role<VBTokenNode>("Comma", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> QuestionMark = new Role<VBTokenNode>("QuestionMark", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> Dot = new Role<VBTokenNode>("Dot", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> Semicolon = new Role<VBTokenNode>("Semicolon", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> Assign = new Role<VBTokenNode>("Assign", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> Colon = new Role<VBTokenNode>("Colon", VBTokenNode.Null); |
|
||||||
public static readonly Role<VBTokenNode> StatementTerminator = new Role<VBTokenNode>("StatementTerminator", VBTokenNode.Null); |
|
||||||
|
|
||||||
// XML
|
|
||||||
/// <summary>
|
|
||||||
/// Text: <
|
|
||||||
/// </summary>
|
|
||||||
public static readonly Role<VBTokenNode> XmlOpenTag = new Role<VBTokenNode>("XmlOpenTag", VBTokenNode.Null); |
|
||||||
/// <summary>
|
|
||||||
/// Text: >
|
|
||||||
/// </summary>
|
|
||||||
public static readonly Role<VBTokenNode> XmlCloseTag = new Role<VBTokenNode>("XmlOpenTag", VBTokenNode.Null); |
|
||||||
|
|
||||||
public static readonly Role<Comment> Comment = new Role<Comment>("Comment"); |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
} |
|
||||||
@ -1,199 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections; |
|
||||||
using System.Collections.Generic; |
|
||||||
using System.Diagnostics; |
|
||||||
using System.Linq; |
|
||||||
|
|
||||||
using ICSharpCode.NRefactory.PatternMatching; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// Represents the children of an AstNode that have a specific role.
|
|
||||||
/// </summary>
|
|
||||||
public class AstNodeCollection<T> : ICollection<T> where T : AstNode |
|
||||||
{ |
|
||||||
readonly AstNode node; |
|
||||||
readonly Role<T> role; |
|
||||||
|
|
||||||
public AstNodeCollection(AstNode node, Role<T> role) |
|
||||||
{ |
|
||||||
if (node == null) |
|
||||||
throw new ArgumentNullException("node"); |
|
||||||
if (role == null) |
|
||||||
throw new ArgumentNullException("role"); |
|
||||||
this.node = node; |
|
||||||
this.role = role; |
|
||||||
} |
|
||||||
|
|
||||||
public int Count { |
|
||||||
get { |
|
||||||
int count = 0; |
|
||||||
for (AstNode cur = node.FirstChild; cur != null; cur = cur.NextSibling) { |
|
||||||
if (cur.Role == role) |
|
||||||
count++; |
|
||||||
} |
|
||||||
return count; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public void Add(T element) |
|
||||||
{ |
|
||||||
node.AddChild(element, role); |
|
||||||
} |
|
||||||
|
|
||||||
public void AddRange(IEnumerable<T> nodes) |
|
||||||
{ |
|
||||||
// Evaluate 'nodes' first, since it might change when we add the new children
|
|
||||||
// Example: collection.AddRange(collection);
|
|
||||||
if (nodes != null) { |
|
||||||
foreach (T node in nodes.ToList()) |
|
||||||
Add(node); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public void AddRange(T[] nodes) |
|
||||||
{ |
|
||||||
// Fast overload for arrays - we don't need to create a copy
|
|
||||||
if (nodes != null) { |
|
||||||
foreach (T node in nodes) |
|
||||||
Add(node); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public void ReplaceWith(IEnumerable<T> nodes) |
|
||||||
{ |
|
||||||
// Evaluate 'nodes' first, since it might change when we call Clear()
|
|
||||||
// Example: collection.ReplaceWith(collection);
|
|
||||||
if (nodes != null) |
|
||||||
nodes = nodes.ToList(); |
|
||||||
Clear(); |
|
||||||
foreach (T node in nodes) |
|
||||||
Add(node); |
|
||||||
} |
|
||||||
|
|
||||||
public void MoveTo(ICollection<T> targetCollection) |
|
||||||
{ |
|
||||||
foreach (T node in this) { |
|
||||||
node.Remove(); |
|
||||||
targetCollection.Add(node); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public bool Contains(T element) |
|
||||||
{ |
|
||||||
return element != null && element.Parent == node && element.Role == role; |
|
||||||
} |
|
||||||
|
|
||||||
public bool Remove(T element) |
|
||||||
{ |
|
||||||
if (Contains(element)) { |
|
||||||
element.Remove(); |
|
||||||
return true; |
|
||||||
} else { |
|
||||||
return false; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public void CopyTo(T[] array, int arrayIndex) |
|
||||||
{ |
|
||||||
foreach (T item in this) |
|
||||||
array[arrayIndex++] = item; |
|
||||||
} |
|
||||||
|
|
||||||
public void Clear() |
|
||||||
{ |
|
||||||
foreach (T item in this) |
|
||||||
item.Remove(); |
|
||||||
} |
|
||||||
|
|
||||||
bool ICollection<T>.IsReadOnly { |
|
||||||
get { return false; } |
|
||||||
} |
|
||||||
|
|
||||||
public IEnumerator<T> GetEnumerator() |
|
||||||
{ |
|
||||||
AstNode next; |
|
||||||
for (AstNode cur = node.FirstChild; cur != null; cur = next) { |
|
||||||
Debug.Assert(cur.Parent == node); |
|
||||||
// Remember next before yielding cur.
|
|
||||||
// This allows removing/replacing nodes while iterating through the list.
|
|
||||||
next = cur.NextSibling; |
|
||||||
if (cur.Role == role) |
|
||||||
yield return (T)cur; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
IEnumerator IEnumerable.GetEnumerator() |
|
||||||
{ |
|
||||||
return GetEnumerator(); |
|
||||||
} |
|
||||||
|
|
||||||
#region Equals and GetHashCode implementation
|
|
||||||
public override int GetHashCode() |
|
||||||
{ |
|
||||||
return node.GetHashCode() ^ role.GetHashCode(); |
|
||||||
} |
|
||||||
|
|
||||||
public override bool Equals(object obj) |
|
||||||
{ |
|
||||||
AstNodeCollection<T> other = obj as AstNodeCollection<T>; |
|
||||||
if (other == null) |
|
||||||
return false; |
|
||||||
return this.node == other.node && this.role == other.role; |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
internal bool DoMatch(AstNodeCollection<T> other, Match match) |
|
||||||
{ |
|
||||||
// TODO : does not compile (ask Daniel)!
|
|
||||||
// Stack<AstNode> patternStack = new Stack<AstNode>();
|
|
||||||
// Stack<Pattern.PossibleMatch> stack = new Stack<Pattern.PossibleMatch>();
|
|
||||||
// patternStack.Push(this.node.FirstChild);
|
|
||||||
// stack.Push(new Pattern.PossibleMatch(other.node.FirstChild, match.CheckPoint()));
|
|
||||||
// while (stack.Count > 0) {
|
|
||||||
// AstNode cur1 = patternStack.Pop();
|
|
||||||
// AstNode cur2 = stack.Peek().NextOther;
|
|
||||||
// match.RestoreCheckPoint(stack.Pop().Checkpoint);
|
|
||||||
// bool success = true;
|
|
||||||
// while (cur1 != null && success) {
|
|
||||||
// while (cur1 != null && cur1.Role != role)
|
|
||||||
// cur1 = cur1.NextSibling;
|
|
||||||
// while (cur2 != null && cur2.Role != role)
|
|
||||||
// cur2 = cur2.NextSibling;
|
|
||||||
// if (cur1 == null)
|
|
||||||
// break;
|
|
||||||
//
|
|
||||||
// Debug.Assert(stack.Count == patternStack.Count);
|
|
||||||
// success = cur1.DoMatchCollection(role, cur2, match, stack);
|
|
||||||
// Debug.Assert(stack.Count >= patternStack.Count);
|
|
||||||
// while (stack.Count > patternStack.Count)
|
|
||||||
// patternStack.Push(cur1.NextSibling);
|
|
||||||
//
|
|
||||||
// cur1 = cur1.NextSibling;
|
|
||||||
// if (cur2 != null)
|
|
||||||
// cur2 = cur2.NextSibling;
|
|
||||||
// }
|
|
||||||
// while (cur2 != null && cur2.Role != role)
|
|
||||||
// cur2 = cur2.NextSibling;
|
|
||||||
// if (success && cur2 == null)
|
|
||||||
// return true;
|
|
||||||
// }
|
|
||||||
// return false;
|
|
||||||
throw new NotImplementedException(); |
|
||||||
} |
|
||||||
|
|
||||||
public void InsertAfter(T existingItem, T newItem) |
|
||||||
{ |
|
||||||
node.InsertChildAfter(existingItem, newItem, role); |
|
||||||
} |
|
||||||
|
|
||||||
public void InsertBefore(T existingItem, T newItem) |
|
||||||
{ |
|
||||||
node.InsertChildBefore(existingItem, newItem, role); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,67 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections; |
|
||||||
using System.Collections.Generic; |
|
||||||
using System.Diagnostics; |
|
||||||
using System.Linq; |
|
||||||
using System.Threading; |
|
||||||
using ICSharpCode.NRefactory.PatternMatching; |
|
||||||
using ICSharpCode.NRefactory.VB.Ast; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB |
|
||||||
{ |
|
||||||
public class Comment : AstNode |
|
||||||
{ |
|
||||||
public bool IsDocumentationComment { get; set; } |
|
||||||
|
|
||||||
public bool StartsLine { |
|
||||||
get; |
|
||||||
set; |
|
||||||
} |
|
||||||
|
|
||||||
public string Content { |
|
||||||
get; |
|
||||||
set; |
|
||||||
} |
|
||||||
|
|
||||||
TextLocation startLocation; |
|
||||||
public override TextLocation StartLocation { |
|
||||||
get { |
|
||||||
return startLocation; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
TextLocation endLocation; |
|
||||||
public override TextLocation EndLocation { |
|
||||||
get { |
|
||||||
return endLocation; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public Comment (string content, bool isDocumentation = false) |
|
||||||
{ |
|
||||||
this.IsDocumentationComment = isDocumentation; |
|
||||||
this.Content = content; |
|
||||||
} |
|
||||||
|
|
||||||
public Comment (bool isDocumentation, TextLocation startLocation, TextLocation endLocation) |
|
||||||
{ |
|
||||||
this.IsDocumentationComment = isDocumentation; |
|
||||||
this.startLocation = startLocation; |
|
||||||
this.endLocation = endLocation; |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitComment(this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
Comment o = other as Comment; |
|
||||||
return o != null && this.IsDocumentationComment == o.IsDocumentationComment && MatchString(this.Content, o.Content); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,154 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
[Flags] |
|
||||||
public enum Modifiers |
|
||||||
{ |
|
||||||
None = 0x0000, |
|
||||||
|
|
||||||
// Accessibility
|
|
||||||
Private = 0x0001, |
|
||||||
Friend = 0x0002, |
|
||||||
Protected = 0x0004, |
|
||||||
Public = 0x0008, |
|
||||||
|
|
||||||
// Scope
|
|
||||||
MustInherit = 0x0010, // Types
|
|
||||||
MustOverride = 0x0020, // Members
|
|
||||||
Overridable = 0x0040, |
|
||||||
NotInheritable = 0x0080, // Types
|
|
||||||
NotOverridable = 0x0100, // Members
|
|
||||||
Const = 0x0200, |
|
||||||
Shared = 0x0400, |
|
||||||
Static = 0x0800, |
|
||||||
Overrides = 0x1000, |
|
||||||
ReadOnly = 0x2000, |
|
||||||
Shadows = 0x4000, |
|
||||||
Partial = 0x8000, |
|
||||||
|
|
||||||
// Special
|
|
||||||
Overloads = 0x10000, // VB specific
|
|
||||||
WithEvents = 0x20000, // VB specific
|
|
||||||
Default = 0x40000, // VB specific
|
|
||||||
|
|
||||||
Dim = 0x80000, // VB.NET SPECIFIC, for fields/local variables only
|
|
||||||
|
|
||||||
/// <summary>Only for VB properties.</summary>
|
|
||||||
WriteOnly = 0x100000, // VB specific
|
|
||||||
|
|
||||||
ByVal = 0x200000, |
|
||||||
ByRef = 0x400000, |
|
||||||
ParamArray = 0x800000, |
|
||||||
Optional = 0x1000000, |
|
||||||
|
|
||||||
Narrowing = 0x2000000, |
|
||||||
Widening = 0x4000000, |
|
||||||
|
|
||||||
Iterator = 0x8000000, |
|
||||||
Async = 0x10000000, |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Special value used to match any modifiers during pattern matching.
|
|
||||||
/// </summary>
|
|
||||||
Any = unchecked((int)0x80000000) |
|
||||||
} |
|
||||||
|
|
||||||
public enum ParentType |
|
||||||
{ |
|
||||||
ClassOrStruct, |
|
||||||
InterfaceOrEnum, |
|
||||||
Namespace, |
|
||||||
Unknown |
|
||||||
} |
|
||||||
|
|
||||||
public enum FieldDirection |
|
||||||
{ |
|
||||||
None, |
|
||||||
In, |
|
||||||
Out, |
|
||||||
Ref |
|
||||||
} |
|
||||||
|
|
||||||
public enum AssignmentOperatorType |
|
||||||
{ |
|
||||||
None, |
|
||||||
Assign, |
|
||||||
|
|
||||||
Add, |
|
||||||
Subtract, |
|
||||||
Multiply, |
|
||||||
Divide, |
|
||||||
|
|
||||||
Power, // (VB only)
|
|
||||||
DivideInteger, // (VB only)
|
|
||||||
ConcatString, // (VB only)
|
|
||||||
|
|
||||||
ShiftLeft, |
|
||||||
ShiftRight, |
|
||||||
} |
|
||||||
|
|
||||||
public enum ContinueType |
|
||||||
{ |
|
||||||
None, |
|
||||||
Do, |
|
||||||
For, |
|
||||||
While |
|
||||||
} |
|
||||||
|
|
||||||
public enum ConditionType |
|
||||||
{ |
|
||||||
None, |
|
||||||
LoopUntil, |
|
||||||
LoopWhile, |
|
||||||
DoUntil, |
|
||||||
DoWhile |
|
||||||
} |
|
||||||
|
|
||||||
public enum ConversionType |
|
||||||
{ |
|
||||||
None, |
|
||||||
Implicit, |
|
||||||
Explicit |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Specifies the ordering direction of a QueryExpressionOrdering node.
|
|
||||||
/// </summary>
|
|
||||||
public enum QueryOrderingDirection |
|
||||||
{ |
|
||||||
None, |
|
||||||
Ascending, |
|
||||||
Descending |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Specifies the partition type for a VB.NET
|
|
||||||
/// query expression.
|
|
||||||
/// </summary>
|
|
||||||
public enum PartitionKind |
|
||||||
{ |
|
||||||
Take, |
|
||||||
TakeWhile, |
|
||||||
Skip, |
|
||||||
SkipWhile |
|
||||||
} |
|
||||||
|
|
||||||
public enum XmlAxisType |
|
||||||
{ |
|
||||||
Element, // .
|
|
||||||
Attribute, // .@
|
|
||||||
Descendents // ...
|
|
||||||
} |
|
||||||
|
|
||||||
public enum XmlContentType |
|
||||||
{ |
|
||||||
Comment, |
|
||||||
Text, |
|
||||||
CData, |
|
||||||
ProcessingInstruction |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,41 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class AnonymousObjectCreationExpression : Expression |
|
||||||
{ |
|
||||||
public AstNodeCollection<Expression> Initializer { |
|
||||||
get { return GetChildrenByRole(Roles.Expression); } |
|
||||||
} |
|
||||||
|
|
||||||
public AnonymousObjectCreationExpression () |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
public AnonymousObjectCreationExpression (IEnumerable<Expression> initializer) |
|
||||||
{ |
|
||||||
foreach (var ini in initializer) { |
|
||||||
AddChild (ini, Roles.Expression); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public AnonymousObjectCreationExpression (params Expression[] initializer) : this ((IEnumerable<Expression>)initializer) |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitAnonymousObjectCreationExpression(this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
var o = other as AnonymousObjectCreationExpression; |
|
||||||
return o != null && this.Initializer.DoMatch(o.Initializer, match); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,64 +0,0 @@ |
|||||||
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
||||||
// software and associated documentation files (the "Software"), to deal in the Software
|
|
||||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
||||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
||||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all copies or
|
|
||||||
// substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
||||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
||||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
|
||||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
||||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
// DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// New Type[Dimensions]
|
|
||||||
/// </summary>
|
|
||||||
public class ArrayCreateExpression : Expression |
|
||||||
{ |
|
||||||
public readonly static Role<ArraySpecifier> AdditionalArraySpecifierRole = new Role<ArraySpecifier>("AdditionalArraySpecifier"); |
|
||||||
public readonly static Role<ArrayInitializerExpression> InitializerRole = new Role<ArrayInitializerExpression>("Initializer", ArrayInitializerExpression.Null); |
|
||||||
|
|
||||||
public AstType Type { |
|
||||||
get { return GetChildByRole (Roles.Type); } |
|
||||||
set { SetChildByRole (Roles.Type, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public AstNodeCollection<Expression> Arguments { |
|
||||||
get { return GetChildrenByRole (Roles.Argument); } |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Gets additional array ranks (those without size info).
|
|
||||||
/// Empty for "New Integer(5,1)"; will contain a single element for "New Integer(5)()".
|
|
||||||
/// </summary>
|
|
||||||
public AstNodeCollection<ArraySpecifier> AdditionalArraySpecifiers { |
|
||||||
get { return GetChildrenByRole(AdditionalArraySpecifierRole); } |
|
||||||
} |
|
||||||
|
|
||||||
public ArrayInitializerExpression Initializer { |
|
||||||
get { return GetChildByRole (InitializerRole); } |
|
||||||
set { SetChildByRole (InitializerRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitArrayCreateExpression (this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
ArrayCreateExpression o = other as ArrayCreateExpression; |
|
||||||
return o != null && this.Type.DoMatch(o.Type, match) && this.Arguments.DoMatch(o.Arguments, match) && this.AdditionalArraySpecifiers.DoMatch(o.AdditionalArraySpecifiers, match) && this.Initializer.DoMatch(o.Initializer, match); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,53 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// { Elements }
|
|
||||||
/// </summary>
|
|
||||||
public class ArrayInitializerExpression : Expression |
|
||||||
{ |
|
||||||
#region Null
|
|
||||||
public new static readonly ArrayInitializerExpression Null = new NullArrayInitializerExpression (); |
|
||||||
|
|
||||||
sealed class NullArrayInitializerExpression : ArrayInitializerExpression |
|
||||||
{ |
|
||||||
public override bool IsNull { |
|
||||||
get { |
|
||||||
return true; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return default (S); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
return other == null || other.IsNull; |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
public readonly static Role<ArrayInitializerExpression> InitializerRole = new Role<ArrayInitializerExpression>("Initializer", ArrayInitializerExpression.Null); |
|
||||||
|
|
||||||
public AstNodeCollection<Expression> Elements { |
|
||||||
get { return GetChildrenByRole(Roles.Expression); } |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitArrayInitializerExpression (this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
ArrayInitializerExpression o = other as ArrayInitializerExpression; |
|
||||||
return o != null && this.Elements.DoMatch(o.Elements, match); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,44 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class AssignmentExpression : Expression |
|
||||||
{ |
|
||||||
public readonly static Role<Expression> LeftExpressionRole = BinaryOperatorExpression.LeftExpressionRole; |
|
||||||
public readonly static Role<VBTokenNode> OperatorRole = BinaryOperatorExpression.OperatorRole; |
|
||||||
public readonly static Role<Expression> RightExpressionRole = BinaryOperatorExpression.RightExpressionRole; |
|
||||||
|
|
||||||
public AssignmentExpression(Expression left, AssignmentOperatorType type, Expression right) |
|
||||||
{ |
|
||||||
AddChild(left, LeftExpressionRole); |
|
||||||
AddChild(right, RightExpressionRole); |
|
||||||
Operator = type; |
|
||||||
} |
|
||||||
|
|
||||||
public Expression Left { |
|
||||||
get { return GetChildByRole(LeftExpressionRole); } |
|
||||||
set { SetChildByRole(LeftExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public AssignmentOperatorType Operator { get; set; } |
|
||||||
|
|
||||||
public Expression Right { |
|
||||||
get { return GetChildByRole(RightExpressionRole); } |
|
||||||
set { SetChildByRole(RightExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) |
|
||||||
{ |
|
||||||
throw new NotImplementedException(); |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitAssignmentExpression(this, data); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,110 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class BinaryOperatorExpression : Expression |
|
||||||
{ |
|
||||||
public readonly static Role<Expression> LeftExpressionRole = new Role<Expression>("Left"); |
|
||||||
public readonly static Role<VBTokenNode> OperatorRole = new Role<VBTokenNode>("Operator"); |
|
||||||
public readonly static Role<Expression> RightExpressionRole = new Role<Expression>("Right"); |
|
||||||
|
|
||||||
public BinaryOperatorExpression(Expression left, BinaryOperatorType type, Expression right) |
|
||||||
{ |
|
||||||
AddChild(left, LeftExpressionRole); |
|
||||||
AddChild(right, RightExpressionRole); |
|
||||||
Operator = type; |
|
||||||
} |
|
||||||
|
|
||||||
public Expression Left { |
|
||||||
get { return GetChildByRole(LeftExpressionRole); } |
|
||||||
set { SetChildByRole(LeftExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public BinaryOperatorType Operator { get; set; } |
|
||||||
|
|
||||||
public Expression Right { |
|
||||||
get { return GetChildByRole(RightExpressionRole); } |
|
||||||
set { SetChildByRole(RightExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) |
|
||||||
{ |
|
||||||
throw new NotImplementedException(); |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitBinaryOperatorExpression(this, data); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public enum BinaryOperatorType |
|
||||||
{ |
|
||||||
None, |
|
||||||
|
|
||||||
/// <summary>'&' in C#, 'And' in VB.</summary>
|
|
||||||
BitwiseAnd, |
|
||||||
/// <summary>'|' in C#, 'Or' in VB.</summary>
|
|
||||||
BitwiseOr, |
|
||||||
/// <summary>'&&' in C#, 'AndAlso' in VB.</summary>
|
|
||||||
LogicalAnd, |
|
||||||
/// <summary>'||' in C#, 'OrElse' in VB.</summary>
|
|
||||||
LogicalOr, |
|
||||||
/// <summary>'^' in C#, 'Xor' in VB.</summary>
|
|
||||||
ExclusiveOr, |
|
||||||
|
|
||||||
/// <summary>></summary>
|
|
||||||
GreaterThan, |
|
||||||
/// <summary>>=</summary>
|
|
||||||
GreaterThanOrEqual, |
|
||||||
/// <summary>'==' in C#, '=' in VB.</summary>
|
|
||||||
Equality, |
|
||||||
/// <summary>'!=' in C#, '<>' in VB.</summary>
|
|
||||||
InEquality, |
|
||||||
/// <summary><</summary>
|
|
||||||
LessThan, |
|
||||||
/// <summary><=</summary>
|
|
||||||
LessThanOrEqual, |
|
||||||
|
|
||||||
/// <summary>+</summary>
|
|
||||||
Add, |
|
||||||
/// <summary>-</summary>
|
|
||||||
Subtract, |
|
||||||
/// <summary>*</summary>
|
|
||||||
Multiply, |
|
||||||
/// <summary>/</summary>
|
|
||||||
Divide, |
|
||||||
/// <summary>'%' in C#, 'Mod' in VB.</summary>
|
|
||||||
Modulus, |
|
||||||
/// <summary>VB-only: \</summary>
|
|
||||||
DivideInteger, |
|
||||||
/// <summary>VB-only: ^</summary>
|
|
||||||
Power, |
|
||||||
/// <summary>VB-only: &</summary>
|
|
||||||
Concat, |
|
||||||
|
|
||||||
/// <summary>C#: <<</summary>
|
|
||||||
ShiftLeft, |
|
||||||
/// <summary>C#: >></summary>
|
|
||||||
ShiftRight, |
|
||||||
/// <summary>VB-only: Is</summary>
|
|
||||||
ReferenceEquality, |
|
||||||
/// <summary>VB-only: IsNot</summary>
|
|
||||||
ReferenceInequality, |
|
||||||
|
|
||||||
/// <summary>VB-only: Like</summary>
|
|
||||||
Like, |
|
||||||
/// <summary>
|
|
||||||
/// C#: ??
|
|
||||||
/// VB: IF(x, y)
|
|
||||||
/// </summary>
|
|
||||||
NullCoalescing, |
|
||||||
|
|
||||||
/// <summary>VB-only: !</summary>
|
|
||||||
DictionaryAccess |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,95 +0,0 @@ |
|||||||
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
||||||
// software and associated documentation files (the "Software"), to deal in the Software
|
|
||||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
||||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
||||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all copies or
|
|
||||||
// substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
||||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
||||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
|
||||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
||||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
// DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// CastType(Expression, AstType)
|
|
||||||
/// </summary>
|
|
||||||
public class CastExpression : Expression |
|
||||||
{ |
|
||||||
public CastType CastType { get; set; } |
|
||||||
|
|
||||||
public VBTokenNode CastTypeToken { |
|
||||||
get { return GetChildByRole (Roles.Keyword); } |
|
||||||
} |
|
||||||
|
|
||||||
public AstType Type { |
|
||||||
get { return GetChildByRole (Roles.Type); } |
|
||||||
set { SetChildByRole (Roles.Type, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression Expression { |
|
||||||
get { return GetChildByRole (Roles.Expression); } |
|
||||||
set { SetChildByRole (Roles.Expression, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public CastExpression () |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
public CastExpression (CastType castType, AstType castToType, Expression expression) |
|
||||||
{ |
|
||||||
CastType = castType; |
|
||||||
AddChild (castToType, Roles.Type); |
|
||||||
AddChild (expression, Roles.Expression); |
|
||||||
} |
|
||||||
|
|
||||||
public CastExpression (CastType castType, Expression expression) |
|
||||||
{ |
|
||||||
CastType = castType; |
|
||||||
AddChild (expression, Roles.Expression); |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitCastExpression (this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
CastExpression o = other as CastExpression; |
|
||||||
return o != null && this.CastType == o.CastType && this.Type.DoMatch(o.Type, match) && this.Expression.DoMatch(o.Expression, match); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public enum CastType |
|
||||||
{ |
|
||||||
DirectCast, |
|
||||||
TryCast, |
|
||||||
CType, |
|
||||||
CBool, |
|
||||||
CByte, |
|
||||||
CChar, |
|
||||||
CDate, |
|
||||||
CDec, |
|
||||||
CDbl, |
|
||||||
CInt, |
|
||||||
CLng, |
|
||||||
CObj, |
|
||||||
CSByte, |
|
||||||
CShort, |
|
||||||
CSng, |
|
||||||
CStr, |
|
||||||
CUInt, |
|
||||||
CULng, |
|
||||||
CUShort |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,42 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// Identifier As Type In Expression
|
|
||||||
/// </summary>
|
|
||||||
public class CollectionRangeVariableDeclaration : AstNode |
|
||||||
{ |
|
||||||
public static readonly Role<CollectionRangeVariableDeclaration> CollectionRangeVariableDeclarationRole = new Role<CollectionRangeVariableDeclaration>("CollectionRangeVariableDeclaration"); |
|
||||||
|
|
||||||
public VariableIdentifier Identifier { |
|
||||||
get { return GetChildByRole(VariableIdentifier.VariableIdentifierRole); } |
|
||||||
set { SetChildByRole(VariableIdentifier.VariableIdentifierRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public AstType Type { |
|
||||||
get { return GetChildByRole(Roles.Type); } |
|
||||||
set { SetChildByRole(Roles.Type, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression Expression { |
|
||||||
get { return GetChildByRole (Roles.Expression); } |
|
||||||
set { SetChildByRole (Roles.Expression, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitCollectionRangeVariableDeclaration(this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
CollectionRangeVariableDeclaration o = other as CollectionRangeVariableDeclaration; |
|
||||||
return o != null && this.Identifier.DoMatch(o.Identifier, match) && this.Type.DoMatch(o.Type, match) && this.Expression.DoMatch(o.Expression, match); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,44 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class ConditionalExpression : Expression |
|
||||||
{ |
|
||||||
public readonly static Role<Expression> ConditionExpressionRole = new Role<Expression>("ConditionExpressionRole", Expression.Null); |
|
||||||
public readonly static Role<Expression> TrueExpressionRole = new Role<Expression>("TrueExpressionRole", Expression.Null); |
|
||||||
public readonly static Role<Expression> FalseExpressionRole = new Role<Expression>("FalseExpressionRole", Expression.Null); |
|
||||||
|
|
||||||
public VBTokenNode IfToken { |
|
||||||
get { return GetChildByRole (Roles.Keyword); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression ConditionExpression { |
|
||||||
get { return GetChildByRole (ConditionExpressionRole); } |
|
||||||
set { SetChildByRole (ConditionExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression TrueExpression { |
|
||||||
get { return GetChildByRole (TrueExpressionRole); } |
|
||||||
set { SetChildByRole (TrueExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression FalseExpression { |
|
||||||
get { return GetChildByRole (FalseExpressionRole); } |
|
||||||
set { SetChildByRole (FalseExpressionRole, value); } |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) |
|
||||||
{ |
|
||||||
throw new NotImplementedException(); |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitConditionalExpression(this, data); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,59 +0,0 @@ |
|||||||
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
|
||||||
// software and associated documentation files (the "Software"), to deal in the Software
|
|
||||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
|
||||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
|
||||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in all copies or
|
|
||||||
// substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
||||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
||||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
|
||||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
||||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
||||||
// DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class EmptyExpression : Expression |
|
||||||
{ |
|
||||||
TextLocation location; |
|
||||||
|
|
||||||
public override TextLocation StartLocation { |
|
||||||
get { |
|
||||||
return location; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public override TextLocation EndLocation { |
|
||||||
get { |
|
||||||
return location; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public EmptyExpression() |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
public EmptyExpression(TextLocation location) |
|
||||||
{ |
|
||||||
this.location = location; |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitEmptyExpression(this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
var o = other as EmptyExpression; |
|
||||||
return o != null; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,107 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public abstract class Expression : AstNode |
|
||||||
{ |
|
||||||
#region Null
|
|
||||||
public new static readonly Expression Null = new NullExpression (); |
|
||||||
|
|
||||||
sealed class NullExpression : Expression |
|
||||||
{ |
|
||||||
public override bool IsNull { |
|
||||||
get { |
|
||||||
return true; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return default (S); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
return other == null || other.IsNull; |
|
||||||
} |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
|
|
||||||
#region Builder methods
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an member reference expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public MemberAccessExpression Member(string memberName) |
|
||||||
{ |
|
||||||
return new MemberAccessExpression { Target = this, MemberName = memberName }; |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an invocation expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public InvocationExpression Invoke(string methodName, IEnumerable<Expression> arguments) |
|
||||||
{ |
|
||||||
return Invoke(methodName, null, arguments); |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an invocation expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public InvocationExpression Invoke(string methodName, params Expression[] arguments) |
|
||||||
{ |
|
||||||
return Invoke(methodName, null, arguments); |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an invocation expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public InvocationExpression Invoke(string methodName, IEnumerable<AstType> typeArguments, IEnumerable<Expression> arguments) |
|
||||||
{ |
|
||||||
InvocationExpression ie = new InvocationExpression(); |
|
||||||
MemberAccessExpression mre = new MemberAccessExpression(); |
|
||||||
mre.Target = this; |
|
||||||
mre.MemberName = methodName; |
|
||||||
mre.TypeArguments.AddRange(typeArguments); |
|
||||||
ie.Target = mre; |
|
||||||
ie.Arguments.AddRange(arguments); |
|
||||||
return ie; |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an invocation expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public InvocationExpression Invoke(IEnumerable<Expression> arguments) |
|
||||||
{ |
|
||||||
InvocationExpression ie = new InvocationExpression(); |
|
||||||
ie.Target = this; |
|
||||||
ie.Arguments.AddRange(arguments); |
|
||||||
return ie; |
|
||||||
} |
|
||||||
|
|
||||||
/// <summary>
|
|
||||||
/// Builds an invocation expression using this expression as target.
|
|
||||||
/// </summary>
|
|
||||||
public InvocationExpression Invoke(params Expression[] arguments) |
|
||||||
{ |
|
||||||
InvocationExpression ie = new InvocationExpression(); |
|
||||||
ie.Target = this; |
|
||||||
ie.Arguments.AddRange(arguments); |
|
||||||
return ie; |
|
||||||
} |
|
||||||
|
|
||||||
public CastExpression CastTo(AstType type) |
|
||||||
{ |
|
||||||
return new CastExpression { CastType = CastType.CType, Type = type, Expression = this }; |
|
||||||
} |
|
||||||
|
|
||||||
public CastExpression CastTo(Type type) |
|
||||||
{ |
|
||||||
return new CastExpression { CastType = CastType.CType, Type = AstType.Create(type), Expression = this }; |
|
||||||
} |
|
||||||
#endregion
|
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,49 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
using System.Collections.Generic; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
/// <summary>
|
|
||||||
/// [ Key ] .Identifier = Expression
|
|
||||||
/// </summary>
|
|
||||||
public class FieldInitializerExpression : Expression |
|
||||||
{ |
|
||||||
public bool IsKey { get; set; } |
|
||||||
|
|
||||||
public VBTokenNode KeyToken { |
|
||||||
get { return GetChildByRole (Roles.Keyword); } |
|
||||||
} |
|
||||||
|
|
||||||
public VBTokenNode DotToken { |
|
||||||
get { return GetChildByRole (Roles.Dot); } |
|
||||||
} |
|
||||||
|
|
||||||
public Identifier Identifier { |
|
||||||
get { return GetChildByRole(Roles.Identifier); } |
|
||||||
set { SetChildByRole(Roles.Identifier, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public VBTokenNode AssignToken { |
|
||||||
get { return GetChildByRole (Roles.Assign); } |
|
||||||
} |
|
||||||
|
|
||||||
public Expression Expression { |
|
||||||
get { return GetChildByRole (Roles.Expression); } |
|
||||||
set { SetChildByRole (Roles.Expression, value); } |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitFieldInitializerExpression(this, data); |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) |
|
||||||
{ |
|
||||||
FieldInitializerExpression o = other as FieldInitializerExpression; |
|
||||||
return o != null && this.IsKey == o.IsKey && this.Identifier.DoMatch(o.Identifier, match) && this.Expression.DoMatch(o.Expression, match); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,31 +0,0 @@ |
|||||||
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
|
|
||||||
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
||||||
|
|
||||||
using System; |
|
||||||
|
|
||||||
namespace ICSharpCode.NRefactory.VB.Ast |
|
||||||
{ |
|
||||||
public class GetTypeExpression : Expression |
|
||||||
{ |
|
||||||
public GetTypeExpression() |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
public AstType Type { |
|
||||||
get { return GetChildByRole(Roles.Type); } |
|
||||||
set { SetChildByRole(Roles.Type, value); } |
|
||||||
} |
|
||||||
|
|
||||||
protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) |
|
||||||
{ |
|
||||||
var expr = other as GetTypeExpression; |
|
||||||
return expr != null && |
|
||||||
Type.DoMatch(expr.Type, match); |
|
||||||
} |
|
||||||
|
|
||||||
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data) |
|
||||||
{ |
|
||||||
return visitor.VisitGetTypeExpression(this, data); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue