mirror of https://github.com/icsharpcode/ILSpy.git
Daniel Grunwald
15 years ago
590 changed files with 270809 additions and 0 deletions
@ -0,0 +1,2 @@
@@ -0,0 +1,2 @@
|
||||
*.sln -crlf |
||||
*.csproj -crlf |
||||
@ -0,0 +1,2 @@
@@ -0,0 +1,2 @@
|
||||
/lib/*.dll |
||||
/ICSharpCode.NRefactory.Tests/PartCover/* |
||||
@ -0,0 +1,3 @@
@@ -0,0 +1,3 @@
|
||||
|
||||
bin/ |
||||
obj/ |
||||
@ -0,0 +1,87 @@
@@ -0,0 +1,87 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build"> |
||||
<PropertyGroup> |
||||
<ProjectGuid>{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}</ProjectGuid> |
||||
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> |
||||
<Platform Condition=" '$(Platform)' == '' ">x86</Platform> |
||||
<OutputType>WinExe</OutputType> |
||||
<RootNamespace>ICSharpCode.NRefactory.Demo</RootNamespace> |
||||
<AssemblyName>ICSharpCode.NRefactory.Demo</AssemblyName> |
||||
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion> |
||||
<TargetFrameworkProfile>Client</TargetFrameworkProfile> |
||||
<AppDesignerFolder>Properties</AppDesignerFolder> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition=" '$(Platform)' == 'x86' "> |
||||
<PlatformTarget>x86</PlatformTarget> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> |
||||
<OutputPath>bin\Debug\</OutputPath> |
||||
<DebugSymbols>True</DebugSymbols> |
||||
<DebugType>Full</DebugType> |
||||
<Optimize>False</Optimize> |
||||
<CheckForOverflowUnderflow>True</CheckForOverflowUnderflow> |
||||
<DefineConstants>DEBUG;TRACE</DefineConstants> |
||||
</PropertyGroup> |
||||
<PropertyGroup Condition=" '$(Configuration)' == 'Release' "> |
||||
<OutputPath>bin\Release\</OutputPath> |
||||
<DebugSymbols>False</DebugSymbols> |
||||
<DebugType>None</DebugType> |
||||
<Optimize>True</Optimize> |
||||
<CheckForOverflowUnderflow>False</CheckForOverflowUnderflow> |
||||
<DefineConstants>TRACE</DefineConstants> |
||||
</PropertyGroup> |
||||
<ItemGroup> |
||||
<Reference Include="System" /> |
||||
<Reference Include="System.Core"> |
||||
<RequiredTargetFramework>3.5</RequiredTargetFramework> |
||||
</Reference> |
||||
<Reference Include="System.Drawing" /> |
||||
<Reference Include="System.Windows.Forms" /> |
||||
<Reference Include="System.Xml" /> |
||||
</ItemGroup> |
||||
<ItemGroup> |
||||
<Compile Include="VBEditDialog.cs" /> |
||||
<Compile Include="VBEditDialog.Designer.cs"> |
||||
<DependentUpon>VBEditDialog.cs</DependentUpon> |
||||
</Compile> |
||||
<Compile Include="VBDomView.cs" /> |
||||
<Compile Include="VBDomView.Designer.cs"> |
||||
<DependentUpon>VBDomView.cs</DependentUpon> |
||||
</Compile> |
||||
<Compile Include="MainForm.cs" /> |
||||
<Compile Include="MainForm.Designer.cs"> |
||||
<DependentUpon>MainForm.cs</DependentUpon> |
||||
</Compile> |
||||
<Compile Include="Program.cs" /> |
||||
<Compile Include="Properties\AssemblyInfo.cs" /> |
||||
<Compile Include="VBDemo.cs" /> |
||||
<Compile Include="VBDemo.Designer.cs"> |
||||
<DependentUpon>VBDemo.cs</DependentUpon> |
||||
</Compile> |
||||
</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="..\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj"> |
||||
<Project>{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}</Project> |
||||
<Name>ICSharpCode.NRefactory</Name> |
||||
</ProjectReference> |
||||
</ItemGroup> |
||||
<ItemGroup> |
||||
<EmbeddedResource Include="VBEditDialog.resx"> |
||||
<DependentUpon>VBEditDialog.cs</DependentUpon> |
||||
</EmbeddedResource> |
||||
<EmbeddedResource Include="VBDomView.resx"> |
||||
<DependentUpon>VBDomView.cs</DependentUpon> |
||||
</EmbeddedResource> |
||||
<EmbeddedResource Include="MainForm.resx"> |
||||
<DependentUpon>MainForm.cs</DependentUpon> |
||||
</EmbeddedResource> |
||||
<EmbeddedResource Include="VBDemo.resx"> |
||||
<DependentUpon>VBDemo.cs</DependentUpon> |
||||
</EmbeddedResource> |
||||
</ItemGroup> |
||||
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" /> |
||||
</Project> |
||||
@ -0,0 +1,221 @@
@@ -0,0 +1,221 @@
|
||||
// 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)
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
partial class MainForm |
||||
{ |
||||
/// <summary>
|
||||
/// Designer variable used to keep track of non-visual components.
|
||||
/// </summary>
|
||||
private System.ComponentModel.IContainer components = null; |
||||
|
||||
/// <summary>
|
||||
/// Disposes resources used by the form.
|
||||
/// </summary>
|
||||
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
||||
protected override void Dispose(bool disposing) |
||||
{ |
||||
if (disposing) { |
||||
if (components != null) { |
||||
components.Dispose(); |
||||
} |
||||
} |
||||
base.Dispose(disposing); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// This method is required for Windows Forms designer support.
|
||||
/// Do not change the method contents inside the source code editor. The Forms designer might
|
||||
/// not be able to load this method if it was changed manually.
|
||||
/// </summary>
|
||||
private void InitializeComponent() |
||||
{ |
||||
this.tabPage2 = new System.Windows.Forms.TabPage(); |
||||
this.tabPage1 = new System.Windows.Forms.TabPage(); |
||||
this.splitContainer1 = new System.Windows.Forms.SplitContainer(); |
||||
this.csharpCodeTextBox = new System.Windows.Forms.TextBox(); |
||||
this.resolveButton = new System.Windows.Forms.Button(); |
||||
this.csharpTreeView = new System.Windows.Forms.TreeView(); |
||||
this.csharpGenerateCodeButton = new System.Windows.Forms.Button(); |
||||
this.csharpParseButton = new System.Windows.Forms.Button(); |
||||
this.tabControl1 = new System.Windows.Forms.TabControl(); |
||||
this.miniToolStrip = new System.Windows.Forms.ToolStrip(); |
||||
this.vbDemo1 = new ICSharpCode.NRefactory.Demo.VBDemo(); |
||||
this.tabPage2.SuspendLayout(); |
||||
this.tabPage1.SuspendLayout(); |
||||
((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit(); |
||||
this.splitContainer1.Panel1.SuspendLayout(); |
||||
this.splitContainer1.Panel2.SuspendLayout(); |
||||
this.splitContainer1.SuspendLayout(); |
||||
this.tabControl1.SuspendLayout(); |
||||
this.SuspendLayout(); |
||||
//
|
||||
// tabPage2
|
||||
//
|
||||
this.tabPage2.Controls.Add(this.vbDemo1); |
||||
this.tabPage2.Location = new System.Drawing.Point(4, 22); |
||||
this.tabPage2.Name = "tabPage2"; |
||||
this.tabPage2.Padding = new System.Windows.Forms.Padding(3); |
||||
this.tabPage2.Size = new System.Drawing.Size(507, 458); |
||||
this.tabPage2.TabIndex = 1; |
||||
this.tabPage2.Text = "VB"; |
||||
this.tabPage2.UseVisualStyleBackColor = true; |
||||
//
|
||||
// tabPage1
|
||||
//
|
||||
this.tabPage1.Controls.Add(this.splitContainer1); |
||||
this.tabPage1.Location = new System.Drawing.Point(4, 22); |
||||
this.tabPage1.Name = "tabPage1"; |
||||
this.tabPage1.Padding = new System.Windows.Forms.Padding(3); |
||||
this.tabPage1.Size = new System.Drawing.Size(507, 458); |
||||
this.tabPage1.TabIndex = 0; |
||||
this.tabPage1.Text = "C#"; |
||||
this.tabPage1.UseVisualStyleBackColor = true; |
||||
//
|
||||
// splitContainer1
|
||||
//
|
||||
this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.splitContainer1.Location = new System.Drawing.Point(3, 3); |
||||
this.splitContainer1.Name = "splitContainer1"; |
||||
this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal; |
||||
//
|
||||
// splitContainer1.Panel1
|
||||
//
|
||||
this.splitContainer1.Panel1.Controls.Add(this.csharpCodeTextBox); |
||||
//
|
||||
// splitContainer1.Panel2
|
||||
//
|
||||
this.splitContainer1.Panel2.Controls.Add(this.resolveButton); |
||||
this.splitContainer1.Panel2.Controls.Add(this.csharpTreeView); |
||||
this.splitContainer1.Panel2.Controls.Add(this.csharpGenerateCodeButton); |
||||
this.splitContainer1.Panel2.Controls.Add(this.csharpParseButton); |
||||
this.splitContainer1.Size = new System.Drawing.Size(501, 452); |
||||
this.splitContainer1.SplitterDistance = 201; |
||||
this.splitContainer1.TabIndex = 0; |
||||
//
|
||||
// csharpCodeTextBox
|
||||
//
|
||||
this.csharpCodeTextBox.AcceptsReturn = true; |
||||
this.csharpCodeTextBox.AcceptsTab = true; |
||||
this.csharpCodeTextBox.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.csharpCodeTextBox.Font = new System.Drawing.Font("Courier New", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); |
||||
this.csharpCodeTextBox.HideSelection = false; |
||||
this.csharpCodeTextBox.Location = new System.Drawing.Point(0, 0); |
||||
this.csharpCodeTextBox.Multiline = true; |
||||
this.csharpCodeTextBox.Name = "csharpCodeTextBox"; |
||||
this.csharpCodeTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Both; |
||||
this.csharpCodeTextBox.Size = new System.Drawing.Size(501, 201); |
||||
this.csharpCodeTextBox.TabIndex = 0; |
||||
this.csharpCodeTextBox.Text = "using System;\r\nclass Test\r\n{\r\n public void Main(string[] args)\r\n {\r\n " + |
||||
" Console.WriteLine(\"Hello, World\");\r\n }\r\n}"; |
||||
this.csharpCodeTextBox.WordWrap = false; |
||||
this.csharpCodeTextBox.TextChanged += new System.EventHandler(this.CsharpCodeTextBoxTextChanged); |
||||
this.csharpCodeTextBox.KeyDown += new System.Windows.Forms.KeyEventHandler(this.CSharpCodeTextBoxKeyDown); |
||||
//
|
||||
// resolveButton
|
||||
//
|
||||
this.resolveButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.resolveButton.Location = new System.Drawing.Point(200, 3); |
||||
this.resolveButton.Name = "resolveButton"; |
||||
this.resolveButton.Size = new System.Drawing.Size(100, 23); |
||||
this.resolveButton.TabIndex = 3; |
||||
this.resolveButton.Text = "Resolve"; |
||||
this.resolveButton.UseVisualStyleBackColor = true; |
||||
this.resolveButton.Click += new System.EventHandler(this.ResolveButtonClick); |
||||
//
|
||||
// csharpTreeView
|
||||
//
|
||||
this.csharpTreeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) |
||||
| System.Windows.Forms.AnchorStyles.Left) |
||||
| System.Windows.Forms.AnchorStyles.Right))); |
||||
this.csharpTreeView.HideSelection = false; |
||||
this.csharpTreeView.Location = new System.Drawing.Point(3, 32); |
||||
this.csharpTreeView.Name = "csharpTreeView"; |
||||
this.csharpTreeView.Size = new System.Drawing.Size(493, 212); |
||||
this.csharpTreeView.TabIndex = 2; |
||||
this.csharpTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.CSharpTreeViewAfterSelect); |
||||
//
|
||||
// csharpGenerateCodeButton
|
||||
//
|
||||
this.csharpGenerateCodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.csharpGenerateCodeButton.Location = new System.Drawing.Point(306, 2); |
||||
this.csharpGenerateCodeButton.Name = "csharpGenerateCodeButton"; |
||||
this.csharpGenerateCodeButton.Size = new System.Drawing.Size(100, 23); |
||||
this.csharpGenerateCodeButton.TabIndex = 1; |
||||
this.csharpGenerateCodeButton.Text = "Generate"; |
||||
this.csharpGenerateCodeButton.UseVisualStyleBackColor = true; |
||||
this.csharpGenerateCodeButton.Click += new System.EventHandler(this.CSharpGenerateCodeButtonClick); |
||||
//
|
||||
// csharpParseButton
|
||||
//
|
||||
this.csharpParseButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.csharpParseButton.Location = new System.Drawing.Point(94, 3); |
||||
this.csharpParseButton.Name = "csharpParseButton"; |
||||
this.csharpParseButton.Size = new System.Drawing.Size(100, 23); |
||||
this.csharpParseButton.TabIndex = 0; |
||||
this.csharpParseButton.Text = "Parse"; |
||||
this.csharpParseButton.UseVisualStyleBackColor = true; |
||||
this.csharpParseButton.Click += new System.EventHandler(this.CSharpParseButtonClick); |
||||
//
|
||||
// tabControl1
|
||||
//
|
||||
this.tabControl1.Controls.Add(this.tabPage1); |
||||
this.tabControl1.Controls.Add(this.tabPage2); |
||||
this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.tabControl1.Location = new System.Drawing.Point(0, 0); |
||||
this.tabControl1.Name = "tabControl1"; |
||||
this.tabControl1.SelectedIndex = 0; |
||||
this.tabControl1.Size = new System.Drawing.Size(515, 484); |
||||
this.tabControl1.TabIndex = 0; |
||||
//
|
||||
// miniToolStrip
|
||||
//
|
||||
this.miniToolStrip.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); |
||||
this.miniToolStrip.AutoSize = false; |
||||
this.miniToolStrip.CanOverflow = false; |
||||
this.miniToolStrip.Dock = System.Windows.Forms.DockStyle.None; |
||||
this.miniToolStrip.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; |
||||
this.miniToolStrip.Location = new System.Drawing.Point(13, 3); |
||||
this.miniToolStrip.Name = "miniToolStrip"; |
||||
this.miniToolStrip.Size = new System.Drawing.Size(16, 25); |
||||
this.miniToolStrip.TabIndex = 3; |
||||
//
|
||||
// vbDemo1
|
||||
//
|
||||
this.vbDemo1.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.vbDemo1.Location = new System.Drawing.Point(3, 3); |
||||
this.vbDemo1.Name = "vbDemo1"; |
||||
this.vbDemo1.Size = new System.Drawing.Size(501, 452); |
||||
this.vbDemo1.TabIndex = 0; |
||||
//
|
||||
// MainForm
|
||||
//
|
||||
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); |
||||
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; |
||||
this.ClientSize = new System.Drawing.Size(515, 484); |
||||
this.Controls.Add(this.tabControl1); |
||||
this.Name = "MainForm"; |
||||
this.Text = "NRefactory Demo"; |
||||
this.tabPage2.ResumeLayout(false); |
||||
this.tabPage1.ResumeLayout(false); |
||||
this.splitContainer1.Panel1.ResumeLayout(false); |
||||
this.splitContainer1.Panel1.PerformLayout(); |
||||
this.splitContainer1.Panel2.ResumeLayout(false); |
||||
((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit(); |
||||
this.splitContainer1.ResumeLayout(false); |
||||
this.tabControl1.ResumeLayout(false); |
||||
this.ResumeLayout(false); |
||||
} |
||||
private ICSharpCode.NRefactory.Demo.VBDemo vbDemo1; |
||||
private System.Windows.Forms.Button resolveButton; |
||||
private System.Windows.Forms.ToolStrip miniToolStrip; |
||||
private System.Windows.Forms.TreeView csharpTreeView; |
||||
private System.Windows.Forms.Button csharpParseButton; |
||||
private System.Windows.Forms.Button csharpGenerateCodeButton; |
||||
private System.Windows.Forms.TextBox csharpCodeTextBox; |
||||
private System.Windows.Forms.SplitContainer splitContainer1; |
||||
private System.Windows.Forms.TabPage tabPage2; |
||||
private System.Windows.Forms.TabPage tabPage1; |
||||
private System.Windows.Forms.TabControl tabControl1; |
||||
} |
||||
} |
||||
@ -0,0 +1,228 @@
@@ -0,0 +1,228 @@
|
||||
// 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; |
||||
using System.Diagnostics; |
||||
using System.Drawing; |
||||
using System.IO; |
||||
using System.Reflection; |
||||
using System.Text; |
||||
using System.Threading; |
||||
using System.Threading.Tasks; |
||||
using System.Windows.Forms; |
||||
using ICSharpCode.NRefactory.CSharp; |
||||
using ICSharpCode.NRefactory.CSharp.Resolver; |
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
/// <summary>
|
||||
/// Description of MainForm.
|
||||
/// </summary>
|
||||
public partial class MainForm : Form |
||||
{ |
||||
public MainForm() |
||||
{ |
||||
//
|
||||
// The InitializeComponent() call is required for Windows Forms designer support.
|
||||
//
|
||||
InitializeComponent(); |
||||
|
||||
csharpCodeTextBox.SelectAll(); |
||||
CSharpParseButtonClick(null, null); |
||||
resolveButton.UseWaitCursor = true; |
||||
ThreadPool.QueueUserWorkItem( |
||||
delegate { |
||||
builtInLibs.Value.ToString(); |
||||
BeginInvoke(new Action(delegate { resolveButton.UseWaitCursor = false; })); |
||||
}); |
||||
} |
||||
|
||||
CompilationUnit compilationUnit; |
||||
|
||||
void CSharpParseButtonClick(object sender, EventArgs e) |
||||
{ |
||||
CSharpParser parser = new CSharpParser(); |
||||
compilationUnit = parser.Parse(new StringReader(csharpCodeTextBox.Text)); |
||||
csharpTreeView.Nodes.Clear(); |
||||
foreach (var element in compilationUnit.Children) { |
||||
csharpTreeView.Nodes.Add(MakeTreeNode(element)); |
||||
} |
||||
SelectCurrentNode(csharpTreeView.Nodes); |
||||
resolveButton.Enabled = true; |
||||
} |
||||
|
||||
TreeNode MakeTreeNode(AstNode node) |
||||
{ |
||||
TreeNode t = new TreeNode(GetNodeTitle(node)); |
||||
t.Tag = node; |
||||
foreach (AstNode child in node.Children) { |
||||
t.Nodes.Add(MakeTreeNode(child)); |
||||
} |
||||
return t; |
||||
} |
||||
|
||||
string GetNodeTitle(AstNode node) |
||||
{ |
||||
StringBuilder b = new StringBuilder(); |
||||
b.Append(node.Role.ToString()); |
||||
b.Append(": "); |
||||
b.Append(node.GetType().Name); |
||||
bool hasProperties = false; |
||||
foreach (PropertyInfo p in node.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { |
||||
if (p.Name == "NodeType" || p.Name == "IsNull") |
||||
continue; |
||||
if (p.PropertyType == typeof(string) || p.PropertyType.IsEnum || p.PropertyType == typeof(bool)) { |
||||
if (!hasProperties) { |
||||
hasProperties = true; |
||||
b.Append(" ("); |
||||
} else { |
||||
b.Append(", "); |
||||
} |
||||
b.Append(p.Name); |
||||
b.Append(" = "); |
||||
try { |
||||
object val = p.GetValue(node, null); |
||||
b.Append(val != null ? val.ToString() : "**null**"); |
||||
} catch (TargetInvocationException ex) { |
||||
b.Append("**" + ex.InnerException.GetType().Name + "**"); |
||||
} |
||||
} |
||||
} |
||||
if (hasProperties) |
||||
b.Append(")"); |
||||
return b.ToString(); |
||||
} |
||||
|
||||
bool SelectCurrentNode(TreeNodeCollection c) |
||||
{ |
||||
int selectionStart = csharpCodeTextBox.SelectionStart; |
||||
int selectionEnd = selectionStart + csharpCodeTextBox.SelectionLength; |
||||
foreach (TreeNode t in c) { |
||||
AstNode node = t.Tag as AstNode; |
||||
if (node != null |
||||
&& selectionStart >= GetOffset(csharpCodeTextBox, node.StartLocation) |
||||
&& selectionEnd <= GetOffset(csharpCodeTextBox, node.EndLocation)) |
||||
{ |
||||
if (selectionStart == selectionEnd |
||||
&& (selectionStart == GetOffset(csharpCodeTextBox, node.StartLocation) |
||||
|| selectionStart == GetOffset(csharpCodeTextBox, node.EndLocation))) |
||||
{ |
||||
// caret is on border of this node; don't expand
|
||||
csharpTreeView.SelectedNode = t; |
||||
} else { |
||||
t.Expand(); |
||||
if (!SelectCurrentNode(t.Nodes)) |
||||
csharpTreeView.SelectedNode = t; |
||||
} |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
void CSharpGenerateCodeButtonClick(object sender, EventArgs e) |
||||
{ |
||||
StringWriter w = new StringWriter(); |
||||
OutputVisitor output = new OutputVisitor(w, new CSharpFormattingPolicy()); |
||||
compilationUnit.AcceptVisitor(output, null); |
||||
csharpCodeTextBox.Text = w.ToString(); |
||||
} |
||||
|
||||
int GetOffset(TextBox textBox, AstLocation location) |
||||
{ |
||||
return textBox.GetFirstCharIndexFromLine(location.Line - 1) + location.Column - 1; |
||||
} |
||||
|
||||
void CSharpTreeViewAfterSelect(object sender, TreeViewEventArgs e) |
||||
{ |
||||
AstNode node = e.Node.Tag as AstNode; |
||||
if (node != null) { |
||||
int startOffset = GetOffset(csharpCodeTextBox, node.StartLocation); |
||||
int endOffset = GetOffset(csharpCodeTextBox, node.EndLocation); |
||||
csharpCodeTextBox.Select(startOffset, endOffset - startOffset); |
||||
} |
||||
} |
||||
|
||||
Lazy<IList<IProjectContent>> builtInLibs = new Lazy<IList<IProjectContent>>( |
||||
delegate { |
||||
Assembly[] assemblies = { |
||||
typeof(object).Assembly, // mscorlib
|
||||
typeof(Uri).Assembly, // System.dll
|
||||
typeof(System.Linq.Enumerable).Assembly, // System.Core.dll
|
||||
// typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
|
||||
// typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll
|
||||
// typeof(Form).Assembly, // System.Windows.Forms.dll
|
||||
typeof(ICSharpCode.NRefactory.TypeSystem.IProjectContent).Assembly, |
||||
}; |
||||
IProjectContent[] projectContents = new IProjectContent[assemblies.Length]; |
||||
Stopwatch total = Stopwatch.StartNew(); |
||||
Parallel.For( |
||||
0, assemblies.Length, |
||||
delegate (int i) { |
||||
Stopwatch w = Stopwatch.StartNew(); |
||||
CecilLoader loader = new CecilLoader(); |
||||
projectContents[i] = loader.LoadAssemblyFile(assemblies[i].Location); |
||||
Debug.WriteLine(Path.GetFileName(assemblies[i].Location) + ": " + w.Elapsed); |
||||
}); |
||||
Debug.WriteLine("Total: " + total.Elapsed); |
||||
return projectContents; |
||||
}); |
||||
|
||||
void ResolveButtonClick(object sender, EventArgs e) |
||||
{ |
||||
SimpleProjectContent project = new SimpleProjectContent(); |
||||
TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(project, "dummy.cs"); |
||||
compilationUnit.AcceptVisitor(convertVisitor, null); |
||||
project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null); |
||||
|
||||
List<ITypeResolveContext> projects = new List<ITypeResolveContext>(); |
||||
projects.Add(project); |
||||
projects.AddRange(builtInLibs.Value); |
||||
|
||||
using (var context = new CompositeTypeResolveContext(projects).Synchronize()) { |
||||
CSharpResolver resolver = new CSharpResolver(context); |
||||
|
||||
IResolveVisitorNavigator navigator = null; |
||||
if (csharpTreeView.SelectedNode != null) { |
||||
navigator = new NodeListResolveVisitorNavigator(new[] { (AstNode)csharpTreeView.SelectedNode.Tag }); |
||||
} |
||||
ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile, navigator); |
||||
visitor.Scan(compilationUnit); |
||||
csharpTreeView.BeginUpdate(); |
||||
ShowResolveResultsInTree(csharpTreeView.Nodes, visitor); |
||||
csharpTreeView.EndUpdate(); |
||||
} |
||||
} |
||||
|
||||
void ShowResolveResultsInTree(TreeNodeCollection c, ResolveVisitor v) |
||||
{ |
||||
foreach (TreeNode t in c) { |
||||
AstNode node = t.Tag as AstNode; |
||||
if (node != null) { |
||||
ResolveResult rr = v.GetResolveResult(node); |
||||
if (rr != null) |
||||
t.Text = GetNodeTitle(node) + " " + rr.ToString(); |
||||
else |
||||
t.Text = GetNodeTitle(node); |
||||
} |
||||
ShowResolveResultsInTree(t.Nodes, v); |
||||
} |
||||
} |
||||
|
||||
void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e) |
||||
{ |
||||
if (e.Control && e.KeyCode == Keys.A) { |
||||
e.Handled = true; |
||||
csharpCodeTextBox.SelectAll(); |
||||
} |
||||
} |
||||
|
||||
void CsharpCodeTextBoxTextChanged(object sender, EventArgs e) |
||||
{ |
||||
resolveButton.Enabled = false; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,123 @@
@@ -0,0 +1,123 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<root> |
||||
<!-- |
||||
Microsoft ResX Schema |
||||
|
||||
Version 2.0 |
||||
|
||||
The primary goals of this format is to allow a simple XML format |
||||
that is mostly human readable. The generation and parsing of the |
||||
various data types are done through the TypeConverter classes |
||||
associated with the data types. |
||||
|
||||
Example: |
||||
|
||||
... ado.net/XML headers & schema ... |
||||
<resheader name="resmimetype">text/microsoft-resx</resheader> |
||||
<resheader name="version">2.0</resheader> |
||||
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> |
||||
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> |
||||
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> |
||||
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> |
||||
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> |
||||
<value>[base64 mime encoded serialized .NET Framework object]</value> |
||||
</data> |
||||
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> |
||||
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> |
||||
<comment>This is a comment</comment> |
||||
</data> |
||||
|
||||
There are any number of "resheader" rows that contain simple |
||||
name/value pairs. |
||||
|
||||
Each data row contains a name, and value. The row also contains a |
||||
type or mimetype. Type corresponds to a .NET class that support |
||||
text/value conversion through the TypeConverter architecture. |
||||
Classes that don't support this are serialized and stored with the |
||||
mimetype set. |
||||
|
||||
The mimetype is used for serialized objects, and tells the |
||||
ResXResourceReader how to depersist the object. This is currently not |
||||
extensible. For a given mimetype the value must be set accordingly: |
||||
|
||||
Note - application/x-microsoft.net.object.binary.base64 is the format |
||||
that the ResXResourceWriter will generate, however the reader can |
||||
read any of the formats listed below. |
||||
|
||||
mimetype: application/x-microsoft.net.object.binary.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.soap.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.bytearray.base64 |
||||
value : The object must be serialized into a byte array |
||||
: using a System.ComponentModel.TypeConverter |
||||
: and then encoded with base64 encoding. |
||||
--> |
||||
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> |
||||
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> |
||||
<xsd:element name="root" msdata:IsDataSet="true"> |
||||
<xsd:complexType> |
||||
<xsd:choice maxOccurs="unbounded"> |
||||
<xsd:element name="metadata"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" use="required" type="xsd:string" /> |
||||
<xsd:attribute name="type" type="xsd:string" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="assembly"> |
||||
<xsd:complexType> |
||||
<xsd:attribute name="alias" type="xsd:string" /> |
||||
<xsd:attribute name="name" type="xsd:string" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="data"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> |
||||
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="resheader"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:choice> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:schema> |
||||
<resheader name="resmimetype"> |
||||
<value>text/microsoft-resx</value> |
||||
</resheader> |
||||
<resheader name="version"> |
||||
<value>2.0</value> |
||||
</resheader> |
||||
<resheader name="reader"> |
||||
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
<resheader name="writer"> |
||||
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
<metadata name="miniToolStrip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> |
||||
<value>17, 17</value> |
||||
</metadata> |
||||
</root> |
||||
@ -0,0 +1,25 @@
@@ -0,0 +1,25 @@
|
||||
// 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.Windows.Forms; |
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
/// <summary>
|
||||
/// Class with program entry point.
|
||||
/// </summary>
|
||||
internal sealed class Program |
||||
{ |
||||
/// <summary>
|
||||
/// Program entry point.
|
||||
/// </summary>
|
||||
[STAThread] |
||||
private static void Main(string[] args) |
||||
{ |
||||
Application.EnableVisualStyles(); |
||||
Application.SetCompatibleTextRenderingDefault(false); |
||||
Application.Run(new MainForm()); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,31 @@
@@ -0,0 +1,31 @@
|
||||
#region Using directives
|
||||
|
||||
using System; |
||||
using System.Reflection; |
||||
using System.Runtime.InteropServices; |
||||
|
||||
#endregion
|
||||
|
||||
// General Information about an assembly is controlled through the following
|
||||
// set of attributes. Change these attribute values to modify the information
|
||||
// associated with an assembly.
|
||||
[assembly: AssemblyTitle("ICSharpCode.NRefactory.Demo")] |
||||
[assembly: AssemblyDescription("")] |
||||
[assembly: AssemblyConfiguration("")] |
||||
[assembly: AssemblyCompany("")] |
||||
[assembly: AssemblyProduct("ICSharpCode.NRefactory.Demo")] |
||||
[assembly: AssemblyCopyright("Copyright 2010")] |
||||
[assembly: AssemblyTrademark("")] |
||||
[assembly: AssemblyCulture("")] |
||||
|
||||
// This sets the default COM visibility of types in the assembly to invisible.
|
||||
// If you need to expose a type to COM, use [ComVisible(true)] on that type.
|
||||
[assembly: ComVisible(false)] |
||||
|
||||
// The assembly version has following format :
|
||||
//
|
||||
// Major.Minor.Build.Revision
|
||||
//
|
||||
// You can specify all the values or you can use the default the Revision and
|
||||
// Build Numbers by using the '*' as shown below:
|
||||
[assembly: AssemblyVersion("1.0.*")] |
||||
@ -0,0 +1,163 @@
@@ -0,0 +1,163 @@
|
||||
// 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)
|
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
partial class VBDemo |
||||
{ |
||||
/// <summary>
|
||||
/// Designer variable used to keep track of non-visual components.
|
||||
/// </summary>
|
||||
private System.ComponentModel.IContainer components = null; |
||||
|
||||
/// <summary>
|
||||
/// Disposes resources used by the control.
|
||||
/// </summary>
|
||||
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
||||
protected override void Dispose(bool disposing) |
||||
{ |
||||
if (disposing) { |
||||
if (components != null) { |
||||
components.Dispose(); |
||||
} |
||||
} |
||||
base.Dispose(disposing); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// This method is required for Windows Forms designer support.
|
||||
/// Do not change the method contents inside the source code editor. The Forms designer might
|
||||
/// not be able to load this method if it was changed manually.
|
||||
/// </summary>
|
||||
private void InitializeComponent() |
||||
{ |
||||
this.splitContainer1 = new System.Windows.Forms.SplitContainer(); |
||||
this.codeView = new System.Windows.Forms.TextBox(); |
||||
this.editNodeButton = new System.Windows.Forms.Button(); |
||||
this.clearSpecialsButton = new System.Windows.Forms.Button(); |
||||
this.syntaxTree = new ICSharpCode.NRefactory.Demo.VBDomView(); |
||||
this.generateCodeButton = new System.Windows.Forms.Button(); |
||||
this.parseButton = new System.Windows.Forms.Button(); |
||||
((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit(); |
||||
this.splitContainer1.Panel1.SuspendLayout(); |
||||
this.splitContainer1.Panel2.SuspendLayout(); |
||||
this.splitContainer1.SuspendLayout(); |
||||
this.SuspendLayout(); |
||||
//
|
||||
// splitContainer1
|
||||
//
|
||||
this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.splitContainer1.Location = new System.Drawing.Point(0, 0); |
||||
this.splitContainer1.Name = "splitContainer1"; |
||||
this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal; |
||||
//
|
||||
// splitContainer1.Panel1
|
||||
//
|
||||
this.splitContainer1.Panel1.Controls.Add(this.codeView); |
||||
//
|
||||
// splitContainer1.Panel2
|
||||
//
|
||||
this.splitContainer1.Panel2.Controls.Add(this.editNodeButton); |
||||
this.splitContainer1.Panel2.Controls.Add(this.clearSpecialsButton); |
||||
this.splitContainer1.Panel2.Controls.Add(this.syntaxTree); |
||||
this.splitContainer1.Panel2.Controls.Add(this.generateCodeButton); |
||||
this.splitContainer1.Panel2.Controls.Add(this.parseButton); |
||||
this.splitContainer1.Size = new System.Drawing.Size(462, 391); |
||||
this.splitContainer1.SplitterDistance = 173; |
||||
this.splitContainer1.TabIndex = 1; |
||||
//
|
||||
// codeView
|
||||
//
|
||||
this.codeView.AcceptsReturn = true; |
||||
this.codeView.AcceptsTab = true; |
||||
this.codeView.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.codeView.Font = new System.Drawing.Font("Courier New", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); |
||||
this.codeView.HideSelection = false; |
||||
this.codeView.Location = new System.Drawing.Point(0, 0); |
||||
this.codeView.Multiline = true; |
||||
this.codeView.Name = "codeView"; |
||||
this.codeView.ScrollBars = System.Windows.Forms.ScrollBars.Both; |
||||
this.codeView.Size = new System.Drawing.Size(462, 173); |
||||
this.codeView.TabIndex = 0; |
||||
this.codeView.Text = "Imports System\r\nClass Test\r\n Public Sub Main(ByVal args As String())\r\n " + |
||||
" Console.WriteLine(\"Hello, World\")\r\n End Sub\r\nEnd Class"; |
||||
this.codeView.WordWrap = false; |
||||
//
|
||||
// editNodeButton
|
||||
//
|
||||
this.editNodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.editNodeButton.Location = new System.Drawing.Point(331, 2); |
||||
this.editNodeButton.Name = "editNodeButton"; |
||||
this.editNodeButton.Size = new System.Drawing.Size(100, 23); |
||||
this.editNodeButton.TabIndex = 4; |
||||
this.editNodeButton.Text = "Edit node"; |
||||
this.editNodeButton.UseVisualStyleBackColor = true; |
||||
this.editNodeButton.Click += new System.EventHandler(this.EditNodeButtonClick); |
||||
//
|
||||
// clearSpecialsButton
|
||||
//
|
||||
this.clearSpecialsButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.clearSpecialsButton.Location = new System.Drawing.Point(225, 2); |
||||
this.clearSpecialsButton.Name = "clearSpecialsButton"; |
||||
this.clearSpecialsButton.Size = new System.Drawing.Size(100, 23); |
||||
this.clearSpecialsButton.TabIndex = 3; |
||||
this.clearSpecialsButton.Text = "Clear 0 specials"; |
||||
this.clearSpecialsButton.UseVisualStyleBackColor = true; |
||||
this.clearSpecialsButton.Click += new System.EventHandler(this.ClearSpecialsButtonClick); |
||||
//
|
||||
// syntaxTree
|
||||
//
|
||||
this.syntaxTree.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) |
||||
| System.Windows.Forms.AnchorStyles.Left) |
||||
| System.Windows.Forms.AnchorStyles.Right))); |
||||
this.syntaxTree.Location = new System.Drawing.Point(3, 32); |
||||
this.syntaxTree.Name = "syntaxTree"; |
||||
this.syntaxTree.Size = new System.Drawing.Size(459, 182); |
||||
this.syntaxTree.TabIndex = 2; |
||||
this.syntaxTree.Unit = null; |
||||
//
|
||||
// generateCodeButton
|
||||
//
|
||||
this.generateCodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.generateCodeButton.Location = new System.Drawing.Point(119, 2); |
||||
this.generateCodeButton.Name = "generateCodeButton"; |
||||
this.generateCodeButton.Size = new System.Drawing.Size(100, 23); |
||||
this.generateCodeButton.TabIndex = 1; |
||||
this.generateCodeButton.Text = "Generate"; |
||||
this.generateCodeButton.UseVisualStyleBackColor = true; |
||||
this.generateCodeButton.Click += new System.EventHandler(this.GenerateCodeButtonClick); |
||||
//
|
||||
// parseButton
|
||||
//
|
||||
this.parseButton.Anchor = System.Windows.Forms.AnchorStyles.Top; |
||||
this.parseButton.Location = new System.Drawing.Point(13, 2); |
||||
this.parseButton.Name = "parseButton"; |
||||
this.parseButton.Size = new System.Drawing.Size(100, 23); |
||||
this.parseButton.TabIndex = 0; |
||||
this.parseButton.Text = "Parse"; |
||||
this.parseButton.UseVisualStyleBackColor = true; |
||||
this.parseButton.Click += new System.EventHandler(this.ParseButtonClick); |
||||
//
|
||||
// VBDemo
|
||||
//
|
||||
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); |
||||
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; |
||||
this.Controls.Add(this.splitContainer1); |
||||
this.Name = "VBDemo"; |
||||
this.Size = new System.Drawing.Size(462, 391); |
||||
this.splitContainer1.Panel1.ResumeLayout(false); |
||||
this.splitContainer1.Panel1.PerformLayout(); |
||||
this.splitContainer1.Panel2.ResumeLayout(false); |
||||
((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit(); |
||||
this.splitContainer1.ResumeLayout(false); |
||||
this.ResumeLayout(false); |
||||
} |
||||
private System.Windows.Forms.Button clearSpecialsButton; |
||||
private System.Windows.Forms.Button editNodeButton; |
||||
private ICSharpCode.NRefactory.Demo.VBDomView syntaxTree; |
||||
private System.Windows.Forms.TextBox codeView; |
||||
private System.Windows.Forms.Button generateCodeButton; |
||||
private System.Windows.Forms.Button parseButton; |
||||
private System.Windows.Forms.SplitContainer splitContainer1; |
||||
} |
||||
} |
||||
@ -0,0 +1,78 @@
@@ -0,0 +1,78 @@
|
||||
// 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; |
||||
using System.ComponentModel; |
||||
using System.Drawing; |
||||
using System.IO; |
||||
using System.Linq; |
||||
using System.Windows.Forms; |
||||
using ICSharpCode.NRefactory.VB; |
||||
using ICSharpCode.NRefactory.VB.Parser; |
||||
using ICSharpCode.NRefactory.VB.PrettyPrinter; |
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
/// <summary>
|
||||
/// Description of VBDemo.
|
||||
/// </summary>
|
||||
public partial class VBDemo : UserControl |
||||
{ |
||||
public VBDemo() |
||||
{ |
||||
//
|
||||
// The InitializeComponent() call is required for Windows Forms designer support.
|
||||
//
|
||||
InitializeComponent(); |
||||
ParseButtonClick(null, null); |
||||
} |
||||
|
||||
IList<ISpecial> savedSpecials; |
||||
|
||||
void ParseButtonClick(object sender, EventArgs e) |
||||
{ |
||||
using (VBParser parser = new VBParser(new VBLexer(new StringReader(codeView.Text)))) { |
||||
parser.Parse(); |
||||
// this allows retrieving comments, preprocessor directives, etc. (stuff that isn't part of the syntax)
|
||||
SetSpecials(parser.Lexer.SpecialTracker.RetrieveSpecials()); |
||||
// this retrieves the root node of the result DOM
|
||||
if (parser.Errors.Count > 0) { |
||||
MessageBox.Show(parser.Errors.ErrorOutput); |
||||
} |
||||
syntaxTree.Unit = parser.CompilationUnit; |
||||
} |
||||
} |
||||
|
||||
void GenerateCodeButtonClick(object sender, EventArgs e) |
||||
{ |
||||
if (syntaxTree.Unit != null) { |
||||
VBNetOutputVisitor visitor = new VBNetOutputVisitor(); |
||||
// re-insert the comments we saved from the parser into the output
|
||||
using (SpecialNodesInserter.Install(savedSpecials, visitor)) { |
||||
syntaxTree.Unit.AcceptVisitor(visitor, null); |
||||
} |
||||
codeView.Text = visitor.Text.Replace("\t", " "); |
||||
} |
||||
} |
||||
|
||||
void ClearSpecialsButtonClick(object sender, EventArgs e) |
||||
{ |
||||
SetSpecials(new ISpecial[0]); |
||||
} |
||||
|
||||
void EditNodeButtonClick(object sender, EventArgs e) |
||||
{ |
||||
syntaxTree.EditSelectedNode(); |
||||
} |
||||
|
||||
void SetSpecials(IList<ISpecial> specials) |
||||
{ |
||||
savedSpecials = specials; |
||||
if (specials.Count == 1) |
||||
clearSpecialsButton.Text = "Clear 1 special"; |
||||
else |
||||
clearSpecialsButton.Text = "Clear " + specials.Count + " specials"; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,120 @@
@@ -0,0 +1,120 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<root> |
||||
<!-- |
||||
Microsoft ResX Schema |
||||
|
||||
Version 2.0 |
||||
|
||||
The primary goals of this format is to allow a simple XML format |
||||
that is mostly human readable. The generation and parsing of the |
||||
various data types are done through the TypeConverter classes |
||||
associated with the data types. |
||||
|
||||
Example: |
||||
|
||||
... ado.net/XML headers & schema ... |
||||
<resheader name="resmimetype">text/microsoft-resx</resheader> |
||||
<resheader name="version">2.0</resheader> |
||||
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> |
||||
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> |
||||
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> |
||||
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> |
||||
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> |
||||
<value>[base64 mime encoded serialized .NET Framework object]</value> |
||||
</data> |
||||
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> |
||||
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> |
||||
<comment>This is a comment</comment> |
||||
</data> |
||||
|
||||
There are any number of "resheader" rows that contain simple |
||||
name/value pairs. |
||||
|
||||
Each data row contains a name, and value. The row also contains a |
||||
type or mimetype. Type corresponds to a .NET class that support |
||||
text/value conversion through the TypeConverter architecture. |
||||
Classes that don't support this are serialized and stored with the |
||||
mimetype set. |
||||
|
||||
The mimetype is used for serialized objects, and tells the |
||||
ResXResourceReader how to depersist the object. This is currently not |
||||
extensible. For a given mimetype the value must be set accordingly: |
||||
|
||||
Note - application/x-microsoft.net.object.binary.base64 is the format |
||||
that the ResXResourceWriter will generate, however the reader can |
||||
read any of the formats listed below. |
||||
|
||||
mimetype: application/x-microsoft.net.object.binary.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.soap.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.bytearray.base64 |
||||
value : The object must be serialized into a byte array |
||||
: using a System.ComponentModel.TypeConverter |
||||
: and then encoded with base64 encoding. |
||||
--> |
||||
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> |
||||
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> |
||||
<xsd:element name="root" msdata:IsDataSet="true"> |
||||
<xsd:complexType> |
||||
<xsd:choice maxOccurs="unbounded"> |
||||
<xsd:element name="metadata"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" use="required" type="xsd:string" /> |
||||
<xsd:attribute name="type" type="xsd:string" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="assembly"> |
||||
<xsd:complexType> |
||||
<xsd:attribute name="alias" type="xsd:string" /> |
||||
<xsd:attribute name="name" type="xsd:string" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="data"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> |
||||
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="resheader"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:choice> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:schema> |
||||
<resheader name="resmimetype"> |
||||
<value>text/microsoft-resx</value> |
||||
</resheader> |
||||
<resheader name="version"> |
||||
<value>2.0</value> |
||||
</resheader> |
||||
<resheader name="reader"> |
||||
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
<resheader name="writer"> |
||||
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
</root> |
||||
@ -0,0 +1,59 @@
@@ -0,0 +1,59 @@
|
||||
// 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)
|
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
partial class VBDomView : System.Windows.Forms.UserControl |
||||
{ |
||||
/// <summary>
|
||||
/// Designer variable used to keep track of non-visual components.
|
||||
/// </summary>
|
||||
private System.ComponentModel.IContainer components = null; |
||||
|
||||
/// <summary>
|
||||
/// Disposes resources used by the control.
|
||||
/// </summary>
|
||||
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
||||
protected override void Dispose(bool disposing) |
||||
{ |
||||
if (disposing) { |
||||
if (components != null) { |
||||
components.Dispose(); |
||||
} |
||||
} |
||||
base.Dispose(disposing); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// This method is required for Windows Forms designer support.
|
||||
/// Do not change the method contents inside the source code editor. The Forms designer might
|
||||
/// not be able to load this method if it was changed manually.
|
||||
/// </summary>
|
||||
private void InitializeComponent() |
||||
{ |
||||
this.tree = new System.Windows.Forms.TreeView(); |
||||
this.SuspendLayout(); |
||||
//
|
||||
// tree
|
||||
//
|
||||
this.tree.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.tree.HideSelection = false; |
||||
this.tree.Location = new System.Drawing.Point(0, 0); |
||||
this.tree.Name = "tree"; |
||||
this.tree.ShowRootLines = false; |
||||
this.tree.Size = new System.Drawing.Size(186, 182); |
||||
this.tree.TabIndex = 0; |
||||
this.tree.KeyDown += new System.Windows.Forms.KeyEventHandler(this.TreeKeyDown); |
||||
//
|
||||
// AstView
|
||||
//
|
||||
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); |
||||
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; |
||||
this.Controls.Add(this.tree); |
||||
this.Name = "AstView"; |
||||
this.Size = new System.Drawing.Size(186, 182); |
||||
this.ResumeLayout(false); |
||||
} |
||||
private System.Windows.Forms.TreeView tree; |
||||
} |
||||
} |
||||
@ -0,0 +1,225 @@
@@ -0,0 +1,225 @@
|
||||
// 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.Windows.Forms; |
||||
using System.Reflection; |
||||
|
||||
using ICSharpCode.NRefactory.VB.Dom; |
||||
using ICSharpCode.NRefactory.VB; |
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
public partial class VBDomView |
||||
{ |
||||
CompilationUnit unit; |
||||
|
||||
public CompilationUnit Unit { |
||||
get { |
||||
return unit; |
||||
} |
||||
set { |
||||
if (value != null) { |
||||
unit = value; |
||||
UpdateTree(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void UpdateTree() |
||||
{ |
||||
tree.Nodes.Clear(); |
||||
tree.Nodes.Add(new CollectionNode("CompilationUnit", unit.Children)); |
||||
tree.SelectedNode = tree.Nodes[0]; |
||||
} |
||||
|
||||
public VBDomView() |
||||
{ |
||||
InitializeComponent(); |
||||
} |
||||
|
||||
public void DeleteSelectedNode() |
||||
{ |
||||
if (tree.SelectedNode is ElementNode) { |
||||
INode element = (tree.SelectedNode as ElementNode).element; |
||||
if (tree.SelectedNode.Parent is CollectionNode) { |
||||
if (MessageBox.Show("Remove selected node from parent collection?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question) |
||||
== DialogResult.Yes) |
||||
{ |
||||
IList col = (tree.SelectedNode.Parent as CollectionNode).collection; |
||||
col.Remove(element); |
||||
(tree.SelectedNode.Parent as CollectionNode).Update(); |
||||
} |
||||
} else if (tree.SelectedNode.Parent is ElementNode) { |
||||
if (MessageBox.Show("Set selected property to null?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question) |
||||
== DialogResult.Yes) |
||||
{ |
||||
// get parent element
|
||||
element = (tree.SelectedNode.Parent as ElementNode).element; |
||||
string propertyName = (string)tree.SelectedNode.Tag; |
||||
element.GetType().GetProperty(propertyName).SetValue(element, null, null); |
||||
(tree.SelectedNode.Parent as ElementNode).Update(); |
||||
} |
||||
} |
||||
} else if (tree.SelectedNode is CollectionNode) { |
||||
if (MessageBox.Show("Remove all elements from selected collection?", "Clear collection", MessageBoxButtons.YesNo, MessageBoxIcon.Question) |
||||
== DialogResult.Yes) |
||||
{ |
||||
IList col = (tree.SelectedNode as CollectionNode).collection; |
||||
col.Clear(); |
||||
(tree.SelectedNode as CollectionNode).Update(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public void EditSelectedNode() |
||||
{ |
||||
TreeNode node = tree.SelectedNode; |
||||
while (!(node is ElementNode)) { |
||||
if (node == null) { |
||||
return; |
||||
} |
||||
node = node.Parent; |
||||
} |
||||
INode element = ((ElementNode)node).element; |
||||
using (VBEditDialog dlg = new VBEditDialog(element)) { |
||||
dlg.ShowDialog(); |
||||
} |
||||
((ElementNode)node).Update(); |
||||
} |
||||
|
||||
public void ApplyTransformation(IDomVisitor visitor) |
||||
{ |
||||
if (tree.SelectedNode == tree.Nodes[0]) { |
||||
unit.AcceptVisitor(visitor, null); |
||||
UpdateTree(); |
||||
} else { |
||||
string name = visitor.GetType().Name; |
||||
ElementNode elementNode = tree.SelectedNode as ElementNode; |
||||
CollectionNode collectionNode = tree.SelectedNode as CollectionNode; |
||||
if (elementNode != null) { |
||||
if (MessageBox.Show(("Apply " + name + " to selected element '" + elementNode.Text + "'?"), |
||||
"Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question) |
||||
== DialogResult.Yes) |
||||
{ |
||||
elementNode.element.AcceptVisitor(visitor, null); |
||||
elementNode.Update(); |
||||
} |
||||
} else if (collectionNode != null) { |
||||
if (MessageBox.Show(("Apply " + name + " to all elements in selected collection '" + collectionNode.Text + "'?"), |
||||
"Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question) |
||||
== DialogResult.Yes) |
||||
{ |
||||
foreach (TreeNode subNode in collectionNode.Nodes) { |
||||
if (subNode is ElementNode) { |
||||
(subNode as ElementNode).element.AcceptVisitor(visitor, null); |
||||
} |
||||
} |
||||
collectionNode.Update(); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
static TreeNode CreateNode(object child) |
||||
{ |
||||
if (child == null) { |
||||
return new TreeNode("*null reference*"); |
||||
} else if (child is INode) { |
||||
return new ElementNode(child as INode); |
||||
} else { |
||||
return new TreeNode(child.ToString()); |
||||
} |
||||
} |
||||
|
||||
class CollectionNode : TreeNode |
||||
{ |
||||
internal IList collection; |
||||
string baseName; |
||||
|
||||
public CollectionNode(string text, IList children) : base(text) |
||||
{ |
||||
this.baseName = text; |
||||
this.collection = children; |
||||
Update(); |
||||
} |
||||
|
||||
public void Update() |
||||
{ |
||||
if (collection.Count == 0) { |
||||
Text = baseName + " (empty collection)"; |
||||
} else if (collection.Count == 1) { |
||||
Text = baseName + " (collection with 1 element)"; |
||||
} else { |
||||
Text = baseName + " (collection with " + collection.Count + " elements)"; |
||||
} |
||||
Nodes.Clear(); |
||||
foreach (object child in collection) { |
||||
Nodes.Add(CreateNode(child)); |
||||
} |
||||
Expand(); |
||||
} |
||||
} |
||||
|
||||
class ElementNode : TreeNode |
||||
{ |
||||
internal INode element; |
||||
|
||||
public ElementNode(INode node) |
||||
{ |
||||
this.element = node; |
||||
Update(); |
||||
} |
||||
|
||||
public void Update() |
||||
{ |
||||
Nodes.Clear(); |
||||
Type type = element.GetType(); |
||||
Text = type.Name; |
||||
if (Tag != null) { // HACK: after editing property element
|
||||
Text = Tag.ToString() + " = " + Text; |
||||
} |
||||
if (!(element is INullable && (element as INullable).IsNull)) { |
||||
AddProperties(type, element); |
||||
if (element.Children.Count > 0) { |
||||
Nodes.Add(new CollectionNode("Children", element.Children)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void AddProperties(Type type, INode node) |
||||
{ |
||||
if (type == typeof(AbstractNode)) |
||||
return; |
||||
foreach (PropertyInfo pi in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { |
||||
if (pi.DeclaringType != type) // don't add derived properties
|
||||
continue; |
||||
if (pi.Name == "IsNull") |
||||
continue; |
||||
object value = pi.GetValue(node, null); |
||||
if (value is IList) { |
||||
Nodes.Add(new CollectionNode(pi.Name, (IList)value)); |
||||
} else if (value is string) { |
||||
Text += " " + pi.Name + "='" + value + "'"; |
||||
} else { |
||||
TreeNode treeNode = CreateNode(value); |
||||
treeNode.Text = pi.Name + " = " + treeNode.Text; |
||||
treeNode.Tag = pi.Name; |
||||
Nodes.Add(treeNode); |
||||
} |
||||
} |
||||
AddProperties(type.BaseType, node); |
||||
} |
||||
} |
||||
|
||||
void TreeKeyDown(object sender, KeyEventArgs e) |
||||
{ |
||||
if (e.KeyData == Keys.Delete) { |
||||
DeleteSelectedNode(); |
||||
} else if (e.KeyData == Keys.Space || e.KeyData == Keys.Enter) { |
||||
EditSelectedNode(); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,120 @@
@@ -0,0 +1,120 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<root> |
||||
<!-- |
||||
Microsoft ResX Schema |
||||
|
||||
Version 2.0 |
||||
|
||||
The primary goals of this format is to allow a simple XML format |
||||
that is mostly human readable. The generation and parsing of the |
||||
various data types are done through the TypeConverter classes |
||||
associated with the data types. |
||||
|
||||
Example: |
||||
|
||||
... ado.net/XML headers & schema ... |
||||
<resheader name="resmimetype">text/microsoft-resx</resheader> |
||||
<resheader name="version">2.0</resheader> |
||||
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> |
||||
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> |
||||
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> |
||||
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> |
||||
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> |
||||
<value>[base64 mime encoded serialized .NET Framework object]</value> |
||||
</data> |
||||
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> |
||||
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> |
||||
<comment>This is a comment</comment> |
||||
</data> |
||||
|
||||
There are any number of "resheader" rows that contain simple |
||||
name/value pairs. |
||||
|
||||
Each data row contains a name, and value. The row also contains a |
||||
type or mimetype. Type corresponds to a .NET class that support |
||||
text/value conversion through the TypeConverter architecture. |
||||
Classes that don't support this are serialized and stored with the |
||||
mimetype set. |
||||
|
||||
The mimetype is used for serialized objects, and tells the |
||||
ResXResourceReader how to depersist the object. This is currently not |
||||
extensible. For a given mimetype the value must be set accordingly: |
||||
|
||||
Note - application/x-microsoft.net.object.binary.base64 is the format |
||||
that the ResXResourceWriter will generate, however the reader can |
||||
read any of the formats listed below. |
||||
|
||||
mimetype: application/x-microsoft.net.object.binary.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.soap.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.bytearray.base64 |
||||
value : The object must be serialized into a byte array |
||||
: using a System.ComponentModel.TypeConverter |
||||
: and then encoded with base64 encoding. |
||||
--> |
||||
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> |
||||
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> |
||||
<xsd:element name="root" msdata:IsDataSet="true"> |
||||
<xsd:complexType> |
||||
<xsd:choice maxOccurs="unbounded"> |
||||
<xsd:element name="metadata"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" use="required" type="xsd:string" /> |
||||
<xsd:attribute name="type" type="xsd:string" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="assembly"> |
||||
<xsd:complexType> |
||||
<xsd:attribute name="alias" type="xsd:string" /> |
||||
<xsd:attribute name="name" type="xsd:string" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="data"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> |
||||
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="resheader"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:choice> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:schema> |
||||
<resheader name="resmimetype"> |
||||
<value>text/microsoft-resx</value> |
||||
</resheader> |
||||
<resheader name="version"> |
||||
<value>2.0</value> |
||||
</resheader> |
||||
<resheader name="reader"> |
||||
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
<resheader name="writer"> |
||||
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
</root> |
||||
@ -0,0 +1,88 @@
@@ -0,0 +1,88 @@
|
||||
// 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)
|
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
partial class VBEditDialog : System.Windows.Forms.Form |
||||
{ |
||||
/// <summary>
|
||||
/// Designer variable used to keep track of non-visual components.
|
||||
/// </summary>
|
||||
private System.ComponentModel.IContainer components = null; |
||||
|
||||
/// <summary>
|
||||
/// Disposes resources used by the form.
|
||||
/// </summary>
|
||||
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
||||
protected override void Dispose(bool disposing) |
||||
{ |
||||
if (disposing) { |
||||
if (components != null) { |
||||
components.Dispose(); |
||||
} |
||||
} |
||||
base.Dispose(disposing); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// This method is required for Windows Forms designer support.
|
||||
/// Do not change the method contents inside the source code editor. The Forms designer might
|
||||
/// not be able to load this method if it was changed manually.
|
||||
/// </summary>
|
||||
private void InitializeComponent() |
||||
{ |
||||
this.propertyGrid = new System.Windows.Forms.PropertyGrid(); |
||||
this.panel1 = new System.Windows.Forms.Panel(); |
||||
this.okButton = new System.Windows.Forms.Button(); |
||||
this.panel1.SuspendLayout(); |
||||
this.SuspendLayout(); |
||||
//
|
||||
// propertyGrid
|
||||
//
|
||||
this.propertyGrid.Dock = System.Windows.Forms.DockStyle.Fill; |
||||
this.propertyGrid.HelpVisible = false; |
||||
this.propertyGrid.Location = new System.Drawing.Point(0, 0); |
||||
this.propertyGrid.Name = "propertyGrid"; |
||||
this.propertyGrid.PropertySort = System.Windows.Forms.PropertySort.Alphabetical; |
||||
this.propertyGrid.Size = new System.Drawing.Size(477, 436); |
||||
this.propertyGrid.TabIndex = 0; |
||||
this.propertyGrid.ToolbarVisible = false; |
||||
//
|
||||
// panel1
|
||||
//
|
||||
this.panel1.Controls.Add(this.okButton); |
||||
this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom; |
||||
this.panel1.Location = new System.Drawing.Point(0, 436); |
||||
this.panel1.Name = "panel1"; |
||||
this.panel1.Size = new System.Drawing.Size(477, 38); |
||||
this.panel1.TabIndex = 1; |
||||
//
|
||||
// okButton
|
||||
//
|
||||
this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); |
||||
this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; |
||||
this.okButton.Location = new System.Drawing.Point(390, 6); |
||||
this.okButton.Name = "okButton"; |
||||
this.okButton.Size = new System.Drawing.Size(75, 23); |
||||
this.okButton.TabIndex = 0; |
||||
this.okButton.Text = "OK"; |
||||
this.okButton.UseVisualStyleBackColor = true; |
||||
//
|
||||
// EditDialog
|
||||
//
|
||||
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); |
||||
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; |
||||
this.CancelButton = this.okButton; |
||||
this.ClientSize = new System.Drawing.Size(477, 474); |
||||
this.Controls.Add(this.propertyGrid); |
||||
this.Controls.Add(this.panel1); |
||||
this.Name = "EditDialog"; |
||||
this.Text = "EditDialog"; |
||||
this.panel1.ResumeLayout(false); |
||||
this.ResumeLayout(false); |
||||
} |
||||
private System.Windows.Forms.PropertyGrid propertyGrid; |
||||
private System.Windows.Forms.Button okButton; |
||||
private System.Windows.Forms.Panel panel1; |
||||
} |
||||
} |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
// 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.Drawing; |
||||
using System.Windows.Forms; |
||||
|
||||
namespace ICSharpCode.NRefactory.Demo |
||||
{ |
||||
public partial class VBEditDialog |
||||
{ |
||||
public VBEditDialog(object element) |
||||
{ |
||||
InitializeComponent(); |
||||
propertyGrid.SelectedObject = element; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,120 @@
@@ -0,0 +1,120 @@
|
||||
<?xml version="1.0" encoding="utf-8"?> |
||||
<root> |
||||
<!-- |
||||
Microsoft ResX Schema |
||||
|
||||
Version 2.0 |
||||
|
||||
The primary goals of this format is to allow a simple XML format |
||||
that is mostly human readable. The generation and parsing of the |
||||
various data types are done through the TypeConverter classes |
||||
associated with the data types. |
||||
|
||||
Example: |
||||
|
||||
... ado.net/XML headers & schema ... |
||||
<resheader name="resmimetype">text/microsoft-resx</resheader> |
||||
<resheader name="version">2.0</resheader> |
||||
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> |
||||
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> |
||||
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> |
||||
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> |
||||
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> |
||||
<value>[base64 mime encoded serialized .NET Framework object]</value> |
||||
</data> |
||||
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> |
||||
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> |
||||
<comment>This is a comment</comment> |
||||
</data> |
||||
|
||||
There are any number of "resheader" rows that contain simple |
||||
name/value pairs. |
||||
|
||||
Each data row contains a name, and value. The row also contains a |
||||
type or mimetype. Type corresponds to a .NET class that support |
||||
text/value conversion through the TypeConverter architecture. |
||||
Classes that don't support this are serialized and stored with the |
||||
mimetype set. |
||||
|
||||
The mimetype is used for serialized objects, and tells the |
||||
ResXResourceReader how to depersist the object. This is currently not |
||||
extensible. For a given mimetype the value must be set accordingly: |
||||
|
||||
Note - application/x-microsoft.net.object.binary.base64 is the format |
||||
that the ResXResourceWriter will generate, however the reader can |
||||
read any of the formats listed below. |
||||
|
||||
mimetype: application/x-microsoft.net.object.binary.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.soap.base64 |
||||
value : The object must be serialized with |
||||
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter |
||||
: and then encoded with base64 encoding. |
||||
|
||||
mimetype: application/x-microsoft.net.object.bytearray.base64 |
||||
value : The object must be serialized into a byte array |
||||
: using a System.ComponentModel.TypeConverter |
||||
: and then encoded with base64 encoding. |
||||
--> |
||||
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> |
||||
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> |
||||
<xsd:element name="root" msdata:IsDataSet="true"> |
||||
<xsd:complexType> |
||||
<xsd:choice maxOccurs="unbounded"> |
||||
<xsd:element name="metadata"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" use="required" type="xsd:string" /> |
||||
<xsd:attribute name="type" type="xsd:string" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="assembly"> |
||||
<xsd:complexType> |
||||
<xsd:attribute name="alias" type="xsd:string" /> |
||||
<xsd:attribute name="name" type="xsd:string" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="data"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> |
||||
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> |
||||
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> |
||||
<xsd:attribute ref="xml:space" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
<xsd:element name="resheader"> |
||||
<xsd:complexType> |
||||
<xsd:sequence> |
||||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
||||
</xsd:sequence> |
||||
<xsd:attribute name="name" type="xsd:string" use="required" /> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:choice> |
||||
</xsd:complexType> |
||||
</xsd:element> |
||||
</xsd:schema> |
||||
<resheader name="resmimetype"> |
||||
<value>text/microsoft-resx</value> |
||||
</resheader> |
||||
<resheader name="version"> |
||||
<value>2.0</value> |
||||
</resheader> |
||||
<resheader name="reader"> |
||||
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
<resheader name="writer"> |
||||
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
||||
</resheader> |
||||
</root> |
||||
@ -0,0 +1,3 @@
@@ -0,0 +1,3 @@
|
||||
|
||||
bin/ |
||||
obj/ |
||||
@ -0,0 +1,31 @@
@@ -0,0 +1,31 @@
|
||||
// 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.Reflection; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp |
||||
{ |
||||
[TestFixture] |
||||
public class AstStructureTest |
||||
{ |
||||
[Test] |
||||
public void RolesAreStaticReadOnly() |
||||
{ |
||||
foreach (Type type in typeof(AstNode).Assembly.GetExportedTypes()) { |
||||
if (type.IsSubclassOf(typeof(AstNode))) { |
||||
foreach (FieldInfo field in type.GetFields()) { |
||||
if (field.FieldType.IsSubclassOf(typeof(Role))) { |
||||
Assert.IsTrue(field.IsPublic); |
||||
Assert.IsTrue(field.IsStatic); |
||||
Assert.IsTrue(field.IsInitOnly); |
||||
Assert.IsTrue(field.Name.EndsWith("Role", StringComparison.Ordinal)); |
||||
Assert.IsNotNull(field.GetValue(null)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@
@@ -0,0 +1,36 @@
|
||||
// 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.IO; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class AliasReferenceExpressionTests |
||||
{ |
||||
[Test, Ignore] |
||||
public void GlobalReferenceExpressionTest() |
||||
{ |
||||
CSharpParser parser = new CSharpParser(); |
||||
parser.ParseTypeReference(new StringReader("global::System")); |
||||
//Assert.IsTrue(tre.TypeReference.IsGlobal);
|
||||
//Assert.AreEqual("System", tre.TypeReference.Type);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void GlobalTypeDeclaration() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("global::System.String a;"); |
||||
//TypeReference typeRef = lvd.GetTypeForVariable(0);
|
||||
//Assert.IsTrue(typeRef.IsGlobal);
|
||||
//Assert.AreEqual("System.String", typeRef.Type);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
// TODO: add tests for aliases other than 'global'
|
||||
} |
||||
} |
||||
@ -0,0 +1,55 @@
@@ -0,0 +1,55 @@
|
||||
// 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.IO; |
||||
using System.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class AnonymousMethodTests |
||||
{ |
||||
AnonymousMethodExpression Parse(string expression) |
||||
{ |
||||
return ParseUtilCSharp.ParseExpression<AnonymousMethodExpression>(expression); |
||||
} |
||||
|
||||
[Test] |
||||
public void AnonymousMethodWithoutParameterList() |
||||
{ |
||||
AnonymousMethodExpression ame = Parse("delegate {}"); |
||||
Assert.AreEqual(0, ame.Parameters.Count()); |
||||
Assert.AreEqual(0, ame.Body.Statements.Count()); |
||||
Assert.IsFalse(ame.HasParameterList); |
||||
} |
||||
|
||||
[Test] |
||||
public void AnonymousMethodAfterCast() |
||||
{ |
||||
CastExpression c = ParseUtilCSharp.ParseExpression<CastExpression>("(ThreadStart)delegate {}"); |
||||
AnonymousMethodExpression ame = (AnonymousMethodExpression)c.Expression; |
||||
Assert.AreEqual(0, ame.Parameters.Count()); |
||||
Assert.AreEqual(0, ame.Body.Statements.Count()); |
||||
} |
||||
|
||||
[Test, Ignore("Parameter list is broken")] |
||||
public void EmptyAnonymousMethod() |
||||
{ |
||||
AnonymousMethodExpression ame = Parse("delegate() {}"); |
||||
Assert.AreEqual(0, ame.Parameters.Count()); |
||||
Assert.AreEqual(0, ame.Body.Statements.Count()); |
||||
Assert.IsTrue(ame.HasParameterList); |
||||
} |
||||
|
||||
[Test, Ignore("Parameter list is broken")] |
||||
public void SimpleAnonymousMethod() |
||||
{ |
||||
AnonymousMethodExpression ame = Parse("delegate(int a, int b) { return a + b; }"); |
||||
Assert.AreEqual(2, ame.Parameters.Count()); |
||||
Assert.AreEqual(1, ame.Body.Statements.Count()); |
||||
Assert.IsTrue(ame.Body.Children.First() is ReturnStatement); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@
@@ -0,0 +1,36 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore("Needs to be ported to new NRefactory")] |
||||
public class ArrayObjectCreateExpressionTests |
||||
{ |
||||
[Test] |
||||
public void ArrayCreateExpressionTest1() |
||||
{ |
||||
/* |
||||
ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression<ArrayCreateExpression>("new int[5]"); |
||||
Assert.AreEqual("System.Int32", ace.CreateType.Type); |
||||
Assert.IsTrue(ace.CreateType.IsKeyword); |
||||
Assert.AreEqual(1, ace.Arguments.Count); |
||||
Assert.AreEqual(new int[] {0}, ace.CreateType.RankSpecifier); |
||||
*/ |
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitlyTypedArrayCreateExpression() |
||||
{ |
||||
/* |
||||
ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression<ArrayCreateExpression>("new[] { 1, 10, 100, 1000 }"); |
||||
Assert.AreEqual("", ace.CreateType.Type); |
||||
Assert.AreEqual(0, ace.Arguments.Count); |
||||
Assert.AreEqual(4, ace.ArrayInitializer.CreateExpressions.Count);*/ |
||||
throw new NotImplementedException(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,88 @@
@@ -0,0 +1,88 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class AssignmentExpressionTests |
||||
{ |
||||
void TestAssignmentExpression(string program, AssignmentOperatorType op) |
||||
{ |
||||
AssignmentExpression ae = ParseUtilCSharp.ParseExpression<AssignmentExpression>(program); |
||||
|
||||
Assert.AreEqual(op, ae.Operator); |
||||
|
||||
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 ModulusTest() |
||||
{ |
||||
TestAssignmentExpression("a %= b", AssignmentOperatorType.Modulus); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShiftLeftTest() |
||||
{ |
||||
TestAssignmentExpression("a <<= b", AssignmentOperatorType.ShiftLeft); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShiftRightTest() |
||||
{ |
||||
TestAssignmentExpression("a >>= b", AssignmentOperatorType.ShiftRight); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitwiseAndTest() |
||||
{ |
||||
TestAssignmentExpression("a &= b", AssignmentOperatorType.BitwiseAnd); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitwiseOrTest() |
||||
{ |
||||
TestAssignmentExpression("a |= b", AssignmentOperatorType.BitwiseOr); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExclusiveOrTest() |
||||
{ |
||||
TestAssignmentExpression("a ^= b", AssignmentOperatorType.ExclusiveOr); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class BaseReferenceExpressionTests |
||||
{ |
||||
[Test] |
||||
public void BaseReferenceExpressionTest1() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("base.myField"); |
||||
Assert.IsTrue(fre.Target is BaseReferenceExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,227 @@
@@ -0,0 +1,227 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class BinaryOperatorExpressionTests |
||||
{ |
||||
#region Precedence Tests
|
||||
void OperatorPrecedenceTest(string strongOperator, BinaryOperatorType strongOperatorType, |
||||
string weakOperator, BinaryOperatorType weakOperatorType, bool vb) |
||||
{ |
||||
string program = "a " + weakOperator + " b " + strongOperator + " c"; |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program); |
||||
Assert.AreEqual(weakOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
boe = (BinaryOperatorExpression)boe.Right; |
||||
Assert.AreEqual(strongOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
|
||||
program = "a " + strongOperator + " b " + weakOperator + " c"; |
||||
|
||||
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program); |
||||
Assert.AreEqual(weakOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
boe = (BinaryOperatorExpression)boe.Left; |
||||
Assert.AreEqual(strongOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
} |
||||
|
||||
void SameOperatorPrecedenceTest(string firstOperator, BinaryOperatorType firstOperatorType, |
||||
string secondOperator, BinaryOperatorType secondOperatorType, bool vb) |
||||
{ |
||||
string program = "a " + secondOperator + " b " + firstOperator + " c"; |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program); |
||||
Assert.AreEqual(firstOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
boe = (BinaryOperatorExpression)boe.Left; |
||||
Assert.AreEqual(secondOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
|
||||
program = "a " + firstOperator + " b " + secondOperator + " c"; |
||||
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program); |
||||
Assert.AreEqual(secondOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
boe = (BinaryOperatorExpression)boe.Left; |
||||
Assert.AreEqual(firstOperatorType, boe.Operator); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void OperatorPrecedenceTest() |
||||
{ |
||||
SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, false); |
||||
SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "%", BinaryOperatorType.Modulus, false); |
||||
OperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "+", BinaryOperatorType.Add, false); |
||||
SameOperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "+", BinaryOperatorType.Add, false); |
||||
OperatorPrecedenceTest("+", BinaryOperatorType.Add, "<<", BinaryOperatorType.ShiftLeft, false); |
||||
SameOperatorPrecedenceTest(">>", BinaryOperatorType.ShiftRight, "<<", BinaryOperatorType.ShiftLeft, false); |
||||
OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "==", BinaryOperatorType.Equality, false); |
||||
SameOperatorPrecedenceTest("!=", BinaryOperatorType.InEquality, "==", BinaryOperatorType.Equality, false); |
||||
OperatorPrecedenceTest("==", BinaryOperatorType.Equality, "&", BinaryOperatorType.BitwiseAnd, false); |
||||
OperatorPrecedenceTest("&", BinaryOperatorType.BitwiseAnd, "^", BinaryOperatorType.ExclusiveOr, false); |
||||
OperatorPrecedenceTest("^", BinaryOperatorType.ExclusiveOr, "|", BinaryOperatorType.BitwiseOr, false); |
||||
OperatorPrecedenceTest("|", BinaryOperatorType.BitwiseOr, "&&", BinaryOperatorType.LogicalAnd, false); |
||||
OperatorPrecedenceTest("&&", BinaryOperatorType.LogicalAnd, "||", BinaryOperatorType.LogicalOr, false); |
||||
OperatorPrecedenceTest("||", BinaryOperatorType.LogicalOr, "??", BinaryOperatorType.NullCoalescing, false); |
||||
} |
||||
#endregion
|
||||
|
||||
void TestBinaryOperatorExpressionTest(string program, BinaryOperatorType op) |
||||
{ |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program); |
||||
Assert.AreEqual(op, boe.Operator); |
||||
|
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
|
||||
} |
||||
|
||||
[Test] |
||||
public void SubtractionLeftToRight() |
||||
{ |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a - b - c"); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
Assert.IsTrue(boe.Left is BinaryOperatorExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullCoalescingRightToLeft() |
||||
{ |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a ?? b ?? c"); |
||||
Assert.IsTrue(boe.Left is IdentifierExpression); |
||||
Assert.IsTrue(boe.Right is BinaryOperatorExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitwiseAndTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitwiseOrTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr); |
||||
} |
||||
|
||||
[Test] |
||||
public void LogicalAndTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd); |
||||
} |
||||
|
||||
[Test] |
||||
public void LogicalOrTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExclusiveOrTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr); |
||||
} |
||||
|
||||
|
||||
[Test] |
||||
public void GreaterThanTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan); |
||||
} |
||||
|
||||
[Test] |
||||
public void GreaterThanOrEqualTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual); |
||||
} |
||||
|
||||
[Test] |
||||
public void EqualityTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality); |
||||
} |
||||
|
||||
[Test] |
||||
public void InEqualityTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality); |
||||
} |
||||
|
||||
[Test] |
||||
public void LessThanTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan); |
||||
} |
||||
|
||||
[Test] |
||||
public void LessThanOrEqualTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual); |
||||
} |
||||
|
||||
[Test] |
||||
public void AddTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add); |
||||
} |
||||
|
||||
[Test] |
||||
public void SubtractTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract); |
||||
} |
||||
|
||||
[Test] |
||||
public void MultiplyTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply); |
||||
} |
||||
|
||||
[Test] |
||||
public void DivideTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide); |
||||
} |
||||
|
||||
[Test] |
||||
public void ModulusTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShiftLeftTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShiftRightTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullCoalescingTest() |
||||
{ |
||||
TestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing); |
||||
} |
||||
|
||||
[Test] |
||||
public void LessThanOrGreaterTest() |
||||
{ |
||||
const string expr = "i1 < 0 || i1 > (Count - 1)"; |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(expr); |
||||
Assert.AreEqual(BinaryOperatorType.LogicalOr, boe.Operator); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,140 @@
@@ -0,0 +1,140 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore("Port unit tests to new DOM")] |
||||
public class CastExpressionTests |
||||
{ |
||||
/* |
||||
[Test] |
||||
public void SimpleCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyObject)o"); |
||||
Assert.AreEqual("MyObject", ce.CastTo.Type); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void ArrayCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType[])o"); |
||||
Assert.AreEqual("MyType", ce.CastTo.Type); |
||||
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullablePrimitiveCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(int?)o"); |
||||
Assert.AreEqual("System.Nullable", ce.CastTo.Type); |
||||
Assert.AreEqual("System.Int32", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType?)o"); |
||||
Assert.AreEqual("System.Nullable", ce.CastTo.Type); |
||||
Assert.AreEqual("MyType", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableTryCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("o as int?"); |
||||
Assert.AreEqual("System.Nullable", ce.CastTo.Type); |
||||
Assert.IsTrue(ce.CastTo.IsKeyword); |
||||
Assert.AreEqual("System.Int32", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.TryCast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(List<string>)o"); |
||||
Assert.AreEqual("List", ce.CastTo.Type); |
||||
Assert.AreEqual("System.String", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericArrayCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(List<string>[])o"); |
||||
Assert.AreEqual("List", ce.CastTo.Type); |
||||
Assert.AreEqual("System.String", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericArrayAsCastExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("o as List<string>[]"); |
||||
Assert.AreEqual("List", ce.CastTo.Type); |
||||
Assert.AreEqual("System.String", ce.CastTo.GenericTypes[0].Type); |
||||
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
Assert.AreEqual(CastType.TryCast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void CastMemberReferenceOnParenthesizedExpression() |
||||
{ |
||||
// yes, we really wanted to evaluate .Member on expr and THEN cast the result to MyType
|
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType)(expr).Member"); |
||||
Assert.AreEqual("MyType", ce.CastTo.Type); |
||||
Assert.IsTrue(ce.Expression is MemberReferenceExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void TryCastParenthesizedExpression() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(o) as string"); |
||||
Assert.AreEqual("System.String", ce.CastTo.ToString()); |
||||
Assert.IsTrue(ce.Expression is ParenthesizedExpression); |
||||
Assert.AreEqual(CastType.TryCast, ce.CastType); |
||||
} |
||||
|
||||
[Test] |
||||
public void CastNegation() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(uint)-negativeValue"); |
||||
Assert.AreEqual("System.UInt32", ce.CastTo.ToString()); |
||||
Assert.IsTrue(ce.Expression is UnaryOperatorExpression); |
||||
Assert.AreEqual(CastType.Cast, ce.CastType); |
||||
} |
||||
*/ |
||||
|
||||
[Test] |
||||
public void SubtractionIsNotCast() |
||||
{ |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("(BigInt)-negativeValue"); |
||||
Assert.IsTrue(boe.Left is ParenthesizedExpression); |
||||
Assert.IsTrue(boe.Right is IdentifierExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void IntMaxValueToBigInt() |
||||
{ |
||||
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(BigInt)int.MaxValue"); |
||||
Assert.AreEqual("BigInt", ce.CastTo.ToString()); |
||||
Assert.IsTrue(ce.Expression is MemberReferenceExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@
@@ -0,0 +1,26 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class CheckedExpressionTests |
||||
{ |
||||
[Test] |
||||
public void CheckedExpressionTest() |
||||
{ |
||||
CheckedExpression ce = ParseUtilCSharp.ParseExpression<CheckedExpression>("checked(a)"); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void UncheckedExpressionTest() |
||||
{ |
||||
UncheckedExpression ce = ParseUtilCSharp.ParseExpression<UncheckedExpression>("unchecked(a)"); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,104 @@
@@ -0,0 +1,104 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class ConditionalExpressionTests |
||||
{ |
||||
[Test] |
||||
public void ConditionalExpressionTest() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a == b ? a() : a.B"); |
||||
|
||||
Assert.IsTrue(ce.Condition is BinaryOperatorExpression); |
||||
Assert.IsTrue(ce.TrueExpression is InvocationExpression); |
||||
Assert.IsTrue(ce.FalseExpression is MemberReferenceExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalIsExpressionTest() |
||||
{ |
||||
// (as is b?) ERROR (conflict with nullables, SD-419)
|
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? a() : a.B"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IsExpression); |
||||
Assert.IsTrue(ce.TrueExpression is InvocationExpression); |
||||
Assert.IsTrue(ce.FalseExpression is MemberReferenceExpression); |
||||
} |
||||
|
||||
[Test, Ignore("crashes the parser")] |
||||
public void ConditionalIsWithNullableExpressionTest() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b? ? a() : a.B"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IsExpression); |
||||
Assert.IsTrue(ce.TrueExpression is InvocationExpression); |
||||
Assert.IsTrue(ce.FalseExpression is MemberReferenceExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalIsExpressionTest2() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? (a()) : a.B"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IsExpression); |
||||
Assert.IsTrue(ce.TrueExpression is ParenthesizedExpression); |
||||
Assert.IsTrue(ce.FalseExpression is MemberReferenceExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalExpressionNegativeValue() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("isNegative ? -1 : 1"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IdentifierExpression); |
||||
Assert.IsTrue(ce.TrueExpression is UnaryOperatorExpression); |
||||
Assert.IsTrue(ce.FalseExpression is PrimitiveExpression); |
||||
} |
||||
|
||||
|
||||
[Test] |
||||
public void ConditionalIsWithNegativeValue() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? -1 : 1"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IsExpression); |
||||
Assert.IsTrue(ce.TrueExpression is UnaryOperatorExpression); |
||||
Assert.IsTrue(ce.FalseExpression is PrimitiveExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConditionalIsWithExplicitPositiveValue() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? +1 : 1"); |
||||
|
||||
Assert.IsTrue(ce.Condition is IsExpression); |
||||
Assert.IsTrue(ce.TrueExpression is UnaryOperatorExpression); |
||||
Assert.IsTrue(ce.FalseExpression is PrimitiveExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void RepeatedConditionalExpr() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a ? b : c ? d : e"); |
||||
|
||||
Assert.AreEqual("a", ((IdentifierExpression)ce.Condition).Identifier); |
||||
Assert.AreEqual("b", ((IdentifierExpression)ce.TrueExpression).Identifier); |
||||
Assert.IsTrue(ce.FalseExpression is ConditionalExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void NestedConditionalExpr() |
||||
{ |
||||
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a ? b ? c : d : e"); |
||||
|
||||
Assert.AreEqual("a", ((IdentifierExpression)ce.Condition).Identifier); |
||||
Assert.AreEqual("e", ((IdentifierExpression)ce.FalseExpression).Identifier); |
||||
Assert.IsTrue(ce.TrueExpression is ConditionalExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,53 @@
@@ -0,0 +1,53 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore("tests need to be ported")] |
||||
public class DefaultValueExpressionTests |
||||
{ |
||||
[Test] |
||||
public void SimpleDefaultValue() |
||||
{ |
||||
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(T)"); |
||||
Assert.AreEqual("T", toe.Type); |
||||
} |
||||
|
||||
/* |
||||
[Test] |
||||
public void FullQualifiedDefaultValue() |
||||
{ |
||||
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(global::MyNamespace.N1.MyType)"); |
||||
Assert.IsTrue(toe.TypeReference.IsGlobal); |
||||
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericDefaultValue() |
||||
{ |
||||
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(MyNamespace.N1.MyType<string>)"); |
||||
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); |
||||
Assert.AreEqual("System.String", toe.TypeReference.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void DefaultValueAsIntializer() |
||||
{ |
||||
// This test is failing because we need a resolver for the "default:" / "default(" conflict.
|
||||
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("T a = default(T);"); |
||||
DefaultValueExpression dve = (DefaultValueExpression)lvd.Variables[0].Initializer; |
||||
Assert.AreEqual("T", dve.TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void DefaultValueInReturnStatement() |
||||
{ |
||||
ReturnStatement rs = ParseUtilCSharp.ParseStatement<ReturnStatement>("return default(T);"); |
||||
DefaultValueExpression dve = (DefaultValueExpression)rs.Expression; |
||||
Assert.AreEqual("T", dve.TypeReference.Type); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,78 @@
@@ -0,0 +1,78 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class IdentifierExpressionTests |
||||
{ |
||||
void CheckIdentifier(string sourceCode, string identifier) |
||||
{ |
||||
IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>(sourceCode); |
||||
Assert.AreEqual(identifier, ident.Identifier); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestIdentifier() |
||||
{ |
||||
CheckIdentifier("a_Bc05", "a_Bc05"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestIdentifierStartingWithUnderscore() |
||||
{ |
||||
CheckIdentifier("_Bc05", "_Bc05"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestIdentifierStartingWithEscapeSequence() |
||||
{ |
||||
CheckIdentifier(@"\u006cexer", "lexer"); |
||||
} |
||||
|
||||
[Test, Ignore("Mono parser bug?")] |
||||
public void TestIdentifierContainingEscapeSequence() |
||||
{ |
||||
CheckIdentifier(@"l\U00000065xer", "lexer"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestKeyWordAsIdentifier() |
||||
{ |
||||
CheckIdentifier("@int", "int"); |
||||
} |
||||
|
||||
[Test, Ignore("Mono parser bug?")] |
||||
public void TestKeywordWithEscapeSequenceIsIdentifier() |
||||
{ |
||||
CheckIdentifier(@"i\u006et", "int"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestKeyWordAsIdentifierStartingWithUnderscore() |
||||
{ |
||||
CheckIdentifier("@_int", "_int"); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void GenericMethodReference() |
||||
{ |
||||
IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>("M<int>"); |
||||
Assert.AreEqual("M", ident.Identifier); |
||||
//Assert.AreEqual(1, ident.TypeArguments.Count);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void GenericMethodReference2() |
||||
{ |
||||
IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>("TargetMethod<string>"); |
||||
Assert.AreEqual("TargetMethod", ident.Identifier); |
||||
//Assert.AreEqual(1, ident.TypeArguments.Count);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,29 @@
@@ -0,0 +1,29 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class IndexerExpressionTests |
||||
{ |
||||
[Test] |
||||
public void IndexerExpressionTest() |
||||
{ |
||||
IndexerExpression ie = ParseUtilCSharp.ParseExpression<IndexerExpression>("field[1, \"Hello\", 'a']"); |
||||
Assert.IsTrue(ie.Target is IdentifierExpression); |
||||
|
||||
Assert.AreEqual(3, ie.Arguments.Count()); |
||||
|
||||
Assert.IsTrue(ie.Arguments.ElementAt(0) is PrimitiveExpression); |
||||
Assert.AreEqual(1, (int)((PrimitiveExpression)ie.Arguments.ElementAt(0)).Value); |
||||
Assert.IsTrue(ie.Arguments.ElementAt(1) is PrimitiveExpression); |
||||
Assert.AreEqual("Hello", (string)((PrimitiveExpression)ie.Arguments.ElementAt(1)).Value); |
||||
Assert.IsTrue(ie.Arguments.ElementAt(2) is PrimitiveExpression); |
||||
Assert.AreEqual('a', (char)((PrimitiveExpression)ie.Arguments.ElementAt(2)).Value); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,155 @@
@@ -0,0 +1,155 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore("Port unit tests to new DOM")] |
||||
public class InvocationExpressionTests |
||||
{ |
||||
[Test] |
||||
public void SimpleInvocationExpressionTest() |
||||
{ |
||||
var ie = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod()"); |
||||
Assert.AreEqual(0, ie.Arguments.Count()); |
||||
Assert.IsTrue(ie.Target is IdentifierExpression); |
||||
Assert.AreEqual("myMethod", ((IdentifierExpression)ie.Target).Identifier); |
||||
} |
||||
|
||||
/* TODO port unit tests to new DOM |
||||
[Test] |
||||
public void GenericInvocationExpressionTest() |
||||
{ |
||||
var expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod<char>('a')"); |
||||
Assert.AreEqual(1, expr.Arguments.Count()); |
||||
Assert.IsTrue(expr.TargetObject is IdentifierExpression); |
||||
IdentifierExpression ident = (IdentifierExpression)expr.TargetObject; |
||||
Assert.AreEqual("myMethod", ident.Identifier); |
||||
Assert.AreEqual(1, ident.TypeArguments.Count); |
||||
Assert.AreEqual("System.Char", ident.TypeArguments[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericInvocation2ExpressionTest() |
||||
{ |
||||
var expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod<T,bool>()"); |
||||
Assert.AreEqual(0, expr.Arguments.Count); |
||||
Assert.IsTrue(expr.TargetObject is IdentifierExpression); |
||||
IdentifierExpression ident = (IdentifierExpression)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); |
||||
} |
||||
|
||||
[Test] |
||||
public void AmbiguousGrammarGenericMethodCall() |
||||
{ |
||||
InvocationExpression ie = ParseUtilCSharp.ParseExpression<InvocationExpression>("F(G<A,B>(7))"); |
||||
Assert.IsTrue(ie.TargetObject is IdentifierExpression); |
||||
Assert.AreEqual(1, ie.Arguments.Count); |
||||
ie = (InvocationExpression)ie.Arguments[0]; |
||||
Assert.AreEqual(1, ie.Arguments.Count); |
||||
Assert.IsTrue(ie.Arguments[0] is PrimitiveExpression); |
||||
IdentifierExpression ident = (IdentifierExpression)ie.TargetObject; |
||||
Assert.AreEqual("G", ident.Identifier); |
||||
Assert.AreEqual(2, ident.TypeArguments.Count); |
||||
} |
||||
|
||||
[Test] |
||||
public void AmbiguousGrammarNotAGenericMethodCall() |
||||
{ |
||||
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("F<A>+y"); |
||||
Assert.AreEqual(BinaryOperatorType.GreaterThan, boe.Op); |
||||
Assert.IsTrue(boe.Left is BinaryOperatorExpression); |
||||
Assert.IsTrue(boe.Right is UnaryOperatorExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvalidNestedInvocationExpressionTest() |
||||
{ |
||||
// this test was written because this bug caused the AbstractASTVisitor to crash
|
||||
|
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("WriteLine(myMethod(,))", true); |
||||
Assert.IsTrue(expr.TargetObject is IdentifierExpression); |
||||
Assert.AreEqual("WriteLine", ((IdentifierExpression)expr.TargetObject).Identifier); |
||||
|
||||
Assert.AreEqual(1, expr.Arguments.Count); // here a second null parameter was added incorrectly
|
||||
|
||||
Assert.IsTrue(expr.Arguments[0] is InvocationExpression); |
||||
CheckSimpleInvoke((InvocationExpression)expr.Arguments[0]); |
||||
} |
||||
|
||||
[Test] |
||||
public void NestedInvocationPositions() |
||||
{ |
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("a.B().C(args)"); |
||||
Assert.AreEqual(new Location(8, 1), expr.StartLocation); |
||||
Assert.AreEqual(new Location(14, 1), expr.EndLocation); |
||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
||||
Assert.AreEqual(new Location(6, 1), mre.StartLocation); |
||||
Assert.AreEqual(new Location(8, 1), mre.EndLocation); |
||||
|
||||
Assert.AreEqual(new Location(4, 1), mre.TargetObject.StartLocation); |
||||
Assert.AreEqual(new Location(6, 1), mre.TargetObject.EndLocation); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvocationOnGenericType() |
||||
{ |
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.Foo()"); |
||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
||||
Assert.AreEqual("Foo", mre.MemberName); |
||||
TypeReferenceExpression tre = (TypeReferenceExpression)mre.TargetObject; |
||||
Assert.AreEqual("A", tre.TypeReference.Type); |
||||
Assert.AreEqual("T", tre.TypeReference.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvocationOnInnerClassInGenericType() |
||||
{ |
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.B.Foo()"); |
||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
||||
Assert.AreEqual("Foo", mre.MemberName); |
||||
MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject; |
||||
Assert.AreEqual("B", mre2.MemberName); |
||||
TypeReferenceExpression tre = (TypeReferenceExpression)mre2.TargetObject; |
||||
Assert.AreEqual("A", tre.TypeReference.Type); |
||||
Assert.AreEqual("T", tre.TypeReference.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvocationOnGenericInnerClassInGenericType() |
||||
{ |
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.B.C<U>.Foo()"); |
||||
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject; |
||||
Assert.AreEqual("Foo", mre.MemberName); |
||||
TypeReferenceExpression tre = (TypeReferenceExpression)mre.TargetObject; |
||||
InnerClassTypeReference ictr = (InnerClassTypeReference)tre.TypeReference; |
||||
Assert.AreEqual("B.C", ictr.Type); |
||||
Assert.AreEqual(1, ictr.GenericTypes.Count); |
||||
Assert.AreEqual("U", ictr.GenericTypes[0].Type); |
||||
|
||||
Assert.AreEqual("A", ictr.BaseType.Type); |
||||
Assert.AreEqual(1, ictr.BaseType.GenericTypes.Count); |
||||
Assert.AreEqual("T", ictr.BaseType.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvocationWithNamedArgument() |
||||
{ |
||||
InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("a(arg: ref v)"); |
||||
Assert.AreEqual(1, expr.Arguments.Count); |
||||
NamedArgumentExpression nae = (NamedArgumentExpression)expr.Arguments[0]; |
||||
Assert.AreEqual("arg", nae.Name); |
||||
DirectionExpression dir = (DirectionExpression)nae.Expression; |
||||
Assert.AreEqual(FieldDirection.Ref, dir.FieldDirection); |
||||
Assert.IsInstanceOf<IdentifierExpression>(dir.Expression); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,45 @@
@@ -0,0 +1,45 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class IsExpressionTests |
||||
{ |
||||
[Test, Ignore] |
||||
public void GenericArrayIsExpression() |
||||
{ |
||||
/* TODO |
||||
TypeOfIsExpression ce = ParseUtilCSharp.ParseExpression<TypeOfIsExpression>("o is List<string>[]"); |
||||
Assert.AreEqual("List", ce.TypeReference.Type); |
||||
Assert.AreEqual("System.String", ce.TypeReference.GenericTypes[0].Type); |
||||
Assert.AreEqual(new int[] { 0 }, ce.TypeReference.RankSpecifier); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression);*/ |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableIsExpression() |
||||
{ |
||||
IsExpression ce = ParseUtilCSharp.ParseExpression<IsExpression>("o is int?"); |
||||
ComposedType type = (ComposedType)ce.Type; |
||||
Assert.IsTrue(type.HasNullableSpecifier); |
||||
Assert.AreEqual("int", ((PrimitiveType)type.BaseType).Keyword); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableIsExpressionInBinaryOperatorExpression() |
||||
{ |
||||
BinaryOperatorExpression boe; |
||||
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("o is int? == true"); |
||||
IsExpression ce = (IsExpression)boe.Left; |
||||
ComposedType type = (ComposedType)ce.Type; |
||||
Assert.IsTrue(type.HasNullableSpecifier); |
||||
Assert.AreEqual("int", ((PrimitiveType)type.BaseType).Keyword); |
||||
Assert.IsTrue(ce.Expression is IdentifierExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,89 @@
@@ -0,0 +1,89 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore("Port unit tests")] |
||||
public class LambdaExpressionTests |
||||
{ |
||||
static LambdaExpression ParseCSharp(string program) |
||||
{ |
||||
return ParseUtilCSharp.ParseExpression<LambdaExpression>(program); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitlyTypedExpressionBody() |
||||
{ |
||||
/* |
||||
LambdaExpression e = ParseCSharp("(x) => x + 1"); |
||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue(e.Parameters[0].TypeReference.IsNull); |
||||
Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression); |
||||
Assert.IsTrue(e.ReturnType.IsNull);*/ |
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO Port unit tests |
||||
[Test] |
||||
public void ImplicitlyTypedExpressionBodyWithoutParenthesis() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("x => x + 1"); |
||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue(e.Parameters[0].TypeReference.IsNull); |
||||
Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitlyTypedStatementBody() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("(x) => { return x + 1; }"); |
||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue(e.Parameters[0].TypeReference.IsNull); |
||||
Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitlyTypedStatementBodyWithoutParenthesis() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("x => { return x + 1; }"); |
||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue(e.Parameters[0].TypeReference.IsNull); |
||||
Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExplicitlyTypedStatementBody() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("(int x) => { return x + 1; }"); |
||||
Assert.AreEqual("x", e.Parameters[0].ParameterName); |
||||
Assert.AreEqual("System.Int32", e.Parameters[0].TypeReference.Type); |
||||
Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExplicitlyTypedStatementBodyWithRefParameter() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("(ref int i) => i = 1"); |
||||
Assert.AreEqual("i", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue((e.Parameters[0].ParamModifier & ParameterModifiers.Ref) == ParameterModifiers.Ref); |
||||
Assert.AreEqual("System.Int32", e.Parameters[0].TypeReference.Type); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionContainingConditionalExpression() |
||||
{ |
||||
LambdaExpression e = ParseCSharp("rr => rr != null ? rr.ResolvedType : null"); |
||||
Assert.AreEqual("rr", e.Parameters[0].ParameterName); |
||||
Assert.IsTrue(e.ExpressionBody is ConditionalExpression); |
||||
Assert.IsTrue(e.ReturnType.IsNull); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,76 @@
@@ -0,0 +1,76 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class MemberReferenceExpressionTests |
||||
{ |
||||
[Test] |
||||
public void SimpleFieldReferenceExpressionTest() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("myTargetObject.myField"); |
||||
//Assert.AreEqual("myField", fre.MemberName);
|
||||
//Assert.IsTrue(fre.TargetObject is IdentifierExpression);
|
||||
//Assert.AreEqual("myTargetObject", ((IdentifierExpression)fre.TargetObject).Identifier);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO port unit tests |
||||
[Test] |
||||
public void GenericFieldReferenceExpressionTest() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("SomeClass<string>.myField"); |
||||
Assert.AreEqual("myField", fre.MemberName); |
||||
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression); |
||||
TypeReference tr = ((TypeReferenceExpression)fre.TargetObject).TypeReference; |
||||
Assert.AreEqual("SomeClass", tr.Type); |
||||
Assert.AreEqual(1, tr.GenericTypes.Count); |
||||
Assert.AreEqual("System.String", tr.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void FullNamespaceGenericFieldReferenceExpressionTest() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("Namespace.Subnamespace.SomeClass<string>.myField"); |
||||
Assert.AreEqual("myField", fre.MemberName); |
||||
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression); |
||||
TypeReference tr = ((TypeReferenceExpression)fre.TargetObject).TypeReference; |
||||
Assert.AreEqual("Namespace.Subnamespace.SomeClass", tr.Type); |
||||
Assert.AreEqual(1, tr.GenericTypes.Count); |
||||
Assert.AreEqual("System.String", tr.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void GlobalFullNamespaceGenericFieldReferenceExpressionTest() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("global::Namespace.Subnamespace.SomeClass<string>.myField"); |
||||
Assert.AreEqual("myField", fre.MemberName); |
||||
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression); |
||||
TypeReference tr = ((TypeReferenceExpression)fre.TargetObject).TypeReference; |
||||
Assert.IsFalse(tr is InnerClassTypeReference); |
||||
Assert.AreEqual("Namespace.Subnamespace.SomeClass", tr.Type); |
||||
Assert.AreEqual(1, tr.GenericTypes.Count); |
||||
Assert.AreEqual("System.String", tr.GenericTypes[0].Type); |
||||
Assert.IsTrue(tr.IsGlobal); |
||||
} |
||||
|
||||
[Test] |
||||
public void NestedGenericFieldReferenceExpressionTest() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("MyType<string>.InnerClass<int>.myField"); |
||||
Assert.AreEqual("myField", fre.MemberName); |
||||
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression); |
||||
InnerClassTypeReference ic = (InnerClassTypeReference)((TypeReferenceExpression)fre.TargetObject).TypeReference; |
||||
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); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,21 @@
@@ -0,0 +1,21 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class ParenthesizedExpressionTests |
||||
{ |
||||
[Test] |
||||
public void PrimitiveParenthesizedExpression() |
||||
{ |
||||
ParenthesizedExpression p = ParseUtilCSharp.ParseExpression<ParenthesizedExpression>("((1))"); |
||||
Assert.IsTrue(p.Expression is ParenthesizedExpression); |
||||
p = (ParenthesizedExpression)p.Expression; |
||||
Assert.IsTrue(p.Expression is PrimitiveExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,21 @@
@@ -0,0 +1,21 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class PointerReferenceExpressionTests |
||||
{ |
||||
[Test, Ignore("where did PointerReferenceExpression.MemberName go?")] |
||||
public void PointerReferenceExpressionTest() |
||||
{ |
||||
PointerReferenceExpression pre = ParseUtilCSharp.ParseExpression<PointerReferenceExpression>("myObj.field->b"); |
||||
Assert.IsTrue(pre.Target is MemberReferenceExpression); |
||||
//Assert.AreEqual("b", pre.MemberName);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,203 @@
@@ -0,0 +1,203 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class PrimitiveExpressionTests |
||||
{ |
||||
[Test] |
||||
public void HexIntegerTest1() |
||||
{ |
||||
InvocationExpression invExpr = ParseUtilCSharp.ParseExpression<InvocationExpression>("0xAFFE.ToString()"); |
||||
Assert.AreEqual(0, invExpr.Arguments.Count()); |
||||
Assert.IsTrue(invExpr.Target is MemberReferenceExpression); |
||||
MemberReferenceExpression fre = invExpr.Target as MemberReferenceExpression; |
||||
Assert.AreEqual("ToString", fre.MemberName); |
||||
|
||||
Assert.IsTrue(fre.Target is PrimitiveExpression); |
||||
PrimitiveExpression pe = fre.Target as PrimitiveExpression; |
||||
|
||||
Assert.AreEqual(0xAFFE, (int)pe.Value); |
||||
|
||||
} |
||||
|
||||
void CheckLiteral(string code, object value) |
||||
{ |
||||
PrimitiveExpression pe = ParseUtilCSharp.ParseExpression<PrimitiveExpression>(code); |
||||
Assert.AreEqual(value.GetType(), pe.Value.GetType()); |
||||
Assert.AreEqual(value, pe.Value); |
||||
} |
||||
|
||||
[Test] |
||||
public void DoubleTest1() |
||||
{ |
||||
CheckLiteral(".5e-06", .5e-06); |
||||
} |
||||
|
||||
[Test] |
||||
public void CharTest1() |
||||
{ |
||||
CheckLiteral("'\\u0356'", '\u0356'); |
||||
} |
||||
|
||||
[Test, Ignore("this special case isn't implemented yet")] |
||||
public void IntMinValueTest() |
||||
{ |
||||
CheckLiteral("-2147483648", -2147483648); |
||||
} |
||||
|
||||
[Test] |
||||
public void IntMaxValueTest() |
||||
{ |
||||
CheckLiteral("2147483647", 2147483647); // int
|
||||
CheckLiteral("2147483648", 2147483648); // uint
|
||||
} |
||||
|
||||
[Test, Ignore("this special case isn't implemented yet")] |
||||
public void LongMinValueTest() |
||||
{ |
||||
CheckLiteral("-9223372036854775808", -9223372036854775808); |
||||
} |
||||
|
||||
[Test] |
||||
public void LongMaxValueTest() |
||||
{ |
||||
CheckLiteral("9223372036854775807", 9223372036854775807); // long
|
||||
CheckLiteral("9223372036854775808", 9223372036854775808); // ulong
|
||||
} |
||||
|
||||
[Test] |
||||
public void StringTest1() |
||||
{ |
||||
CheckLiteral("\"\\n\\t\\u0005 Hello World !!!\"", "\n\t\u0005 Hello World !!!"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestSingleDigit() |
||||
{ |
||||
CheckLiteral("5", 5); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestZero() |
||||
{ |
||||
CheckLiteral("0", 0); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestInteger() |
||||
{ |
||||
CheckLiteral("66", 66); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestNonOctalInteger() |
||||
{ |
||||
// C# does not have octal integers, so 077 should parse to 77
|
||||
Assert.IsTrue(077 == 77); |
||||
|
||||
CheckLiteral("077", 077); |
||||
CheckLiteral("056", 056); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestHexadecimalInteger() |
||||
{ |
||||
CheckLiteral("0x99F", 0x99F); |
||||
CheckLiteral("0xAB1f", 0xAB1f); |
||||
CheckLiteral("0xffffffff", 0xffffffff); |
||||
CheckLiteral("0xffffffffL", 0xffffffffL); |
||||
CheckLiteral("0xffffffffuL", 0xffffffffuL); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvalidHexadecimalInteger() |
||||
{ |
||||
// don't check result, just make sure there is no exception
|
||||
ParseUtilCSharp.ParseExpression<PrimitiveExpression>("0x2GF", expectErrors: true); |
||||
ParseUtilCSharp.ParseExpression<PrimitiveExpression>("0xG2F", expectErrors: true); |
||||
ParseUtilCSharp.ParseExpression<PrimitiveExpression>("0x", expectErrors: true); // SD-457
|
||||
// hexadecimal integer >ulong.MaxValue
|
||||
ParseUtilCSharp.ParseExpression<PrimitiveExpression>("0xfedcba98765432100", expectErrors: true); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestLongHexadecimalInteger() |
||||
{ |
||||
CheckLiteral("0x4244636f446c6d58", 0x4244636f446c6d58); |
||||
CheckLiteral("0xf244636f446c6d58", 0xf244636f446c6d58); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestLongInteger() |
||||
{ |
||||
CheckLiteral("9223372036854775807", 9223372036854775807); // long.MaxValue
|
||||
CheckLiteral("9223372036854775808", 9223372036854775808); // long.MaxValue+1
|
||||
CheckLiteral("18446744073709551615", 18446744073709551615); // ulong.MaxValue
|
||||
} |
||||
|
||||
[Test] |
||||
public void TestTooLongInteger() |
||||
{ |
||||
// ulong.MaxValue+1
|
||||
ParseUtilCSharp.ParseExpression<PrimitiveExpression>("18446744073709551616", expectErrors: true); |
||||
|
||||
CheckLiteral("18446744073709551616f", 18446744073709551616f); // ulong.MaxValue+1 as float
|
||||
CheckLiteral("18446744073709551616d", 18446744073709551616d); // ulong.MaxValue+1 as double
|
||||
CheckLiteral("18446744073709551616m", 18446744073709551616m); // ulong.MaxValue+1 as decimal
|
||||
} |
||||
|
||||
[Test] |
||||
public void TestDouble() |
||||
{ |
||||
CheckLiteral("1.0", 1.0); |
||||
CheckLiteral("1.1", 1.1); |
||||
CheckLiteral("1.1e-2", 1.1e-2); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestFloat() |
||||
{ |
||||
CheckLiteral("1f", 1f); |
||||
CheckLiteral("1.0f", 1.0f); |
||||
CheckLiteral("1.1f", 1.1f); |
||||
CheckLiteral("1.1e-2f", 1.1e-2f); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestDecimal() |
||||
{ |
||||
CheckLiteral("1m", 1m); |
||||
CheckLiteral("1.0m", 1.0m); |
||||
CheckLiteral("1.1m", 1.1m); |
||||
CheckLiteral("1.1e-2m", 1.1e-2m); |
||||
CheckLiteral("2.0e-5m", 2.0e-5m); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestString() |
||||
{ |
||||
CheckLiteral(@"@""-->""""<--""", @"-->""<--"); |
||||
CheckLiteral(@"""-->\""<--""", "-->\"<--"); |
||||
|
||||
CheckLiteral(@"""\U00000041""", "\U00000041"); |
||||
CheckLiteral(@"""\U00010041""", "\U00010041"); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestCharLiteral() |
||||
{ |
||||
CheckLiteral(@"'a'", 'a'); |
||||
CheckLiteral(@"'\u0041'", '\u0041'); |
||||
CheckLiteral(@"'\x41'", '\x41'); |
||||
CheckLiteral(@"'\x041'", '\x041'); |
||||
CheckLiteral(@"'\x0041'", '\x0041'); |
||||
CheckLiteral(@"'\U00000041'", '\U00000041'); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,109 @@
@@ -0,0 +1,109 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class QueryExpressionTests |
||||
{ |
||||
[Test] |
||||
public void SimpleExpression() |
||||
{ |
||||
/* |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from c in customers where c.City == \"London\" select c" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.AreEqual(1, qe.MiddleClauses.Count); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[0]); |
||||
QueryExpressionWhereClause wc = (QueryExpressionWhereClause)qe.MiddleClauses[0]; |
||||
Assert.IsInstanceOf(typeof(BinaryOperatorExpression), wc.Condition); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);*/ |
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO port unit tests |
||||
[Test] |
||||
public void ExpressionWithType1() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from Customer c in customers select c" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("Customer", qe.FromClause.Sources.First().Type.ToString()); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExpressionWithType2() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from int c in customers select c" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("System.Int32", qe.FromClause.Sources.First().Type.Type); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
} |
||||
|
||||
|
||||
[Test] |
||||
public void ExpressionWithType3() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from S<int[]>? c in customers select c" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("System.Nullable<S<System.Int32[]>>", qe.FromClause.Sources.First().Type.ToString()); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
} |
||||
|
||||
[Test] |
||||
public void MultipleGenerators() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(@"
|
||||
from c in customers |
||||
where c.City == ""London"" |
||||
from o in c.Orders |
||||
where o.OrderDate.Year == 2005 |
||||
select new { c.Name, o.OrderID, o.Total }");
|
||||
Assert.AreEqual(3, qe.MiddleClauses.Count); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[0]); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionFromClause), qe.MiddleClauses[1]); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[2]); |
||||
|
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExpressionWithOrderBy() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from c in customers orderby c.Name select c" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionOrderClause), qe.MiddleClauses[0]); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExpressionWithOrderByAndLet() |
||||
{ |
||||
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>( |
||||
"from c in customers orderby c.Name let x = c select x" |
||||
); |
||||
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier); |
||||
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionOrderClause), qe.MiddleClauses[0]); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionLetClause), qe.MiddleClauses[1]); |
||||
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class SizeOfExpressionTests |
||||
{ |
||||
[Test, Ignore("type references not implemented yet")] |
||||
public void SizeOfExpressionTest() |
||||
{ |
||||
SizeOfExpression soe = ParseUtilCSharp.ParseExpression<SizeOfExpression>("sizeof(MyType)"); |
||||
Assert.AreEqual("MyType", soe.Type); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class StackAllocExpressionTests |
||||
{ |
||||
[Test, Ignore] |
||||
public void StackAllocExpressionTest() |
||||
{ |
||||
var sae = ParseUtilCSharp.ParseExpression<StackAllocExpression>("stackalloc int[100]"); |
||||
throw new NotImplementedException(); // TODO: verify type + length expression
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class ThisReferenceExpressionTests |
||||
{ |
||||
[Test] |
||||
public void TestMethod() |
||||
{ |
||||
ParseUtilCSharp.ParseExpression<ThisReferenceExpression>("this"); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,91 @@
@@ -0,0 +1,91 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class TypeOfExpressionTests |
||||
{ |
||||
[Test] |
||||
public void SimpleTypeOfExpressionTest() |
||||
{ |
||||
//TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyNamespace.N1.MyType)");
|
||||
//Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO |
||||
[Test] |
||||
public void GlobalTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(global::System.Console)"); |
||||
Assert.AreEqual("System.Console", toe.TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void PrimitiveTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(int)"); |
||||
Assert.AreEqual("System.Int32", toe.TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void VoidTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(void)"); |
||||
Assert.AreEqual("System.Void", toe.TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void ArrayTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType[])"); |
||||
Assert.AreEqual("MyType", toe.TypeReference.Type); |
||||
Assert.AreEqual(new int[] {0}, toe.TypeReference.RankSpecifier); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyNamespace.N1.MyType<string>)"); |
||||
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); |
||||
Assert.AreEqual("System.String", toe.TypeReference.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NestedGenericTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType<string>.InnerClass<int>.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); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyStruct?)"); |
||||
Assert.AreEqual("System.Nullable", toe.TypeReference.Type); |
||||
Assert.AreEqual("MyStruct", toe.TypeReference.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void UnboundTypeOfExpressionTest() |
||||
{ |
||||
TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType<,>)"); |
||||
Assert.AreEqual("MyType", toe.TypeReference.Type); |
||||
Assert.IsTrue(toe.TypeReference.GenericTypes[0].IsNull); |
||||
Assert.IsTrue(toe.TypeReference.GenericTypes[1].IsNull); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,46 @@
@@ -0,0 +1,46 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class TypeReferenceExpressionTests |
||||
{ |
||||
[Test] |
||||
public void GlobalTypeReferenceExpression() |
||||
{ |
||||
/*TypeReferenceExpression tr = ParseUtilCSharp.ParseExpression<TypeReferenceExpression>("global::System"); |
||||
Assert.AreEqual("System", tr.TypeReference.Type); |
||||
Assert.IsTrue(tr.TypeReference.IsGlobal);*/ |
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO |
||||
[Test] |
||||
public void GlobalTypeReferenceExpressionWithoutTypeName() |
||||
{ |
||||
TypeReferenceExpression tr = ParseUtilCSharp.ParseExpression<TypeReferenceExpression>("global::", true); |
||||
Assert.AreEqual("?", tr.TypeReference.Type); |
||||
Assert.IsTrue(tr.TypeReference.IsGlobal); |
||||
} |
||||
|
||||
[Test] |
||||
public void IntReferenceExpression() |
||||
{ |
||||
MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("int.MaxValue"); |
||||
Assert.AreEqual("MaxValue", fre.MemberName); |
||||
Assert.AreEqual("System.Int32", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void StandaloneIntReferenceExpression() |
||||
{ |
||||
TypeReferenceExpression tre = ParseUtilCSharp.ParseExpression<TypeReferenceExpression>("int"); |
||||
Assert.AreEqual("System.Int32", tre.TypeReference.Type); |
||||
} |
||||
*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,95 @@
@@ -0,0 +1,95 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Expression |
||||
{ |
||||
[TestFixture] |
||||
public class UnaryOperatorExpressionTests |
||||
{ |
||||
void TestUnaryOperatorExpressionTest(string program, UnaryOperatorType op) |
||||
{ |
||||
UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression<UnaryOperatorExpression>(program); |
||||
Assert.AreEqual(op, uoe.Operator); |
||||
|
||||
Assert.IsTrue(uoe.Expression is IdentifierExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void NotTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("!a", UnaryOperatorType.Not); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitNotTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("~a", UnaryOperatorType.BitNot); |
||||
} |
||||
|
||||
[Test] |
||||
public void MinusTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus); |
||||
} |
||||
|
||||
[Test] |
||||
public void PlusTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus); |
||||
} |
||||
|
||||
[Test] |
||||
public void IncrementTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("++a", UnaryOperatorType.Increment); |
||||
} |
||||
|
||||
[Test] |
||||
public void DecrementTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("--a", UnaryOperatorType.Decrement); |
||||
} |
||||
|
||||
[Test] |
||||
public void PostIncrementTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("a++", UnaryOperatorType.PostIncrement); |
||||
} |
||||
|
||||
[Test] |
||||
public void PostDecrementTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("a--", UnaryOperatorType.PostDecrement); |
||||
} |
||||
|
||||
[Test] |
||||
public void StarTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("*a", UnaryOperatorType.Dereference); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitWiseAndTest() |
||||
{ |
||||
TestUnaryOperatorExpressionTest("&a", UnaryOperatorType.AddressOf); |
||||
} |
||||
|
||||
[Test] |
||||
public void DereferenceAfterCast() |
||||
{ |
||||
UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression<UnaryOperatorExpression>("*((SomeType*) &w)"); |
||||
Assert.AreEqual(UnaryOperatorType.Dereference, uoe.Operator); |
||||
ParenthesizedExpression pe = (ParenthesizedExpression)uoe.Expression; |
||||
CastExpression ce = (CastExpression)pe.Expression; |
||||
//Assert.AreEqual("SomeType", ce.CastTo.Type);
|
||||
//Assert.AreEqual(1, ce.CastTo.PointerNestingLevel);
|
||||
Assert.Ignore("need to check target type"); // TODO
|
||||
|
||||
UnaryOperatorExpression adrOf = (UnaryOperatorExpression)ce.Expression; |
||||
Assert.AreEqual(UnaryOperatorType.AddressOf, adrOf.Operator); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,68 @@
@@ -0,0 +1,68 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class AttributeSectionTests |
||||
{ |
||||
[Test, Ignore] |
||||
public void GlobalAttributeCSharp() |
||||
{ |
||||
string program = @"[global::Microsoft.VisualBasic.CompilerServices.DesignerGenerated()]
|
||||
[someprefix::DesignerGenerated()] |
||||
public class Form1 { |
||||
}";
|
||||
// TODO This old NRefactory test checked that [global] attributes are incorrectly applied to the following type???
|
||||
|
||||
//TypeDeclaration decl = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program);
|
||||
//Assert.AreEqual("Microsoft.VisualBasic.CompilerServices.DesignerGenerated", decl.Attributes.First().Attributes.Single().Name);
|
||||
//Assert.AreEqual("someprefix.DesignerGenerated", decl.Attributes.Last().Attributes.Single().Name);
|
||||
} |
||||
|
||||
[Test] |
||||
public void AssemblyAttributeCSharp() |
||||
{ |
||||
string program = @"[assembly: System.Attribute()]"; |
||||
AttributeSection decl = ParseUtilCSharp.ParseGlobal<AttributeSection>(program); |
||||
Assert.AreEqual(new AstLocation(1, 1), decl.StartLocation); |
||||
Assert.AreEqual("assembly", decl.AttributeTarget); |
||||
} |
||||
|
||||
[Test] |
||||
public void AssemblyAttributeCSharpWithNamedArguments() |
||||
{ |
||||
string program = @"[assembly: Foo(1, namedArg: 2, prop = 3)]"; |
||||
AttributeSection decl = ParseUtilCSharp.ParseGlobal<AttributeSection>(program); |
||||
Assert.AreEqual("assembly", decl.AttributeTarget); |
||||
var a = decl.Attributes.Single(); |
||||
Assert.AreEqual("Foo", a.Type); |
||||
Assert.AreEqual(3, a.Arguments.Count()); |
||||
|
||||
// TODO: check arguments
|
||||
} |
||||
|
||||
[Test] |
||||
public void ModuleAttributeCSharp() |
||||
{ |
||||
string program = @"[module: System.Attribute()]"; |
||||
AttributeSection decl = ParseUtilCSharp.ParseGlobal<AttributeSection>(program); |
||||
Assert.AreEqual(new AstLocation(1, 1), decl.StartLocation); |
||||
Assert.AreEqual(AttributeTarget.Module, decl.AttributeTarget); |
||||
} |
||||
|
||||
[Test] |
||||
public void TypeAttributeCSharp() |
||||
{ |
||||
string program = @"[type: System.Attribute()] class Test {}"; |
||||
TypeDeclaration type = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program); |
||||
AttributeSection decl = type.Attributes.Single(); |
||||
Assert.AreEqual(new AstLocation(1, 1), decl.StartLocation); |
||||
Assert.AreEqual(AttributeTarget.Type, decl.AttributeTarget); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,77 @@
@@ -0,0 +1,77 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope |
||||
{ |
||||
[TestFixture, Ignore("delegates are completely broken at the moment")] |
||||
public class DelegateDeclarationTests |
||||
{ |
||||
void TestParameters(DelegateDeclaration dd) |
||||
{ |
||||
Assert.AreEqual(3, dd.Parameters.Count()); |
||||
|
||||
Assert.AreEqual("a", ((ParameterDeclaration)dd.Parameters.ElementAt(0)).Name); |
||||
//Assert.AreEqual("System.Int32", ((ParameterDeclaration)dd.Parameters.ElementAt(0)).TypeReference.Type);
|
||||
Assert.Ignore("check types"); // TODO
|
||||
Assert.AreEqual("secondParam", ((ParameterDeclaration)dd.Parameters.ElementAt(1)).Name); |
||||
//Assert.AreEqual("System.Int32", ((ParameterDeclaration)dd.Parameters.ElementAt(1)).TypeReference.Type);
|
||||
|
||||
Assert.AreEqual("lastParam", ((ParameterDeclaration)dd.Parameters.ElementAt(2)).Name); |
||||
//Assert.AreEqual("MyObj", ((ParameterDeclaration)dd.Parameters.ElementAt(2)).TypeReference.Type);
|
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleCSharpDelegateDeclarationTest() |
||||
{ |
||||
string program = "public delegate void MyDelegate(int a, int secondParam, MyObj lastParam);\n"; |
||||
DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program); |
||||
Assert.AreEqual("MyDelegate", dd.Name); |
||||
//Assert.AreEqual("System.Void", dd.ReturnType.Type);
|
||||
TestParameters(dd); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void DelegateWithoutNameDeclarationTest() |
||||
{ |
||||
string program = "public delegate void(int a, int secondParam, MyObj lastParam);\n"; |
||||
DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program, true); |
||||
//Assert.AreEqual("System.Void", dd.ReturnType.Type);
|
||||
//Assert.AreEqual("?", dd.Name);
|
||||
TestParameters(dd); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void GenericDelegateDeclarationTest() |
||||
{ |
||||
string program = "public delegate T CreateObject<T>() where T : ICloneable;\n"; |
||||
DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program); |
||||
Assert.AreEqual("CreateObject", dd.Name); |
||||
//Assert.AreEqual("T", dd.ReturnType.Type);
|
||||
Assert.AreEqual(0, dd.Parameters.Count()); |
||||
/*Assert.AreEqual(1, dd.Templates.Count); |
||||
Assert.AreEqual("T", dd.Templates[0].Name); |
||||
Assert.AreEqual(1, dd.Templates[0].Bases.Count); |
||||
Assert.AreEqual("ICloneable", dd.Templates[0].Bases[0].Type);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test] |
||||
public void DelegateDeclarationInNamespace() |
||||
{ |
||||
string program = "namespace N { delegate void MyDelegate(); }"; |
||||
NamespaceDeclaration nd = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>(program); |
||||
Assert.AreEqual("MyDelegate", ((DelegateDeclaration)nd.Members.Single()).Name); |
||||
} |
||||
|
||||
[Test, Ignore("inner classes not yet implemented")] |
||||
public void DelegateDeclarationInClass() |
||||
{ |
||||
string program = "class Outer { delegate void Inner(); }"; |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program); |
||||
Assert.AreEqual("Inner", ((DelegateDeclaration)td.Members.Single()).Name); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@
@@ -0,0 +1,36 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope |
||||
{ |
||||
[TestFixture] |
||||
public class NamespaceDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void SimpleNamespaceTest() |
||||
{ |
||||
string program = "namespace TestNamespace {\n" + |
||||
"}\n"; |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>(program); |
||||
Assert.AreEqual("TestNamespace", ns.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void NestedNamespaceTest() |
||||
{ |
||||
string program = "namespace N1 {//TestNamespace\n" + |
||||
" namespace N2 {// Declares a namespace named N2 within N1.\n" + |
||||
" }\n" + |
||||
"}\n"; |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>(program); |
||||
|
||||
Assert.AreEqual("N1", ns.Name); |
||||
|
||||
Assert.AreEqual("N2", ns.Children.OfType<NamespaceDeclaration>().Single().Name); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,240 @@
@@ -0,0 +1,240 @@
|
||||
// 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.Linq; |
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope |
||||
{ |
||||
[TestFixture] |
||||
public class TypeDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void SimpleClassTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("class MyClass : My.Base.Class { }"); |
||||
|
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("MyClass", td.Name); |
||||
//Assert.AreEqual("My.Base.Class", td.BaseTypes[0].Type);
|
||||
Assert.Ignore("need to check base type"); // TODO
|
||||
Assert.AreEqual(Modifiers.None, td.Modifiers); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleClassRegionTest() |
||||
{ |
||||
const string program = "class MyClass\n{\n}\n"; |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program); |
||||
Assert.AreEqual(1, td.StartLocation.Line, "StartLocation.Y"); |
||||
Assert.AreEqual(1, td.StartLocation.Column, "StartLocation.X"); |
||||
AstLocation bodyStartLocation = td.GetChildByRole(AstNode.Roles.LBrace).PrevSibling.EndLocation; |
||||
Assert.AreEqual(1, bodyStartLocation.Line, "BodyStartLocation.Y"); |
||||
Assert.AreEqual(14, bodyStartLocation.Column, "BodyStartLocation.X"); |
||||
Assert.AreEqual(3, td.EndLocation.Line, "EndLocation.Y"); |
||||
Assert.AreEqual(2, td.EndLocation.Column, "EndLocation.Y"); |
||||
} |
||||
|
||||
[Test, Ignore("partial modifier is broken")] |
||||
public void SimplePartialClassTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("partial class MyClass { }"); |
||||
Assert.IsFalse(td.IsNull); |
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("MyClass", td.Name); |
||||
Assert.AreEqual(Modifiers.Partial, td.Modifiers); |
||||
} |
||||
|
||||
[Test, Ignore("nested classes are broken")] |
||||
public void NestedClassesTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("class MyClass { partial class P1 {} public partial class P2 {} static class P3 {} internal static class P4 {} }"); |
||||
Assert.IsFalse(td.IsNull); |
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("MyClass", td.Name); |
||||
Assert.AreEqual(Modifiers.Partial, ((TypeDeclaration)td.Members.ElementAt(0)).Modifiers); |
||||
Assert.AreEqual(Modifiers.Partial | Modifiers.Public, ((TypeDeclaration)td.Members.ElementAt(1)).Modifiers); |
||||
Assert.AreEqual(Modifiers.Static, ((TypeDeclaration)td.Members.ElementAt(2)).Modifiers); |
||||
Assert.AreEqual(Modifiers.Static | Modifiers.Internal, ((TypeDeclaration)td.Members.ElementAt(3)).Modifiers); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleStaticClassTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("static class MyClass { }"); |
||||
Assert.IsFalse(td.IsNull); |
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("MyClass", td.Name); |
||||
Assert.AreEqual(Modifiers.Static, td.Modifiers); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void GenericClassTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("public class G<T> {}"); |
||||
|
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("G", td.Name); |
||||
Assert.AreEqual(Modifiers.Public, td.Modifiers); |
||||
/*Assert.AreEqual(0, td.BaseTypes.Count); |
||||
Assert.AreEqual(1, td.TypeArguments.Count()); |
||||
Assert.AreEqual("T", td.TypeArguments.Single().Name);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
|
||||
[Test, Ignore] |
||||
public void GenericClassWithWhere() |
||||
{ |
||||
string declr = @"
|
||||
public class Test<T> where T : IMyInterface |
||||
{ |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(declr); |
||||
|
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
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);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void ComplexGenericClassTypeDeclarationTest() |
||||
{ |
||||
string declr = @"
|
||||
public class Generic<T, S> : System.IComparable where S : G<T[]> where T : MyNamespace.IMyInterface |
||||
{ |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(declr); |
||||
|
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("Generic", td.Name); |
||||
Assert.AreEqual(Modifiers.Public, td.Modifiers); |
||||
/*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("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);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void ComplexClassTypeDeclarationTest() |
||||
{ |
||||
string declr = @"
|
||||
[MyAttr()] |
||||
public abstract class MyClass : MyBase, Interface1, My.Test.Interface2 |
||||
{ |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(declr); |
||||
|
||||
Assert.AreEqual(ClassType.Class, td.ClassType); |
||||
Assert.AreEqual("MyClass", td.Name); |
||||
Assert.AreEqual(Modifiers.Public | Modifiers.Abstract, td.Modifiers); |
||||
Assert.AreEqual(1, td.Attributes.Count()); |
||||
/* Assert.AreEqual(3, td.BaseTypes.Count); |
||||
Assert.AreEqual("MyBase", td.BaseTypes[0].Type); |
||||
Assert.AreEqual("Interface1", td.BaseTypes[1].Type); |
||||
Assert.AreEqual("My.Test.Interface2", td.BaseTypes[2].Type);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleStructTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("struct MyStruct {}"); |
||||
|
||||
Assert.AreEqual(ClassType.Struct, td.ClassType); |
||||
Assert.AreEqual("MyStruct", td.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleInterfaceTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("interface MyInterface {}"); |
||||
|
||||
Assert.AreEqual(ClassType.Interface, td.ClassType); |
||||
Assert.AreEqual("MyInterface", td.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleEnumTypeDeclarationTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("enum MyEnum {}"); |
||||
|
||||
Assert.AreEqual(ClassType.Enum, td.ClassType); |
||||
Assert.AreEqual("MyEnum", td.Name); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void ContextSensitiveKeywordTest() |
||||
{ |
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("partial class partial<[partial: where] where> where where : partial<where> { }"); |
||||
|
||||
Assert.AreEqual(Modifiers.Partial, td.Modifiers); |
||||
Assert.AreEqual("partial", td.Name); |
||||
|
||||
/* |
||||
Assert.AreEqual(1, td.Templates.Count); |
||||
TemplateDefinition tp = td.Templates[0]; |
||||
Assert.AreEqual("where", tp.Name); |
||||
|
||||
Assert.AreEqual(1, tp.Attributes.Count); |
||||
Assert.AreEqual("partial", tp.Attributes[0].AttributeTarget); |
||||
Assert.AreEqual(1, tp.Attributes[0].Attributes.Count); |
||||
Assert.AreEqual("where", tp.Attributes[0].Attributes[0].Name); |
||||
|
||||
Assert.AreEqual(1, tp.Bases.Count); |
||||
Assert.AreEqual("partial", tp.Bases[0].Type); |
||||
Assert.AreEqual("where", tp.Bases[0].GenericTypes[0].Type);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
[Test] |
||||
public void TypeInNamespaceTest() |
||||
{ |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>("namespace N { class MyClass { } }"); |
||||
|
||||
Assert.AreEqual("N", ns.Name); |
||||
Assert.AreEqual("MyClass", ((TypeDeclaration)ns.Members.Single()).Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void StructInNamespaceTest() |
||||
{ |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>("namespace N { struct MyClass { } }"); |
||||
|
||||
Assert.AreEqual("N", ns.Name); |
||||
Assert.AreEqual("MyClass", ((TypeDeclaration)ns.Members.Single()).Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void EnumInNamespaceTest() |
||||
{ |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>("namespace N { enum MyClass { } }"); |
||||
|
||||
Assert.AreEqual("N", ns.Name); |
||||
Assert.AreEqual("MyClass", ((TypeDeclaration)ns.Members.Single()).Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void InterfaceInNamespaceTest() |
||||
{ |
||||
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal<NamespaceDeclaration>("namespace N { interface MyClass { } }"); |
||||
|
||||
Assert.AreEqual("N", ns.Name); |
||||
Assert.AreEqual("MyClass", ((TypeDeclaration)ns.Members.Single()).Name); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,102 @@
@@ -0,0 +1,102 @@
|
||||
// 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.IO; |
||||
using System.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope |
||||
{ |
||||
[TestFixture] |
||||
public class UsingDeclarationTests |
||||
{ |
||||
[Test] |
||||
[Ignore("error reporting not yet implemented")] |
||||
public void WrongUsingTest() |
||||
{ |
||||
string program = "using\n"; |
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu = parser.Parse(new StringReader(program)); |
||||
Assert.AreEqual(0, cu.Children.Count()); |
||||
Assert.IsTrue(parser.HasErrors); |
||||
} |
||||
|
||||
[Test] |
||||
public void DeclarationTest() |
||||
{ |
||||
string program = "using System;\n" + |
||||
"using My.Name.Space;\n"; |
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu = parser.Parse(new StringReader(program)); |
||||
Assert.IsFalse(parser.HasErrors); |
||||
|
||||
Assert.AreEqual(2, cu.Children.Count()); |
||||
Assert.IsTrue(cu.Children.ElementAt(0) is UsingDeclaration); |
||||
Assert.IsFalse(cu.Children.ElementAt(0) is UsingAliasDeclaration); |
||||
UsingDeclaration ud = (UsingDeclaration)cu.Children.ElementAt(0); |
||||
Assert.AreEqual("System", ud.Namespace); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(1) is UsingDeclaration); |
||||
Assert.IsFalse(cu.Children.ElementAt(1) is UsingAliasDeclaration); |
||||
ud = (UsingDeclaration)cu.Children.ElementAt(1); |
||||
Assert.AreEqual("My.Name.Space", ud.Namespace); |
||||
} |
||||
|
||||
[Test] |
||||
public void UsingAliasDeclarationTest() |
||||
{ |
||||
string program = "using TESTME=System;\n" + |
||||
"using myAlias=My.Name.Space;\n" + |
||||
"using StringCollection = System.Collections.Generic.List<string>;\n"; |
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu = parser.Parse(new StringReader(program)); |
||||
Assert.IsFalse(parser.HasErrors); |
||||
|
||||
Assert.AreEqual(3, cu.Children.Count()); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(0) is UsingAliasDeclaration); |
||||
UsingAliasDeclaration ud = (UsingAliasDeclaration)cu.Children.ElementAt(0); |
||||
Assert.AreEqual("TESTME", ud.Alias); |
||||
Assert.AreEqual("System", ud.Import.ToString()); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(1) is UsingAliasDeclaration); |
||||
ud = (UsingAliasDeclaration)cu.Children.ElementAt(1); |
||||
Assert.AreEqual("myAlias", ud.Alias); |
||||
Assert.AreEqual("My.Name.Space", ud.Import.ToString()); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(2) is UsingAliasDeclaration); |
||||
ud = (UsingAliasDeclaration)cu.Children.ElementAt(2); |
||||
Assert.AreEqual("StringCollection", ud.Alias); |
||||
Assert.AreEqual("System.Collections.Generic.List<string>", ud.Import.ToString()); |
||||
} |
||||
|
||||
[Test] |
||||
public void UsingWithAliasing() |
||||
{ |
||||
string program = "using global::System;\n" + |
||||
"using myAlias=global::My.Name.Space;\n" + |
||||
"using a::b.c;\n"; |
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu = parser.Parse(new StringReader(program)); |
||||
Assert.IsFalse(parser.HasErrors); |
||||
|
||||
Assert.AreEqual(3, cu.Children.Count()); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(0) is UsingDeclaration); |
||||
Assert.IsFalse(cu.Children.ElementAt(0) is UsingAliasDeclaration); |
||||
UsingDeclaration ud = (UsingDeclaration)cu.Children.ElementAt(0); |
||||
Assert.AreEqual("global::System", ud.Namespace); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(1) is UsingAliasDeclaration); |
||||
UsingAliasDeclaration uad = (UsingAliasDeclaration)cu.Children.ElementAt(1); |
||||
Assert.AreEqual("myAlias", uad.Alias); |
||||
Assert.AreEqual("global::My.Name.Space", uad.Import.ToString()); |
||||
|
||||
Assert.IsTrue(cu.Children.ElementAt(2) is UsingDeclaration); |
||||
Assert.IsFalse(cu.Children.ElementAt(2) is UsingAliasDeclaration); |
||||
ud = (UsingDeclaration)cu.Children.ElementAt(2); |
||||
Assert.AreEqual("a::b.c", ud.Namespace); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,71 @@
@@ -0,0 +1,71 @@
|
||||
// Copyright (c) 2010 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.IO; |
||||
using System.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser |
||||
{ |
||||
/// <summary>
|
||||
/// Helper methods for parser unit tests.
|
||||
/// </summary>
|
||||
public class ParseUtilCSharp |
||||
{ |
||||
public static T ParseGlobal<T>(string code, bool expectErrors = false) where T : AstNode |
||||
{ |
||||
CSharpParser parser = new CSharpParser(); |
||||
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 T ParseStatement<T>(string stmt, bool expectErrors = false) where T : AstNode |
||||
{ |
||||
CSharpParser parser = new CSharpParser(); |
||||
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 T ParseExpression<T>(string expr, bool expectErrors = false) where T : AstNode |
||||
{ |
||||
if (expectErrors) Assert.Ignore("errors not yet implemented"); |
||||
|
||||
CSharpParser parser = new CSharpParser(); |
||||
AstNode parsedExpression = parser.ParseExpression(new StringReader(expr)); |
||||
|
||||
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors"); |
||||
|
||||
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 T ParseTypeMember<T>(string expr, bool expectErrors = false) where T : AttributedNode |
||||
{ |
||||
if (expectErrors) Assert.Ignore("errors not yet implemented"); |
||||
|
||||
CSharpParser parser = new CSharpParser(); |
||||
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; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,41 @@
@@ -0,0 +1,41 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class BlockStatementTests |
||||
{ |
||||
[Test] |
||||
public void BlockStatementTest() |
||||
{ |
||||
BlockStatement blockStmt = ParseUtilCSharp.ParseStatement<BlockStatement>("{}"); |
||||
Assert.AreEqual(0, blockStmt.Statements.Count()); |
||||
} |
||||
|
||||
[Test, Ignore("position isn't correct when only parsing a block")] |
||||
public void ComplexBlockStatementPositionTest() |
||||
{ |
||||
string code = @"{
|
||||
WebClient wc = new WebClient(); |
||||
wc.Test(); |
||||
wc.UploadStringCompleted += delegate { |
||||
output.BeginInvoke((MethodInvoker)delegate { |
||||
output.Text += newText; |
||||
}); |
||||
}; |
||||
}";
|
||||
BlockStatement blockStmt = ParseUtilCSharp.ParseStatement<BlockStatement>(code); |
||||
Assert.AreEqual(1, blockStmt.StartLocation.Column); |
||||
Assert.AreEqual(1, blockStmt.StartLocation.Line); |
||||
Assert.AreEqual(2, blockStmt.EndLocation.Column); |
||||
Assert.AreEqual(9, blockStmt.EndLocation.Line); |
||||
|
||||
Assert.AreEqual(3, blockStmt.Statements.Count()); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,45 @@
@@ -0,0 +1,45 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class CheckedStatementTests |
||||
{ |
||||
[Test] |
||||
public void CheckedStatementTest() |
||||
{ |
||||
CheckedStatement checkedStatement = ParseUtilCSharp.ParseStatement<CheckedStatement>("checked { }"); |
||||
Assert.IsFalse(checkedStatement.Body.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void CheckedStatementAndExpressionTest() |
||||
{ |
||||
CheckedStatement checkedStatement = ParseUtilCSharp.ParseStatement<CheckedStatement>("checked { checked(++i).ToString(); }"); |
||||
ExpressionStatement es = (ExpressionStatement)checkedStatement.Body.Statements.Single(); |
||||
CheckedExpression ce = (CheckedExpression)((MemberReferenceExpression)((InvocationExpression)es.Expression).Target).Target; |
||||
Assert.IsTrue(ce.Expression is UnaryOperatorExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void UncheckedStatementTest() |
||||
{ |
||||
UncheckedStatement uncheckedStatement = ParseUtilCSharp.ParseStatement<UncheckedStatement>("unchecked { }"); |
||||
Assert.IsFalse(uncheckedStatement.Body.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void UncheckedStatementAndExpressionTest() |
||||
{ |
||||
UncheckedStatement uncheckedStatement = ParseUtilCSharp.ParseStatement<UncheckedStatement>("unchecked { unchecked(++i).ToString(); }"); |
||||
ExpressionStatement es = (ExpressionStatement)uncheckedStatement.Body.Statements.Single(); |
||||
UncheckedExpression ce = (UncheckedExpression)((MemberReferenceExpression)((InvocationExpression)es.Expression).Target).Target; |
||||
Assert.IsTrue(ce.Expression is UnaryOperatorExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class EmptyStatementTests |
||||
{ |
||||
[Test] |
||||
public void EmptyStatementTest() |
||||
{ |
||||
EmptyStatement emptyStmt = ParseUtilCSharp.ParseStatement<EmptyStatement>(";"); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@
@@ -0,0 +1,26 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class ExpressionStatementTests |
||||
{ |
||||
[Test] |
||||
public void StatementExpressionTest() |
||||
{ |
||||
ExpressionStatement stmtExprStmt = ParseUtilCSharp.ParseStatement<ExpressionStatement>("a = my.Obj.PropCall;"); |
||||
Assert.IsTrue(stmtExprStmt.Expression is AssignmentExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void StatementExpressionTest1() |
||||
{ |
||||
ExpressionStatement stmtExprStmt = ParseUtilCSharp.ParseStatement<ExpressionStatement>("yield.yield();"); |
||||
Assert.IsTrue(stmtExprStmt.Expression is InvocationExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class FixedStatementTests |
||||
{ |
||||
[Test] |
||||
public void FixedStatementTest() |
||||
{ |
||||
FixedStatement fixedStmt = ParseUtilCSharp.ParseStatement<FixedStatement>("fixed (int* ptr = &myIntArr) { }"); |
||||
// TODO : Extend test.
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,59 @@
@@ -0,0 +1,59 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class ForStatementTests |
||||
{ |
||||
[Test] |
||||
public void ForeachStatementTest() |
||||
{ |
||||
ForeachStatement foreachStmt = ParseUtilCSharp.ParseStatement<ForeachStatement>("foreach (int i in myColl) {} "); |
||||
// TODO : Extend test.
|
||||
} |
||||
|
||||
[Test, Ignore("for statement is broken when Initializers.Count()!=1")] |
||||
public void EmptyForStatementTest() |
||||
{ |
||||
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (;;) ;"); |
||||
Assert.AreEqual(0, forStmt.Initializers.Count()); |
||||
Assert.AreEqual(0, forStmt.Iterators.Count()); |
||||
Assert.IsTrue(forStmt.Condition.IsNull); |
||||
Assert.IsTrue(forStmt.EmbeddedStatement is EmptyStatement); |
||||
} |
||||
|
||||
[Test] |
||||
public void ForStatementTest() |
||||
{ |
||||
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (int i = 5; i < 6; ++i) {} "); |
||||
var init = (VariableDeclarationStatement)forStmt.Initializers.Single(); |
||||
Assert.AreEqual("i", init.Variables.Single().Name); |
||||
|
||||
Assert.IsTrue(forStmt.Condition is BinaryOperatorExpression); |
||||
|
||||
var inc = (ExpressionStatement)forStmt.Iterators.Single(); |
||||
Assert.IsTrue(inc.Expression is UnaryOperatorExpression); |
||||
} |
||||
|
||||
[Test, Ignore("for statement is broken when Initializers.Count()!=1")] |
||||
public void ForStatementTestMultipleInitializers() |
||||
{ |
||||
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (i = 0, j = 1; i < 6; ++i) {} "); |
||||
Assert.AreEqual(2, forStmt.Initializers.Count()); |
||||
Assert.IsTrue(forStmt.Iterators.All(i => i is ExpressionStatement)); |
||||
} |
||||
|
||||
[Test, Ignore("for statement is broken when Iterators.Count()!=1")] |
||||
public void ForStatementTestMultipleIterators() |
||||
{ |
||||
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (int i = 5; i < 6; ++i, j--) {} "); |
||||
Assert.AreEqual(2, forStmt.Iterators.Count()); |
||||
Assert.IsTrue(forStmt.Iterators.All(i => i is ExpressionStatement)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,48 @@
@@ -0,0 +1,48 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class GotoStatementTests |
||||
{ |
||||
[Test, Ignore("regular goto statement is broken")] |
||||
public void GotoStatementTest() |
||||
{ |
||||
GotoStatement gotoStmt = ParseUtilCSharp.ParseStatement<GotoStatement>("goto myLabel;"); |
||||
Assert.AreEqual(GotoType.Label, gotoStmt.GotoType); |
||||
Assert.AreEqual("myLabel", gotoStmt.Label); |
||||
} |
||||
|
||||
[Test] |
||||
public void GotoDefaultStatementTest() |
||||
{ |
||||
GotoStatement gotoCaseStmt = ParseUtilCSharp.ParseStatement<GotoStatement>("goto default;"); |
||||
Assert.AreEqual(GotoType.CaseDefault, gotoCaseStmt.GotoType); |
||||
} |
||||
|
||||
[Test] |
||||
public void GotoCaseStatementTest() |
||||
{ |
||||
GotoStatement gotoCaseStmt = ParseUtilCSharp.ParseStatement<GotoStatement>("goto case 6;"); |
||||
Assert.AreEqual(GotoType.Case, gotoCaseStmt.GotoType); |
||||
Assert.IsTrue(gotoCaseStmt.LabelExpression is PrimitiveExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void BreakStatementTest() |
||||
{ |
||||
BreakStatement breakStmt = ParseUtilCSharp.ParseStatement<BreakStatement>("break;"); |
||||
} |
||||
|
||||
[Test] |
||||
public void ContinueStatementTest() |
||||
{ |
||||
ContinueStatement continueStmt = ParseUtilCSharp.ParseStatement<ContinueStatement>("continue;"); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,39 @@
@@ -0,0 +1,39 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class IfElseStatementTests |
||||
{ |
||||
[Test] |
||||
public void SimpleIfStatementTest() |
||||
{ |
||||
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (true) { }"); |
||||
Assert.IsTrue(ifElseStatement.Condition is PrimitiveExpression); |
||||
Assert.IsTrue(ifElseStatement.TrueStatement is BlockStatement); |
||||
Assert.IsTrue(ifElseStatement.FalseStatement.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleIfElseStatementTest() |
||||
{ |
||||
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (true) { } else { }"); |
||||
Assert.IsTrue(ifElseStatement.Condition is PrimitiveExpression); |
||||
Assert.IsTrue(ifElseStatement.TrueStatement is BlockStatement); |
||||
Assert.IsTrue(ifElseStatement.FalseStatement is BlockStatement); |
||||
} |
||||
|
||||
[Test] |
||||
public void IfElseIfStatementTest() |
||||
{ |
||||
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (1) { } else if (2) { } else if (3) { } else { }"); |
||||
Assert.IsTrue(ifElseStatement.Condition is PrimitiveExpression); |
||||
Assert.IsTrue(ifElseStatement.TrueStatement is BlockStatement); |
||||
Assert.IsTrue(ifElseStatement.FalseStatement is IfElseStatement); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,29 @@
@@ -0,0 +1,29 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class LabelStatementTests |
||||
{ |
||||
[Test] |
||||
public void LabelStatementTest() |
||||
{ |
||||
BlockStatement block = ParseUtilCSharp.ParseStatement<BlockStatement>("{ myLabel: ; }"); |
||||
LabelStatement labelStmt = (LabelStatement)block.Statements.First(); |
||||
Assert.AreEqual("myLabel", labelStmt.Label); |
||||
} |
||||
|
||||
[Test] |
||||
public void Label2StatementTest() |
||||
{ |
||||
BlockStatement block = ParseUtilCSharp.ParseStatement<BlockStatement>("{ yield: ; }"); |
||||
LabelStatement labelStmt = (LabelStatement)block.Statements.First(); |
||||
Assert.AreEqual("yield", labelStmt.Label); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class LockStatementTests |
||||
{ |
||||
[Test] |
||||
public void LockStatementTest() |
||||
{ |
||||
LockStatement lockStmt = ParseUtilCSharp.ParseStatement<LockStatement>("lock (myObj) {}"); |
||||
// TODO : Extend test.
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,33 @@
@@ -0,0 +1,33 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class ReturnStatementTests |
||||
{ |
||||
[Test] |
||||
public void EmptyReturnStatementTest() |
||||
{ |
||||
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return;"); |
||||
Assert.IsTrue(returnStatement.Expression.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ReturnStatementTest() |
||||
{ |
||||
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return 5;"); |
||||
Assert.IsTrue(returnStatement.Expression is PrimitiveExpression); |
||||
} |
||||
|
||||
[Test] |
||||
public void ReturnStatementTest1() |
||||
{ |
||||
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return yield;"); |
||||
Assert.IsTrue(returnStatement.Expression is IdentifierExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,20 @@
@@ -0,0 +1,20 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class SwitchStatementTests |
||||
{ |
||||
[Test] |
||||
public void SwitchStatementTest() |
||||
{ |
||||
SwitchStatement switchStmt = ParseUtilCSharp.ParseStatement<SwitchStatement>("switch (a) { case 4: case 5: break; case 6: break; default: break; }"); |
||||
Assert.AreEqual("a", ((IdentifierExpression)switchStmt.Expression).Identifier); |
||||
// TODO: Extend test
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@
@@ -0,0 +1,26 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class ThrowStatementTests |
||||
{ |
||||
[Test] |
||||
public void EmptyThrowStatementTest() |
||||
{ |
||||
ThrowStatement throwStmt = ParseUtilCSharp.ParseStatement<ThrowStatement>("throw;"); |
||||
Assert.IsTrue(throwStmt.Expression.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void ThrowStatementTest() |
||||
{ |
||||
ThrowStatement throwStmt = ParseUtilCSharp.ParseStatement<ThrowStatement>("throw new Exception();"); |
||||
Assert.IsTrue(throwStmt.Expression is ObjectCreateExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,47 @@
@@ -0,0 +1,47 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class TryCatchStatementTests |
||||
{ |
||||
[Test] |
||||
public void SimpleTryCatchStatementTest() |
||||
{ |
||||
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch { } "); |
||||
Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull); |
||||
Assert.AreEqual(1, tryCatchStatement.CatchClauses.Count()); |
||||
Assert.IsTrue(tryCatchStatement.CatchClauses.Single().Type.IsNull); |
||||
Assert.AreEqual(string.Empty, tryCatchStatement.CatchClauses.Single().VariableName); |
||||
} |
||||
|
||||
/* TODO port tests |
||||
[Test] |
||||
public void SimpleTryCatchStatementTest2() |
||||
{ |
||||
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception e) { } "); |
||||
Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull); |
||||
Assert.AreEqual(1, tryCatchStatement.CatchClauses.Count); |
||||
Assert.AreEqual("Exception", tryCatchStatement.CatchClauses[0].TypeReference.Type); |
||||
Assert.AreEqual("e", tryCatchStatement.CatchClauses[0].VariableName); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleTryCatchFinallyStatementTest() |
||||
{ |
||||
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception) { } catch { } finally { } "); |
||||
Assert.IsFalse(tryCatchStatement.FinallyBlock.IsNull); |
||||
Assert.AreEqual(2, tryCatchStatement.CatchClauses.Count); |
||||
Assert.AreEqual("Exception", tryCatchStatement.CatchClauses[0].TypeReference.Type); |
||||
Assert.IsEmpty(tryCatchStatement.CatchClauses[0].VariableName); |
||||
Assert.IsTrue(tryCatchStatement.CatchClauses[1].TypeReference.IsNull); |
||||
Assert.IsEmpty(tryCatchStatement.CatchClauses[1].VariableName); |
||||
} |
||||
*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class UnsafeStatementTests |
||||
{ |
||||
[Test] |
||||
public void UnsafeStatementTest() |
||||
{ |
||||
UnsafeStatement unsafeStatement = ParseUtilCSharp.ParseStatement<UnsafeStatement>("unsafe { }"); |
||||
Assert.IsFalse(unsafeStatement.Body.IsNull); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class UsingStatementTests |
||||
{ |
||||
[Test] |
||||
public void UsingStatementTest() |
||||
{ |
||||
UsingStatement usingStmt = ParseUtilCSharp.ParseStatement<UsingStatement>("using (MyVar var = new MyVar()) { } "); |
||||
// TODO : Extend test.
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,226 @@
@@ -0,0 +1,226 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class VariableDeclarationStatementTests |
||||
{ |
||||
[Test] |
||||
public void VariableDeclarationStatementTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("int a = 5;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count()); |
||||
/*Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("System.Int32", type.Type); |
||||
Assert.AreEqual(5, ((PrimitiveExpression)lvd.Variables[0].Initializer).Value);*/ throw new NotImplementedException(); |
||||
} |
||||
|
||||
/* TODO port unit tests |
||||
[Test] |
||||
public void VoidPointerVariableDeclarationTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("void *a;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("System.Void", type.Type); |
||||
Assert.AreEqual(1, type.PointerNestingLevel); |
||||
} |
||||
|
||||
[Test] |
||||
public void ComplexGenericVariableDeclarationStatementTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("Generic<Namespace.Printable, G<Printable[]> > where = new Generic<Namespace.Printable, G<Printable[]>>();"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("where", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("Generic", type.Type); |
||||
Assert.AreEqual(2, type.GenericTypes.Count); |
||||
Assert.AreEqual("Namespace.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); |
||||
|
||||
// TODO: Check initializer
|
||||
} |
||||
|
||||
[Test] |
||||
public void NestedGenericVariableDeclarationStatementTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("MyType<string>.InnerClass<int>.InnerInnerClass a;"); |
||||
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 GenericWithArrayVariableDeclarationStatementTest1() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("G<int>[] a;"); |
||||
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 GenericWithArrayVariableDeclarationStatementTest2() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("G<int[]> a;"); |
||||
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(new int[] {0}, type.GenericTypes[0].RankSpecifier); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericVariableDeclarationStatementTest2() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("G<G<int> > a;"); |
||||
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 GenericVariableDeclarationStatementTest2WithoutSpace() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("G<G<int>> a;"); |
||||
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 GenericVariableDeclarationStatementTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("G<int> a;"); |
||||
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 SimpleVariableDeclarationStatementTest() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("MyVar var = new MyVar();"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("var", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("MyVar", type.Type); |
||||
// TODO: Check initializer
|
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleVariableDeclarationStatementTest1() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("yield yield = new yield();"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("yield", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("yield", type.Type); |
||||
// TODO: Check initializer
|
||||
} |
||||
|
||||
[Test] |
||||
public void NullableVariableDeclarationStatementTest1() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("int? a;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("System.Nullable", type.Type); |
||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableVariableDeclarationStatementTest2() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("DateTime? a;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("System.Nullable", type.Type); |
||||
Assert.AreEqual("DateTime", type.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableVariableDeclarationStatementTest3() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("DateTime?[] a;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.IsTrue(type.IsArrayType); |
||||
Assert.AreEqual("System.Nullable", type.Type); |
||||
Assert.AreEqual("DateTime", type.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableVariableDeclarationStatementTest4() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("SomeStruct<int?>? a;"); |
||||
Assert.AreEqual(1, lvd.Variables.Count); |
||||
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name); |
||||
TypeReference type = lvd.GetTypeForVariable(0); |
||||
Assert.AreEqual("System.Nullable", type.Type); |
||||
Assert.AreEqual("SomeStruct", type.GenericTypes[0].Type); |
||||
Assert.AreEqual("System.Nullable", type.GenericTypes[0].GenericTypes[0].Type); |
||||
Assert.AreEqual("System.Int32", type.GenericTypes[0].GenericTypes[0].GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void PositionTestWithoutModifier() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("\ndouble w = 7;"); |
||||
Assert.AreEqual(2, lvd.StartLocation.Line); |
||||
Assert.AreEqual(1, lvd.StartLocation.Column); |
||||
Assert.AreEqual(2, lvd.EndLocation.Line); |
||||
Assert.AreEqual(14, lvd.EndLocation.Column); |
||||
} |
||||
|
||||
[Test] |
||||
public void PositionTestWithModifier() |
||||
{ |
||||
VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("\nconst double w = 7;"); |
||||
Assert.AreEqual(Modifiers.Const, lvd.Modifier); |
||||
Assert.AreEqual(2, lvd.StartLocation.Line); |
||||
Assert.AreEqual(1, lvd.StartLocation.Column); |
||||
Assert.AreEqual(2, lvd.EndLocation.Line); |
||||
Assert.AreEqual(20, lvd.EndLocation.Column); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,30 @@
@@ -0,0 +1,30 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class WhileStatementTests |
||||
{ |
||||
[Test] |
||||
public void WhileStatementTest() |
||||
{ |
||||
WhileStatement loopStmt = ParseUtilCSharp.ParseStatement<WhileStatement>("while (true) { }"); |
||||
Assert.AreEqual(WhilePosition.Begin, loopStmt.WhilePosition); |
||||
Assert.IsTrue(loopStmt.Condition is PrimitiveExpression); |
||||
Assert.IsTrue(loopStmt.EmbeddedStatement is BlockStatement); |
||||
} |
||||
|
||||
[Test] |
||||
public void DoWhileStatementTest() |
||||
{ |
||||
WhileStatement loopStmt = ParseUtilCSharp.ParseStatement<WhileStatement>("do { } while (true);"); |
||||
Assert.AreEqual(WhilePosition.End, loopStmt.WhilePosition); |
||||
Assert.IsTrue(loopStmt.Condition is PrimitiveExpression); |
||||
Assert.IsTrue(loopStmt.EmbeddedStatement is BlockStatement); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,41 @@
@@ -0,0 +1,41 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.Statements |
||||
{ |
||||
[TestFixture] |
||||
public class YieldStatementTests |
||||
{ |
||||
[Test] |
||||
public void YieldReturnStatementTest() |
||||
{ |
||||
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement<YieldStatement>("yield return \"Foo\";"); |
||||
PrimitiveExpression expr = (PrimitiveExpression)yieldStmt.Expression; |
||||
Assert.AreEqual("Foo", expr.Value); |
||||
} |
||||
|
||||
[Test] |
||||
public void YieldBreakStatementTest() |
||||
{ |
||||
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement<YieldStatement>("yield break;"); |
||||
Assert.IsTrue(yieldStmt.Expression.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void YieldAsVariableTest() |
||||
{ |
||||
ExpressionStatement se = ParseUtilCSharp.ParseStatement<ExpressionStatement>("yield = 3;"); |
||||
AssignmentExpression ae = se.Expression as AssignmentExpression; |
||||
|
||||
Assert.AreEqual(AssignmentOperatorType.Assign, ae.Operator); |
||||
|
||||
Assert.IsTrue(ae.Left is IdentifierExpression); |
||||
Assert.AreEqual("yield", ((IdentifierExpression)ae.Left).Identifier); |
||||
Assert.IsTrue(ae.Right is PrimitiveExpression); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,52 @@
@@ -0,0 +1,52 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class ConstructorDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void ConstructorDeclarationTest1() |
||||
{ |
||||
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() {}"); |
||||
Assert.IsTrue(cd.Initializer.IsNull); |
||||
} |
||||
|
||||
[Test, Ignore("Constructor initializer is broken")] |
||||
public void ConstructorDeclarationTest2() |
||||
{ |
||||
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : this(5) {}"); |
||||
Assert.AreEqual(ConstructorInitializerType.This, cd.Initializer.ConstructorInitializerType); |
||||
Assert.AreEqual(1, cd.Initializer.Arguments.Count()); |
||||
} |
||||
|
||||
[Test, Ignore("Constructor initializer is broken")] |
||||
public void ConstructorDeclarationTest3() |
||||
{ |
||||
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : base(1, 2, 3) {}"); |
||||
Assert.AreEqual(ConstructorInitializerType.Base, cd.Initializer.ConstructorInitializerType); |
||||
Assert.AreEqual(3, cd.Initializer.Arguments.Count()); |
||||
} |
||||
|
||||
[Test] |
||||
public void StaticConstructorDeclarationTest1() |
||||
{ |
||||
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("static MyClass() {}"); |
||||
Assert.IsTrue(cd.Initializer.IsNull); |
||||
Assert.AreEqual(Modifiers.Static, cd.Modifiers); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExternStaticConstructorDeclarationTest() |
||||
{ |
||||
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("extern static MyClass();"); |
||||
Assert.IsTrue(cd.Initializer.IsNull); |
||||
Assert.AreEqual(Modifiers.Static | Modifiers.Extern, cd.Modifiers); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,32 @@
@@ -0,0 +1,32 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class DestructorDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void DestructorDeclarationTest() |
||||
{ |
||||
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("~MyClass() {}"); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExternDestructorDeclarationTest() |
||||
{ |
||||
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("extern ~MyClass();"); |
||||
Assert.AreEqual(Modifiers.Extern, dd.Modifiers); |
||||
} |
||||
|
||||
[Test] |
||||
public void UnsafeDestructorDeclarationTest() |
||||
{ |
||||
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("unsafe ~MyClass() {}"); |
||||
Assert.AreEqual(Modifiers.Unsafe, dd.Modifiers); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,84 @@
@@ -0,0 +1,84 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class EventDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void SimpleEventDeclarationTest() |
||||
{ |
||||
CustomEventDeclaration ed = ParseUtilCSharp.ParseTypeMember<CustomEventDeclaration>("event System.EventHandler MyEvent;"); |
||||
Assert.AreEqual("MyEvent", ed.Name); |
||||
//Assert.AreEqual("System.EventHandler", ed.TypeReference.Type);
|
||||
Assert.Ignore(); // check type
|
||||
|
||||
Assert.IsTrue(ed.AddAccessor.IsNull); |
||||
Assert.IsTrue(ed.RemoveAccessor.IsNull); |
||||
} |
||||
|
||||
/* TODO Port tests |
||||
[Test] |
||||
public void MultipleEventDeclarationTest() |
||||
{ |
||||
TypeDeclaration t = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("class C { public event EventHandler A, B; }"); |
||||
Assert.AreEqual(2, t.Children.Count); |
||||
|
||||
EventDeclaration ed = (EventDeclaration)t.Children[0]; |
||||
Assert.AreEqual(Modifiers.Public, ed.Modifier); |
||||
Assert.AreEqual("EventHandler", ed.TypeReference.Type); |
||||
Assert.AreEqual("A", ed.Name); |
||||
|
||||
ed = (EventDeclaration)t.Children[1]; |
||||
Assert.AreEqual(Modifiers.Public, ed.Modifier); |
||||
Assert.AreEqual("EventHandler", ed.TypeReference.Type); |
||||
Assert.AreEqual("B", ed.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void EventImplementingInterfaceDeclarationTest() |
||||
{ |
||||
EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event EventHandler MyInterface.MyEvent;"); |
||||
|
||||
Assert.AreEqual("MyEvent", ed.Name); |
||||
Assert.AreEqual("EventHandler", ed.TypeReference.Type); |
||||
|
||||
Assert.IsFalse(ed.HasAddRegion); |
||||
Assert.IsFalse(ed.HasRemoveRegion); |
||||
|
||||
Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type); |
||||
Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName); |
||||
} |
||||
|
||||
[Test] |
||||
public void EventImplementingGenericInterfaceDeclarationTest() |
||||
{ |
||||
EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event EventHandler MyInterface<string>.MyEvent;"); |
||||
|
||||
Assert.AreEqual("MyEvent", ed.Name); |
||||
Assert.AreEqual("EventHandler", ed.TypeReference.Type); |
||||
|
||||
Assert.IsFalse(ed.HasAddRegion); |
||||
Assert.IsFalse(ed.HasRemoveRegion); |
||||
|
||||
Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type); |
||||
Assert.AreEqual("System.String", ed.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); |
||||
Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AddRemoveEventDeclarationTest() |
||||
{ |
||||
EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event System.EventHandler MyEvent { add { } remove { } }"); |
||||
Assert.AreEqual("MyEvent", ed.Name); |
||||
Assert.AreEqual("System.EventHandler", ed.TypeReference.Type); |
||||
|
||||
Assert.IsTrue(ed.HasAddRegion); |
||||
Assert.IsTrue(ed.HasRemoveRegion); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,27 @@
@@ -0,0 +1,27 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture, Ignore] |
||||
public class FieldDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void SimpleFieldDeclarationTest() |
||||
{ |
||||
throw new NotImplementedException(); |
||||
/* |
||||
FieldDeclaration fd = ParseUtilCSharp.ParseTypeMember<FieldDeclaration>("int[,,,] myField;"); |
||||
Assert.AreEqual("System.Int32", fd.TypeReference.Type); |
||||
Assert.AreEqual(new int[] { 3 } , fd.TypeReference.RankSpecifier); |
||||
Assert.AreEqual(1, fd.Fields.Count); |
||||
|
||||
Assert.AreEqual("myField", ((VariableDeclaration)fd.Fields[0]).Name);*/ |
||||
} |
||||
|
||||
// TODO add more tests
|
||||
} |
||||
} |
||||
@ -0,0 +1,47 @@
@@ -0,0 +1,47 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class IndexerDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void IndexerDeclarationTest() |
||||
{ |
||||
IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int this[int a, string b] { get { } set { } }"); |
||||
Assert.AreEqual(2, id.Parameters.Count()); |
||||
Assert.IsNotNull(id.Getter, "No get region found!"); |
||||
Assert.IsNotNull(id.Setter, "No set region found!"); |
||||
} |
||||
|
||||
[Test, Ignore("type reference is not yet implemented")] |
||||
public void IndexerImplementingInterfaceTest() |
||||
{ |
||||
IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int MyInterface.this[int a, string b] { get { } set { } }"); |
||||
Assert.AreEqual(2, id.Parameters.Count()); |
||||
Assert.IsNotNull(id.Getter, "No get region found!"); |
||||
Assert.IsNotNull(id.Setter, "No set region found!"); |
||||
|
||||
Assert.AreEqual("MyInterface", id.PrivateImplementationType); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void IndexerImplementingGenericInterfaceTest() |
||||
{ |
||||
throw new NotImplementedException(); |
||||
/* |
||||
IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int MyInterface<string>.this[int a, string b] { get { } set { } }"); |
||||
Assert.AreEqual(2, id.Parameters.Count); |
||||
Assert.IsNotNull(id.GetAccessor, "No get region found!"); |
||||
Assert.IsNotNull(id.SetAccessor, "No set region found!"); |
||||
|
||||
Assert.AreEqual("MyInterface", id.InterfaceImplementations[0].InterfaceType.Type); |
||||
Assert.AreEqual("System.String", id.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);*/ |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,303 @@
@@ -0,0 +1,303 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class MethodDeclarationTests |
||||
{ |
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void SimpleMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod() {} "); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(0, md.Parameters.Count()); |
||||
Assert.IsFalse(md.IsExtensionMethod); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void AbstractMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("abstract void MyMethod();"); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(0, md.Parameters.Count()); |
||||
Assert.IsFalse(md.IsExtensionMethod); |
||||
Assert.IsTrue(md.Body.IsNull); |
||||
Assert.AreEqual(Modifiers.Abstract, md.Modifiers); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void DefiningPartialMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod();"); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(0, md.Parameters.Count()); |
||||
Assert.IsFalse(md.IsExtensionMethod); |
||||
Assert.IsTrue(md.Body.IsNull); |
||||
Assert.AreEqual(Modifiers.Partial, md.Modifiers); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void ImplementingPartialMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod() { }"); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(0, md.Parameters.Count()); |
||||
Assert.IsFalse(md.IsExtensionMethod); |
||||
Assert.IsFalse(md.Body.IsNull); |
||||
Assert.AreEqual(Modifiers.Partial, md.Modifiers); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleMethodRegionTest() |
||||
{ |
||||
const string program = @"
|
||||
void MyMethod() |
||||
{ |
||||
OtherMethod(); |
||||
} |
||||
";
|
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(program); |
||||
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); |
||||
Assert.AreEqual(5, md.EndLocation.Line, "EndLocation.Y"); |
||||
Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X"); |
||||
Assert.AreEqual(4, md.EndLocation.Column, "EndLocation.X"); |
||||
} |
||||
|
||||
[Test] |
||||
public void MethodWithModifiersRegionTest() |
||||
{ |
||||
const string program = @"
|
||||
public static void MyMethod() |
||||
{ |
||||
OtherMethod(); |
||||
} |
||||
";
|
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(program); |
||||
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); |
||||
Assert.AreEqual(5, md.EndLocation.Line, "EndLocation.Y"); |
||||
Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X"); |
||||
} |
||||
|
||||
[Test] |
||||
public void MethodWithUnnamedParameterDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod(int) {} ", true); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(1, md.Parameters.Count()); |
||||
//Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
|
||||
} |
||||
|
||||
/* TODO: port unit tests |
||||
[Test] |
||||
public void GenericVoidMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod<T>(T a) {} "); |
||||
Assert.AreEqual("System.Void", md.ReturnType); |
||||
Assert.AreEqual(1, md.Parameters.Count()); |
||||
Assert.AreEqual("T", md.Parameters.Single().Type); |
||||
Assert.AreEqual("a", md.Parameters.Single().Name); |
||||
|
||||
Assert.AreEqual(1, md.TypeParameters.Count()); |
||||
Assert.AreEqual("T", md.Templates[0].Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void GenericMethodDeclarationTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("T MyMethod<T>(T a) {} "); |
||||
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 GenericMethodDeclarationWithConstraintTest() |
||||
{ |
||||
string program = "T MyMethod<T>(T a) where T : ISomeInterface {} "; |
||||
MethodDeclaration md = ParseUtilCSharp.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 GenericMethodInInterface() |
||||
{ |
||||
const string program = @"interface MyInterface {
|
||||
T MyMethod<T>(T a) where T : ISomeInterface; |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.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 GenericVoidMethodInInterface() |
||||
{ |
||||
const string program = @"interface MyInterface {
|
||||
void MyMethod<T>(T a) where T : ISomeInterface; |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.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 ShadowingMethodInInterface() |
||||
{ |
||||
const string program = @"interface MyInterface : IDisposable {
|
||||
new void Dispose(); |
||||
} |
||||
";
|
||||
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program); |
||||
MethodDeclaration md = (MethodDeclaration)td.Children[0]; |
||||
Assert.AreEqual("System.Void", md.TypeReference.Type); |
||||
Assert.AreEqual(0, md.Parameters.Count); |
||||
Assert.AreEqual(Modifiers.New, md.Modifier); |
||||
} |
||||
|
||||
[Test] |
||||
public void MethodImplementingInterfaceTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("int MyInterface.MyMethod() {} "); |
||||
Assert.AreEqual("System.Int32", md.TypeReference.Type); |
||||
|
||||
Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void MethodImplementingGenericInterfaceTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("int MyInterface<string>.MyMethod() {} "); |
||||
Assert.AreEqual("System.Int32", md.TypeReference.Type); |
||||
|
||||
Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); |
||||
Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void VoidMethodImplementingInterfaceTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyInterface.MyMethod() {} "); |
||||
Assert.AreEqual("System.Void", md.TypeReference.Type); |
||||
|
||||
Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void VoidMethodImplementingGenericInterfaceTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyInterface<string>.MyMethod() {} "); |
||||
Assert.AreEqual("System.Void", md.TypeReference.Type); |
||||
|
||||
Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); |
||||
Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void IncompleteConstraintsTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>( |
||||
"void a<T>() where T { }", true // expect errors
|
||||
); |
||||
Assert.AreEqual("a", md.Name); |
||||
Assert.AreEqual(1, md.Templates.Count); |
||||
Assert.AreEqual("T", md.Templates[0].Name); |
||||
Assert.AreEqual(0, md.Templates[0].Bases.Count); |
||||
} |
||||
|
||||
[Test] |
||||
public void ExtensionMethodTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>( |
||||
"public static int ToInt32(this string s) { return int.Parse(s); }" |
||||
); |
||||
Assert.AreEqual("ToInt32", md.Name); |
||||
Assert.IsTrue(md.IsExtensionMethod); |
||||
Assert.AreEqual("s", md.Parameters[0].ParameterName); |
||||
Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); |
||||
} |
||||
*/ |
||||
|
||||
[Test] |
||||
public void VoidExtensionMethodTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>( |
||||
"public static void Print(this string s) { Console.WriteLine(s); }" |
||||
); |
||||
Assert.AreEqual("Print", md.Name); |
||||
Assert.AreEqual("s", md.Parameters.First().Name); |
||||
Assert.AreEqual(ParameterModifier.This, md.Parameters.First().ParameterModifier); |
||||
Assert.AreEqual("string", ((PrimitiveType)md.Parameters.First().Type).Keyword); |
||||
Assert.IsTrue(md.IsExtensionMethod); |
||||
} |
||||
|
||||
/* TODO |
||||
[Test] |
||||
public void MethodWithEmptyAssignmentErrorInBody() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>( |
||||
"void A\n" + |
||||
"{\n" + |
||||
"int a = 3;\n" + |
||||
" = 4;\n" + |
||||
"}", true // expect errors
|
||||
); |
||||
Assert.AreEqual("A", md.Name); |
||||
Assert.AreEqual(new Location(1, 2), md.Body.StartLocation); |
||||
Assert.AreEqual(new Location(2, 5), md.Body.EndLocation); |
||||
} |
||||
|
||||
[Test] |
||||
public void OptionalParameterTest() |
||||
{ |
||||
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>( |
||||
"public void Foo(string bar = null, int baz = 0) { }" |
||||
); |
||||
Assert.AreEqual("Foo", md.Name); |
||||
|
||||
Assert.AreEqual("bar", md.Parameters[0].ParameterName); |
||||
Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); |
||||
Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[0].ParamModifier); |
||||
Assert.IsNull(((PrimitiveExpression)md.Parameters[0].DefaultValue).Value); |
||||
|
||||
Assert.AreEqual("baz", md.Parameters[1].ParameterName); |
||||
Assert.AreEqual("System.Int32", md.Parameters[1].TypeReference.Type); |
||||
Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[1].ParamModifier); |
||||
Assert.AreEqual(0, ((PrimitiveExpression)md.Parameters[1].DefaultValue).Value); |
||||
}*/ |
||||
} |
||||
} |
||||
@ -0,0 +1,53 @@
@@ -0,0 +1,53 @@
|
||||
// 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.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class OperatorDeclarationTests |
||||
{ |
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void ImplictOperatorDeclarationTest() |
||||
{ |
||||
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static implicit operator double(MyObject f) { return 0.5d; }"); |
||||
Assert.AreEqual(OperatorType.Implicit, od.OperatorType); |
||||
Assert.AreEqual(1, od.Parameters.Count()); |
||||
Assert.AreEqual("System.Double", od.ReturnType); |
||||
Assert.AreEqual("op_Implicit", od.Name); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void ExplicitOperatorDeclarationTest() |
||||
{ |
||||
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static explicit operator double(MyObject f) { return 0.5d; }"); |
||||
Assert.AreEqual(OperatorType.Explicit, od.OperatorType); |
||||
Assert.AreEqual(1, od.Parameters.Count()); |
||||
Assert.AreEqual("System.Double", od.ReturnType); |
||||
Assert.AreEqual("op_Explicit", od.Name); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void BinaryPlusOperatorDeclarationTest() |
||||
{ |
||||
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a, MyObject b) {}"); |
||||
Assert.AreEqual(OperatorType.Addition, od.OperatorType); |
||||
Assert.AreEqual(2, od.Parameters.Count()); |
||||
Assert.AreEqual("MyObject", od.ReturnType); |
||||
Assert.AreEqual("op_Addition", od.Name); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void UnaryPlusOperatorDeclarationTest() |
||||
{ |
||||
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a) {}"); |
||||
Assert.AreEqual(OperatorType.UnaryPlus, od.OperatorType); |
||||
Assert.AreEqual(1, od.Parameters.Count()); |
||||
Assert.AreEqual("MyObject", od.ReturnType); |
||||
Assert.AreEqual("op_UnaryPlus", od.Name); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,93 @@
@@ -0,0 +1,93 @@
|
||||
// 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.IO; |
||||
using System.Linq; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers |
||||
{ |
||||
[TestFixture] |
||||
public class PropertyDeclarationTests |
||||
{ |
||||
[Test] |
||||
public void SimpleGetSetPropertyDeclarationTest() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} set {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsFalse(pd.Getter.IsNull); |
||||
Assert.IsFalse(pd.Setter.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void GetSetPropertyDeclarationWithAccessorModifiers() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { private get {} protected internal set {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsFalse(pd.Getter.IsNull); |
||||
Assert.IsFalse(pd.Setter.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleGetPropertyDeclarationTest() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsFalse(pd.Getter.IsNull); |
||||
Assert.IsTrue(pd.Setter.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleSetPropertyDeclarationTest() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { set {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsTrue(pd.Getter.IsNull); |
||||
Assert.IsFalse(pd.Setter.IsNull); |
||||
} |
||||
|
||||
[Test] |
||||
public void PropertyRegionTest() |
||||
{ |
||||
const string code = "class T {\n\tint Prop {\n\t\tget { return f; }\n\t\tset { f = value; }\n\t}\n}\n"; |
||||
int line2Pos = code.IndexOf("\tint Prop"); |
||||
int line3Pos = code.IndexOf("\t\tget"); |
||||
int line4Pos = code.IndexOf("\t\tset"); |
||||
|
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu = parser.Parse(new StringReader(code)); |
||||
PropertyDeclaration pd = (PropertyDeclaration)cu.Children.Single().GetChildByRole(TypeDeclaration.MemberRole); |
||||
Assert.AreEqual(new AstLocation(2, code.IndexOf("{\n\t\tget") - line2Pos + 1), pd.GetChildByRole(AstNode.Roles.LBrace).StartLocation); |
||||
Assert.AreEqual(new AstLocation(5, 3), pd.EndLocation); |
||||
Assert.AreEqual(new AstLocation(3, code.IndexOf("{ return") - line3Pos + 1), pd.Getter.Body.StartLocation); |
||||
Assert.AreEqual(new AstLocation(3, code.IndexOf("}\n\t\tset") + 1 - line3Pos + 1), pd.Getter.Body.EndLocation); |
||||
Assert.AreEqual(new AstLocation(4, code.IndexOf("{ f =") - line4Pos + 1), pd.Setter.Body.StartLocation); |
||||
Assert.AreEqual(new AstLocation(4, code.IndexOf("}\n\t}") + 1 - line4Pos + 1), pd.Setter.Body.EndLocation); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void PropertyImplementingInterfaceTest() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface.MyProperty { get {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsFalse(pd.Getter.IsNull); |
||||
Assert.IsTrue(pd.Setter.IsNull); |
||||
|
||||
Assert.AreEqual("MyInterface", pd.PrivateImplementationType); |
||||
} |
||||
|
||||
[Test, Ignore("type references not yet implemented")] |
||||
public void PropertyImplementingGenericInterfaceTest() |
||||
{ |
||||
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface<string>.MyProperty { get {} } "); |
||||
Assert.AreEqual("MyProperty", pd.Name); |
||||
Assert.IsFalse(pd.Getter.IsNull); |
||||
Assert.IsTrue(pd.Setter.IsNull); |
||||
|
||||
throw new NotImplementedException(); |
||||
//Assert.AreEqual("MyInterface", pd.InterfaceImplementations[0].InterfaceType.Type);
|
||||
//Assert.AreEqual("System.String", pd.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
|
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@
@@ -0,0 +1,36 @@
|
||||
// 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.IO; |
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Parser |
||||
{ |
||||
[TestFixture, Ignore("TypeSystemConvertVisitor is not complete yet")] |
||||
public class TypeSystemConvertVisitorTests : TypeSystemTests |
||||
{ |
||||
ITypeResolveContext ctx = CecilLoaderTests.Mscorlib; |
||||
|
||||
[TestFixtureSetUp] |
||||
public void FixtureSetUp() |
||||
{ |
||||
const string fileName = "TypeSystemTests.TestCase.cs"; |
||||
|
||||
CSharpParser parser = new CSharpParser(); |
||||
CompilationUnit cu; |
||||
using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) { |
||||
cu = parser.Parse(s); |
||||
} |
||||
|
||||
testCasePC = new SimpleProjectContent(); |
||||
TypeSystemConvertVisitor visitor = new TypeSystemConvertVisitor(testCasePC, fileName); |
||||
cu.AcceptVisitor(visitor, null); |
||||
ParsedFile parsedFile = visitor.ParsedFile; |
||||
((SimpleProjectContent)testCasePC).UpdateProjectContent(null, parsedFile.TopLevelTypeDefinitions, null, null); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,96 @@
@@ -0,0 +1,96 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture, Ignore("DOM for attributes is incomplete")] |
||||
public class AttributeTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void NamespaceInAttributeContext() |
||||
{ |
||||
string program = "using System; [$System.Runtime$.CompilerServices.IndexerName(\"bla\")] class Test { }"; |
||||
NamespaceResolveResult result = Resolve<NamespaceResolveResult>(program); |
||||
Assert.AreEqual("System.Runtime", result.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AttributeWithShortName() |
||||
{ |
||||
string program = "using System; [$Obsolete$] class Test {}"; |
||||
|
||||
TypeResolveResult result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("System.ObsoleteAttribute", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void QualifiedAttributeWithShortName() |
||||
{ |
||||
string program = "using System; [$System.Obsolete$] class Test {}"; |
||||
|
||||
TypeResolveResult result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("System.ObsoleteAttribute", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AttributeConstructor1() |
||||
{ |
||||
string program = "using System; [$LoaderOptimization(3)$] class Test { }"; |
||||
var mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("System.LoaderOptimization.#ctor", mrr.Member.FullName); |
||||
Assert.AreEqual("System.Byte", (mrr.Member as IMethod).Parameters[0].Type.Resolve(context).FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AttributeConstructor2() |
||||
{ |
||||
string program = "using System; [$LoaderOptimization(LoaderOptimization.NotSpecified)$] class Test { }"; |
||||
var mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("System.LoaderOptimization.#ctor", mrr.Member.FullName); |
||||
Assert.AreEqual("System.LoaderOptimization", (mrr.Member as IMethod).Parameters[0].Type.Resolve(context).FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AttributeArgumentInClassContext1() |
||||
{ |
||||
string program = @"using System;
|
||||
[AttributeUsage($XXX$)] class MyAttribute : Attribute { |
||||
public const AttributeTargets XXX = AttributeTargets.All; |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("MyAttribute.XXX", result.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AttributeArgumentInClassContext2() |
||||
{ |
||||
string program = @"using System; namespace MyNamespace {
|
||||
[SomeAttribute($E.A$)] class Test { } |
||||
enum E { A, B } |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("MyNamespace.E.A", result.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void SD_1384() |
||||
{ |
||||
string program = @"using System;
|
||||
class Flags { |
||||
[Flags] |
||||
enum $Test$ { } |
||||
}";
|
||||
TypeResolveResult result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Flags.Test", result.Type.FullName); |
||||
|
||||
var rt = result.Type.GetDefinition().Attributes[0].AttributeType.Resolve(context); |
||||
Assert.AreEqual("System.FlagsAttribute", rt.FullName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,392 @@
@@ -0,0 +1,392 @@
|
||||
// Copyright (c) 2010 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
// assign short name to the fake reflection type
|
||||
using dynamic = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Dynamic; |
||||
|
||||
[TestFixture] |
||||
public unsafe class BinaryOperatorTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void Multiplication() |
||||
{ |
||||
AssertType(typeof(int), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeResult(typeof(int)), MakeResult(typeof(int)))); |
||||
|
||||
AssertType(typeof(float), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeResult(typeof(int)), MakeConstant(0.0f))); |
||||
|
||||
AssertConstant(3.0f, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeConstant(1.5f), MakeConstant(2))); |
||||
|
||||
AssertConstant(6, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeConstant((byte)2), MakeConstant((byte)3))); |
||||
|
||||
AssertType(typeof(long?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeResult(typeof(uint?)), MakeResult(typeof(int?)))); |
||||
|
||||
AssertError(typeof(decimal), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Multiply, MakeResult(typeof(float)), MakeResult(typeof(decimal)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void Addition() |
||||
{ |
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(short)), MakeResult(typeof(byte?)))); |
||||
|
||||
AssertConstant(3.0, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(1.0f), MakeConstant(2.0))); |
||||
|
||||
AssertConstant(StringComparison.Ordinal, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(StringComparison.InvariantCulture), MakeConstant(2))); |
||||
|
||||
AssertConstant(StringComparison.OrdinalIgnoreCase, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant((short)3), MakeConstant(StringComparison.InvariantCulture))); |
||||
|
||||
AssertConstant("Text", resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant("Te"), MakeConstant("xt"))); |
||||
|
||||
AssertConstant("", resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(null), resolver.ResolveCast(ResolveType(typeof(string)), MakeConstant(null)))); |
||||
|
||||
AssertError(typeof(ReflectionHelper.Null), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(null), MakeConstant(null))); |
||||
|
||||
AssertType(typeof(Action), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(Action)), MakeResult(typeof(Action)))); |
||||
|
||||
AssertType(typeof(Action<string>), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(Action<object>)), MakeResult(typeof(Action<string>)))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(Action<int>)), MakeResult(typeof(Action<long>))).IsError); |
||||
|
||||
AssertType(typeof(StringComparison?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(StringComparison?)), MakeResult(typeof(int)))); |
||||
|
||||
AssertType(typeof(StringComparison?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(int?)), MakeResult(typeof(StringComparison)))); |
||||
|
||||
AssertType(typeof(long?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(int?)), MakeResult(typeof(uint?)))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(ushort?)), MakeResult(typeof(ushort?)))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(null), MakeConstant(null)).IsError); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(1), MakeConstant(null))); |
||||
|
||||
AssertType(typeof(int*), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(int*)), MakeConstant(1))); |
||||
|
||||
AssertType(typeof(byte*), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeResult(typeof(long)), MakeResult(typeof(byte*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void AdditionWithOverflow() |
||||
{ |
||||
resolver.CheckForOverflow = false; |
||||
AssertConstant(int.MinValue, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(int.MaxValue), MakeConstant(1))); |
||||
|
||||
resolver.CheckForOverflow = true; |
||||
AssertError(typeof(int), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Add, MakeConstant(int.MaxValue), MakeConstant(1))); |
||||
} |
||||
|
||||
|
||||
[Test] |
||||
public void Subtraction() |
||||
{ |
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(short)), MakeResult(typeof(byte?)))); |
||||
|
||||
AssertConstant(-1.0, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeConstant(1.0f), MakeConstant(2.0))); |
||||
|
||||
AssertConstant(StringComparison.InvariantCulture, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeConstant(StringComparison.Ordinal), MakeConstant(2))); |
||||
|
||||
AssertConstant(3, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeConstant(StringComparison.OrdinalIgnoreCase), MakeConstant(StringComparison.InvariantCulture))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeConstant("Te"), MakeConstant("xt")).IsError); |
||||
|
||||
AssertType(typeof(Action), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(Action)), MakeResult(typeof(Action)))); |
||||
|
||||
AssertType(typeof(Action<string>), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(Action<object>)), MakeResult(typeof(Action<string>)))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(Action<int>)), MakeResult(typeof(Action<long>))).IsError); |
||||
|
||||
AssertType(typeof(StringComparison?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(StringComparison?)), MakeResult(typeof(int)))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(StringComparison?)), MakeResult(typeof(StringComparison)))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(int?)), MakeResult(typeof(StringComparison))).IsError); |
||||
|
||||
AssertType(typeof(byte*), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(byte*)), MakeResult(typeof(uint)))); |
||||
|
||||
AssertType(typeof(long), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Subtract, MakeResult(typeof(byte*)), MakeResult(typeof(byte*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShiftTest() |
||||
{ |
||||
AssertConstant(6, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ShiftLeft, MakeConstant(3), MakeConstant(1))); |
||||
|
||||
AssertConstant(ulong.MaxValue >> 2, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ShiftRight, MakeConstant(ulong.MaxValue), MakeConstant(2))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ShiftLeft, MakeResult(typeof(ushort?)), MakeConstant(1))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ShiftLeft, MakeConstant(null), MakeConstant(1))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ShiftLeft, MakeConstant(null), MakeConstant(null))); |
||||
} |
||||
|
||||
[Test] |
||||
public void Equality() |
||||
{ |
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(3), MakeConstant(3))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(3), MakeConstant(3.0))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(2.9), MakeConstant(3))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(double.NaN), MakeConstant(double.NaN))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(float.NaN), MakeConstant(float.NaN))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant("A"), MakeConstant("B"))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant("A"), MakeConstant("A"))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(""), MakeConstant(null))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(null), MakeConstant(null))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(1), MakeConstant(null))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(null), MakeConstant('a'))); |
||||
|
||||
AssertType(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeResult(typeof(int*)), MakeResult(typeof(uint*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void Inequality() |
||||
{ |
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(3), MakeConstant(3))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(3), MakeConstant(3.0))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(2.9), MakeConstant(3))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(double.NaN), MakeConstant(double.NaN))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(float.NaN), MakeConstant(double.NaN))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(float.NaN), MakeConstant(float.NaN))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant("A"), MakeConstant("B"))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant("A"), MakeConstant("A"))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(""), MakeConstant(null))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(null), MakeConstant(null))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(1), MakeConstant(null))); |
||||
|
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeConstant(null), MakeConstant('a'))); |
||||
|
||||
AssertType(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.InEquality, MakeResult(typeof(int*)), MakeResult(typeof(uint*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void EqualityEnum() |
||||
{ |
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(0), MakeConstant(StringComparison.Ordinal))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(0), MakeConstant(StringComparison.Ordinal))); |
||||
|
||||
Assert.IsFalse(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.Equality, MakeConstant(StringComparison.Ordinal), MakeConstant(1)).IsCompileTimeConstant); |
||||
} |
||||
|
||||
[Test] |
||||
public void RelationalOperators() |
||||
{ |
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LessThan, MakeConstant(0), MakeConstant(0))); |
||||
|
||||
AssertType(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LessThan, MakeResult(typeof(int*)), MakeResult(typeof(uint*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void RelationalEnum() |
||||
{ |
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LessThan, MakeConstant(0), MakeConstant(StringComparison.Ordinal))); |
||||
|
||||
AssertError(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LessThanOrEqual, MakeConstant(1), MakeConstant(StringComparison.Ordinal))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.GreaterThan, MakeConstant(StringComparison.CurrentCultureIgnoreCase), MakeConstant(StringComparison.Ordinal))); |
||||
|
||||
AssertType(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.GreaterThan, MakeResult(typeof(StringComparison?)), MakeResult(typeof(StringComparison?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitAnd() |
||||
{ |
||||
AssertConstant(5, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeConstant(7), MakeConstant(13))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeConstant(null), MakeConstant((short)13))); |
||||
|
||||
AssertType(typeof(long?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeResult(typeof(uint?)), MakeConstant((short)13))); |
||||
|
||||
AssertType(typeof(uint?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeResult(typeof(uint?)), MakeConstant((int)13))); |
||||
|
||||
AssertType(typeof(ulong?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeResult(typeof(ulong?)), MakeConstant((long)13))); |
||||
|
||||
Assert.IsTrue(resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeResult(typeof(ulong?)), MakeConstant((short)13)).IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitXor() |
||||
{ |
||||
AssertConstant(6L ^ 3, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ExclusiveOr, MakeConstant(6L), MakeConstant(3))); |
||||
|
||||
AssertConstant(6UL ^ 3L, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ExclusiveOr, MakeConstant(6UL), MakeConstant(3L))); |
||||
|
||||
AssertError(typeof(ulong), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.ExclusiveOr, MakeConstant(6UL), MakeConstant(-3L))); |
||||
} |
||||
|
||||
[Test] |
||||
public void BitwiseEnum() |
||||
{ |
||||
AssertConstant(AttributeTargets.Field | AttributeTargets.Property, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseOr, MakeConstant(AttributeTargets.Field), MakeConstant(AttributeTargets.Property))); |
||||
|
||||
AssertConstant(AttributeTargets.Field & AttributeTargets.All, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeConstant(AttributeTargets.Field), MakeConstant(AttributeTargets.All))); |
||||
|
||||
AssertConstant(AttributeTargets.Field & 0, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseAnd, MakeConstant(AttributeTargets.Field), MakeConstant(0))); |
||||
|
||||
AssertConstant(0 | AttributeTargets.Field, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.BitwiseOr, MakeConstant(0), MakeConstant(AttributeTargets.Field))); |
||||
} |
||||
|
||||
[Test] |
||||
public void LogicalAnd() |
||||
{ |
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalAnd, MakeConstant(true), MakeConstant(true))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalAnd, MakeConstant(false), MakeConstant(true))); |
||||
|
||||
AssertError(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalAnd, MakeConstant(false), MakeResult(typeof(bool?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void LogicalOr() |
||||
{ |
||||
AssertConstant(true, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalOr, MakeConstant(false), MakeConstant(true))); |
||||
|
||||
AssertConstant(false, resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalOr, MakeConstant(false), MakeConstant(false))); |
||||
|
||||
AssertError(typeof(bool), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.LogicalOr, MakeConstant(false), MakeResult(typeof(bool?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullCoalescing() |
||||
{ |
||||
AssertType(typeof(int), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(int?)), MakeResult(typeof(short)))); |
||||
|
||||
AssertType(typeof(int?), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(int?)), MakeResult(typeof(short?)))); |
||||
|
||||
AssertType(typeof(object), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(string)), MakeResult(typeof(object)))); |
||||
|
||||
AssertError(typeof(string), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(string)), MakeResult(typeof(int)))); |
||||
|
||||
AssertType(typeof(dynamic), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(dynamic)), MakeResult(typeof(string)))); |
||||
|
||||
AssertType(typeof(dynamic), resolver.ResolveBinaryOperator( |
||||
BinaryOperatorType.NullCoalescing, MakeResult(typeof(string)), MakeResult(typeof(dynamic)))); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,57 @@
@@ -0,0 +1,57 @@
|
||||
// Copyright (c) 2010 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
// assign short name to the fake reflection type
|
||||
using dynamic = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Dynamic; |
||||
|
||||
[TestFixture] |
||||
public class CastTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void SimpleCast() |
||||
{ |
||||
AssertType(typeof(int), resolver.ResolveCast(ResolveType(typeof(int)), MakeResult(typeof(float)))); |
||||
AssertType(typeof(string), resolver.ResolveCast(ResolveType(typeof(string)), MakeResult(typeof(object)))); |
||||
AssertType(typeof(byte), resolver.ResolveCast(ResolveType(typeof(byte)), MakeResult(typeof(dynamic)))); |
||||
AssertType(typeof(dynamic), resolver.ResolveCast(ResolveType(typeof(dynamic)), MakeResult(typeof(double)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ConstantValueCast() |
||||
{ |
||||
AssertConstant("Hello", resolver.ResolveCast(ResolveType(typeof(string)), MakeConstant("Hello"))); |
||||
AssertConstant((byte)1L, resolver.ResolveCast(ResolveType(typeof(byte)), MakeConstant(1L))); |
||||
AssertConstant(3, resolver.ResolveCast(ResolveType(typeof(int)), MakeConstant(3.1415))); |
||||
AssertConstant(3, resolver.ResolveCast(ResolveType(typeof(int)), MakeConstant(3.99))); |
||||
AssertConstant((short)-3, resolver.ResolveCast(ResolveType(typeof(short)), MakeConstant(-3.99f))); |
||||
AssertConstant(-3L, resolver.ResolveCast(ResolveType(typeof(long)), MakeConstant(-3.5))); |
||||
} |
||||
|
||||
[Test] |
||||
public void OverflowingCast() |
||||
{ |
||||
resolver.CheckForOverflow = false; |
||||
AssertConstant(uint.MaxValue, resolver.ResolveCast(ResolveType(typeof(uint)), MakeConstant(-1.6))); |
||||
resolver.CheckForOverflow = true; |
||||
AssertError(typeof(uint), resolver.ResolveCast(ResolveType(typeof(uint)), MakeConstant(-1.6))); |
||||
} |
||||
|
||||
[Test] |
||||
public void FailingStringCast() |
||||
{ |
||||
AssertError(typeof(string), resolver.ResolveCast(ResolveType(typeof(string)), MakeConstant(1))); |
||||
} |
||||
|
||||
[Test] |
||||
public void OverflowingCastToEnum() |
||||
{ |
||||
resolver.CheckForOverflow = true; |
||||
AssertError(typeof(StringComparison), resolver.ResolveCast(ResolveType(typeof(StringComparison)), MakeConstant(long.MaxValue))); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,336 @@
@@ -0,0 +1,336 @@
|
||||
// Copyright (c) 2010 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
// assign short names to the fake reflection types
|
||||
using Null = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Null; |
||||
using dynamic = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Dynamic; |
||||
|
||||
[TestFixture] |
||||
public unsafe class ConversionsTest |
||||
{ |
||||
IProjectContent mscorlib = CecilLoaderTests.Mscorlib; |
||||
Conversions conversions = new Conversions(CecilLoaderTests.Mscorlib); |
||||
|
||||
bool ImplicitConversion(Type from, Type to) |
||||
{ |
||||
IType from2 = from.ToTypeReference().Resolve(mscorlib); |
||||
IType to2 = to.ToTypeReference().Resolve(mscorlib); |
||||
return conversions.ImplicitConversion(from2, to2); |
||||
} |
||||
|
||||
[Test] |
||||
public void IdentityConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(char), typeof(char))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(string), typeof(string))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(object), typeof(object))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(bool), typeof(char))); |
||||
|
||||
Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.Dynamic, SharedTypes.Dynamic)); |
||||
Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.UnknownType, SharedTypes.UnknownType)); |
||||
Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.Null, SharedTypes.Null)); |
||||
} |
||||
|
||||
[Test] |
||||
public void DynamicIdentityConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(object), typeof(ReflectionHelper.Dynamic))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(ReflectionHelper.Dynamic), typeof(object))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ComplexDynamicIdentityConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(List<object>), typeof(List<dynamic>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(List<dynamic>), typeof(List<object>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(List<string>), typeof(List<dynamic>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(List<dynamic>), typeof(List<string>))); |
||||
|
||||
Assert.IsTrue(ImplicitConversion(typeof(List<List<dynamic>[]>), typeof(List<List<object>[]>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(List<List<object>[]>), typeof(List<List<dynamic>[]>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(List<List<object>[,]>), typeof(List<List<dynamic>[]>))); |
||||
} |
||||
|
||||
[Test] |
||||
public void PrimitiveConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(char), typeof(ushort))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(byte), typeof(char))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int), typeof(long))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(long), typeof(int))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int), typeof(float))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(bool), typeof(float))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(float), typeof(double))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(float), typeof(decimal))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(char), typeof(long))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(uint), typeof(long))); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(char), typeof(ushort?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(byte), typeof(char?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int), typeof(long?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(long), typeof(int?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int), typeof(float?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(bool), typeof(float?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(float), typeof(double?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(float), typeof(decimal?))); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableConversions2() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(char?), typeof(ushort?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(byte?), typeof(char?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int?), typeof(long?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(long?), typeof(int?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int?), typeof(float?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(bool?), typeof(float?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(float?), typeof(double?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(float?), typeof(decimal?))); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullLiteralConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(int?))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(char?))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(Null), typeof(int))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(object))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(dynamic))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(string))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(int[]))); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleReferenceConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(string), typeof(object))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(BitArray), typeof(ICollection))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(IList), typeof(IEnumerable))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(object), typeof(string))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(ICollection), typeof(BitArray))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(IEnumerable), typeof(IList))); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleDynamicConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(string), typeof(dynamic))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(dynamic), typeof(string))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int), typeof(dynamic))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(dynamic), typeof(int))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParameterizedTypeConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(List<string>), typeof(ICollection<string>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(IList<string>), typeof(ICollection<string>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(List<string>), typeof(ICollection<object>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(IList<string>), typeof(ICollection<object>))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ArrayConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(string[]), typeof(object[]))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(string[,]), typeof(object[,]))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(string[]), typeof(object[,]))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(object[]), typeof(string[]))); |
||||
|
||||
Assert.IsTrue(ImplicitConversion(typeof(string[]), typeof(IList<string>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(string[,]), typeof(IList<string>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(string[]), typeof(IList<object>))); |
||||
|
||||
Assert.IsTrue(ImplicitConversion(typeof(string[]), typeof(Array))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(string[]), typeof(ICloneable))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(Array), typeof(string[]))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(object), typeof(object[]))); |
||||
} |
||||
|
||||
[Test] |
||||
public void VarianceConversions() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(List<string>), typeof(IEnumerable<object>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(List<object>), typeof(IEnumerable<string>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(IEnumerable<string>), typeof(IEnumerable<object>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(ICollection<string>), typeof(ICollection<object>))); |
||||
|
||||
Assert.IsTrue(ImplicitConversion(typeof(Comparer<object>), typeof(IComparer<string>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Comparer<object>), typeof(IComparer<Array>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(Comparer<object>), typeof(Comparer<string>))); |
||||
|
||||
Assert.IsFalse(ImplicitConversion(typeof(List<object>), typeof(IEnumerable<string>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(IEnumerable<string>), typeof(IEnumerable<object>))); |
||||
|
||||
Assert.IsTrue(ImplicitConversion(typeof(Func<ICollection, ICollection>), typeof(Func<IList, IEnumerable>))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(Func<IEnumerable, IList>), typeof(Func<ICollection, ICollection>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(Func<ICollection, ICollection>), typeof(Func<IEnumerable, IList>))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(Func<IList, IEnumerable>), typeof(Func<ICollection, ICollection>))); |
||||
} |
||||
|
||||
[Test] |
||||
public void PointerConversion() |
||||
{ |
||||
Assert.IsTrue(ImplicitConversion(typeof(Null), typeof(int*))); |
||||
Assert.IsTrue(ImplicitConversion(typeof(int*), typeof(void*))); |
||||
} |
||||
|
||||
[Test] |
||||
public void NoConversionFromPointerTypeToObject() |
||||
{ |
||||
Assert.IsFalse(ImplicitConversion(typeof(int*), typeof(object))); |
||||
Assert.IsFalse(ImplicitConversion(typeof(int*), typeof(dynamic))); |
||||
} |
||||
|
||||
[Test, Ignore] |
||||
public void TypeParameterConversions() |
||||
{ |
||||
// TODO: write tests for conversions of type parameters
|
||||
throw new NotImplementedException(); |
||||
} |
||||
|
||||
bool IntegerLiteralConversion(object value, Type to) |
||||
{ |
||||
IType fromType = value.GetType().ToTypeReference().Resolve(mscorlib); |
||||
ConstantResolveResult crr = new ConstantResolveResult(fromType, value); |
||||
IType to2 = to.ToTypeReference().Resolve(mscorlib); |
||||
return conversions.ImplicitConversion(crr, to2); |
||||
} |
||||
|
||||
[Test] |
||||
public void IntegerLiteralToEnumConversions() |
||||
{ |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(LoaderOptimization))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0L, typeof(LoaderOptimization))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(LoaderOptimization?))); |
||||
Assert.IsFalse(IntegerLiteralConversion(0, typeof(string))); |
||||
Assert.IsFalse(IntegerLiteralConversion(1, typeof(LoaderOptimization))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitConstantExpressionConversion() |
||||
{ |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(int))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(ushort))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(sbyte))); |
||||
|
||||
Assert.IsTrue (IntegerLiteralConversion(-1, typeof(int))); |
||||
Assert.IsFalse(IntegerLiteralConversion(-1, typeof(ushort))); |
||||
Assert.IsTrue (IntegerLiteralConversion(-1, typeof(sbyte))); |
||||
|
||||
Assert.IsTrue (IntegerLiteralConversion(200, typeof(int))); |
||||
Assert.IsTrue (IntegerLiteralConversion(200, typeof(ushort))); |
||||
Assert.IsFalse(IntegerLiteralConversion(200, typeof(sbyte))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitLongConstantExpressionConversion() |
||||
{ |
||||
Assert.IsFalse(IntegerLiteralConversion(0L, typeof(int))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0L, typeof(long))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0L, typeof(ulong))); |
||||
|
||||
Assert.IsTrue(IntegerLiteralConversion(-1L, typeof(long))); |
||||
Assert.IsFalse(IntegerLiteralConversion(-1L, typeof(ulong))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitConstantExpressionConversionToNullable() |
||||
{ |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(uint?))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(short?))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(byte?))); |
||||
|
||||
Assert.IsFalse(IntegerLiteralConversion(-1, typeof(uint?))); |
||||
Assert.IsTrue (IntegerLiteralConversion(-1, typeof(short?))); |
||||
Assert.IsFalse(IntegerLiteralConversion(-1, typeof(byte?))); |
||||
|
||||
Assert.IsTrue(IntegerLiteralConversion(200, typeof(uint?))); |
||||
Assert.IsTrue(IntegerLiteralConversion(200, typeof(short?))); |
||||
Assert.IsTrue(IntegerLiteralConversion(200, typeof(byte?))); |
||||
|
||||
Assert.IsFalse(IntegerLiteralConversion(0L, typeof(uint?))); |
||||
Assert.IsTrue (IntegerLiteralConversion(0L, typeof(long?))); |
||||
Assert.IsTrue (IntegerLiteralConversion(0L, typeof(ulong?))); |
||||
|
||||
Assert.IsTrue(IntegerLiteralConversion(-1L, typeof(long?))); |
||||
Assert.IsFalse(IntegerLiteralConversion(-1L, typeof(ulong?))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImplicitConstantExpressionConversionNumberInterfaces() |
||||
{ |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(IFormattable))); |
||||
Assert.IsTrue(IntegerLiteralConversion(0, typeof(IComparable<int>))); |
||||
Assert.IsFalse(IntegerLiteralConversion(0, typeof(IComparable<short>))); |
||||
Assert.IsFalse(IntegerLiteralConversion(0, typeof(IComparable<long>))); |
||||
} |
||||
|
||||
int BetterConversion(Type s, Type t1, Type t2) |
||||
{ |
||||
IType sType = s.ToTypeReference().Resolve(mscorlib); |
||||
IType t1Type = t1.ToTypeReference().Resolve(mscorlib); |
||||
IType t2Type = t2.ToTypeReference().Resolve(mscorlib); |
||||
return conversions.BetterConversion(sType, t1Type, t2Type); |
||||
} |
||||
|
||||
int BetterConversion(object value, Type t1, Type t2) |
||||
{ |
||||
IType fromType = value.GetType().ToTypeReference().Resolve(mscorlib); |
||||
ConstantResolveResult crr = new ConstantResolveResult(fromType, value); |
||||
IType t1Type = t1.ToTypeReference().Resolve(mscorlib); |
||||
IType t2Type = t2.ToTypeReference().Resolve(mscorlib); |
||||
return conversions.BetterConversion(crr, t1Type, t2Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void BetterConversion() |
||||
{ |
||||
Assert.AreEqual(1, BetterConversion(typeof(string), typeof(string), typeof(object))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(string), typeof(object), typeof(IComparable<string>))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(string), typeof(IEnumerable<char>), typeof(IComparable<string>))); |
||||
} |
||||
|
||||
[Test] |
||||
public void BetterPrimitiveConversion() |
||||
{ |
||||
Assert.AreEqual(1, BetterConversion(typeof(short), typeof(int), typeof(long))); |
||||
Assert.AreEqual(1, BetterConversion(typeof(short), typeof(int), typeof(uint))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(ushort), typeof(uint), typeof(int))); |
||||
Assert.AreEqual(1, BetterConversion(typeof(char), typeof(short), typeof(int))); |
||||
Assert.AreEqual(1, BetterConversion(typeof(char), typeof(ushort), typeof(int))); |
||||
Assert.AreEqual(1, BetterConversion(typeof(sbyte), typeof(long), typeof(ulong))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(byte), typeof(ushort), typeof(short))); |
||||
|
||||
Assert.AreEqual(1, BetterConversion(1, typeof(sbyte), typeof(byte))); |
||||
Assert.AreEqual(2, BetterConversion(1, typeof(ushort), typeof(sbyte))); |
||||
} |
||||
|
||||
[Test] |
||||
public void BetterNullableConversion() |
||||
{ |
||||
Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(int), typeof(uint?))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(byte?), typeof(int?), typeof(uint?))); |
||||
Assert.AreEqual(1, BetterConversion(typeof(byte), typeof(ushort?), typeof(uint?))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(byte?), typeof(ulong?), typeof(uint?))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ushort?), typeof(uint))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ushort?), typeof(int))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(byte), typeof(ulong?), typeof(uint))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ulong?), typeof(int))); |
||||
Assert.AreEqual(2, BetterConversion(typeof(ushort?), typeof(long?), typeof(int?))); |
||||
Assert.AreEqual(0, BetterConversion(typeof(sbyte), typeof(int?), typeof(uint?))); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,89 @@
@@ -0,0 +1,89 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class ExtensionMethodTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void ExtensionMethodsTest() |
||||
{ |
||||
string program = @"using XN;
|
||||
class TestClass { |
||||
static void Test(A a, B b, C c) { |
||||
$; |
||||
} |
||||
} |
||||
class A { } |
||||
class B { |
||||
public void F(int i) { } |
||||
} |
||||
class C { |
||||
public void F(object obj) { } |
||||
} |
||||
namespace XN { |
||||
public static class XC { |
||||
public static void F(this object obj, int i) { } |
||||
public static void F(this object obj, string s) { } |
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult mrr; |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$a.F(1)$")); |
||||
Assert.AreEqual("XN.XC.F", mrr.Member.FullName); |
||||
Assert.AreEqual("System.Int32", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$a.F(\"text\")$")); |
||||
Assert.AreEqual("XN.XC.F", mrr.Member.FullName); |
||||
Assert.AreEqual("System.String", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$b.F(1)$")); |
||||
Assert.AreEqual("B.F", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$b.F(\"text\")$")); |
||||
Assert.AreEqual("XN.XC.F", mrr.Member.FullName); |
||||
Assert.AreEqual("System.String", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$c.F(1)$")); |
||||
Assert.AreEqual("C.F", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$c.F(\"text\")$")); |
||||
Assert.AreEqual("C.F", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Test fails due to parser returning incorrect position")] |
||||
public void ExtensionMethodsTest2() |
||||
{ |
||||
string program = @"using System; using System.Collections.Generic;
|
||||
class TestClass { |
||||
static void Test(string[] args) { |
||||
$; |
||||
} |
||||
} |
||||
public static class XC { |
||||
public static int ToInt32(this string s) { return int.Parse(s); } |
||||
public static T[] Slice<T>(this T[] source, int index, int count) { throw new NotImplementedException(); } |
||||
public static IEnumerable<T> Filter<T>(this IEnumerable<T> source, Predicate<T> predicate) { throw new NotImplementedException(); } |
||||
} |
||||
";
|
||||
MemberResolveResult mrr; |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$\"text\".ToInt32()$")); |
||||
Assert.AreEqual("XC.ToInt32", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$args.Slice(1, 2)$")); |
||||
Assert.AreEqual("XC.Slice", mrr.Member.FullName); |
||||
Assert.AreEqual("System.String[]", mrr.Type.ReflectionName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$args.Filter(delegate { return true; })$")); |
||||
Assert.AreEqual("XC.Filter", mrr.Member.FullName); |
||||
Assert.AreEqual("System.Collections.Generic.IEnumerable{System.String}", mrr.Type.ReflectionName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,268 @@
@@ -0,0 +1,268 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class InvocationTests : ResolverTestBase |
||||
{ |
||||
// TODO: do we want to return the MemberResolveResult for the InvocationExpression, or only for it's target?
|
||||
|
||||
[Test] |
||||
public void MethodCallTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$TargetMethod()$; |
||||
} |
||||
|
||||
int TargetMethod() { |
||||
return 3; |
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("A.TargetMethod", result.Member.FullName); |
||||
Assert.AreEqual("System.Int32", result.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvalidMethodCall() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method(string b) { |
||||
$b.ThisMethodDoesNotExistOnString(b)$; |
||||
} |
||||
} |
||||
";
|
||||
UnknownMethodResolveResult result = Resolve<UnknownMethodResolveResult>(program); |
||||
Assert.AreEqual("ThisMethodDoesNotExistOnString", result.MemberName); |
||||
Assert.AreEqual("System.String", result.TargetType.FullName); |
||||
Assert.AreEqual(1, result.Parameters.Count); |
||||
Assert.AreEqual("b", result.Parameters[0].Name); |
||||
Assert.AreEqual("System.String", result.Parameters[0].Type.Resolve(context).ReflectionName); |
||||
|
||||
Assert.AreSame(SharedTypes.UnknownType, result.Type); |
||||
} |
||||
|
||||
[Test, Ignore("Inheritance not supported in parser")] |
||||
public void OverriddenMethodCall() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$new B().GetRandomNumber()$; |
||||
} |
||||
|
||||
public abstract int GetRandomNumber(); |
||||
} |
||||
class B : A { |
||||
public override int GetRandomNumber() { |
||||
return 4; // chosen by fair dice roll.
|
||||
// guaranteed to be random
|
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("B.GetRandomNumber", result.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Inheritance not supported in parser")] |
||||
public void OverriddenMethodCall2() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$new B().GetRandomNumber(""x"", this)$; |
||||
} |
||||
|
||||
public abstract int GetRandomNumber(string a, A b); |
||||
} |
||||
class B : A { |
||||
public override int GetRandomNumber(string b, A a) { |
||||
return 4; // chosen by fair dice roll.
|
||||
// guaranteed to be random
|
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("B.GetRandomNumber", result.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ThisMethodCallTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$this.TargetMethod()$; |
||||
} |
||||
|
||||
int TargetMethod() { |
||||
return 3; |
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("A.TargetMethod", result.Member.FullName); |
||||
Assert.AreEqual("System.Int32", result.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void VoidTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class A { |
||||
void TestMethod() { |
||||
$TestMethod()$; |
||||
} |
||||
} |
||||
";
|
||||
Assert.AreEqual("System.Void", Resolve(program).Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void EventCallTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class A { |
||||
void Method() { |
||||
$TestEvent(this, EventArgs.Empty)$; |
||||
} |
||||
|
||||
public event EventHandler TestEvent; |
||||
} |
||||
";
|
||||
Assert.AreEqual("System.Void", Resolve(program).Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void DelegateCallTest() |
||||
{ |
||||
string program = @"using System; using System.Reflection;
|
||||
class A { |
||||
void Method(ModuleResolveEventHandler eh) { |
||||
$eh(this, new ResolveEventArgs())$; |
||||
} |
||||
} |
||||
";
|
||||
Assert.AreEqual("System.Reflection.Module", Resolve(program).Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void DelegateReturnedFromMethodCallTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class A { |
||||
void Method() { |
||||
$GetHandler()(abc)$; |
||||
} |
||||
abstract Predicate<string> GetHandler(); |
||||
} |
||||
";
|
||||
Assert.AreEqual("System.Boolean", Resolve(program).Type.ReflectionName); |
||||
} |
||||
|
||||
/* TODO |
||||
[Test] |
||||
public void MethodGroupResolveTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
|
||||
} |
||||
|
||||
void TargetMethod(int a) { } |
||||
void TargetMethod<T>(T a) { } |
||||
} |
||||
";
|
||||
MethodGroupResolveResult result = Resolve<MethodGroupResolveResult>(program, "TargetMethod", 3); |
||||
Assert.AreEqual("TargetMethod", result.Name); |
||||
Assert.AreEqual(2, result.Methods.Count); |
||||
|
||||
result = Resolve<MethodGroupResolveResult>(program, "TargetMethod<string>", 3); |
||||
Assert.AreEqual("TargetMethod", result.Name); |
||||
Assert.AreEqual(1, result.Methods[0].Count); |
||||
Assert.AreEqual("System.String", result.GetMethodIfSingleOverload().Parameters[0].ReturnType.FullyQualifiedName); |
||||
} |
||||
*/ |
||||
|
||||
[Test] |
||||
public void TestOverloadingByRef() |
||||
{ |
||||
string program = @"using System;
|
||||
class Program { |
||||
public static void Main() { |
||||
int a = 42; |
||||
T(a); |
||||
T(ref a); |
||||
} |
||||
static void T(int x) {} |
||||
static void T(ref int y) {} |
||||
}";
|
||||
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program, "T(a)"); |
||||
Assert.IsFalse(((IMethod)mrr.Member).Parameters[0].IsRef); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program, "T(ref a)"); |
||||
Assert.IsTrue(((IMethod)mrr.Member).Parameters[0].IsRef); |
||||
} |
||||
|
||||
[Test, Ignore("Inheritance not supported in parser")] |
||||
public void AddedOverload() |
||||
{ |
||||
string program = @"class BaseClass {
|
||||
static void Main(DerivedClass d) { |
||||
$d.Test(3)$; |
||||
} |
||||
public void Test(int a) { } |
||||
} |
||||
class DerivedClass : BaseClass { |
||||
public void Test(object a) { } |
||||
}";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Inheritance not supported in parser")] |
||||
public void AddedNonApplicableOverload() |
||||
{ |
||||
string program = @"class BaseClass {
|
||||
static void Main(DerivedClass d) { |
||||
$d.Test(3)$; |
||||
} |
||||
public void Test(int a) { } |
||||
} |
||||
class DerivedClass : BaseClass { |
||||
public void Test(string a) { } |
||||
}";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("(3)", "(\"3\")")); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Inheritance not supported in parser")] |
||||
public void OverrideShadowed() |
||||
{ |
||||
string program = @"using System;
|
||||
class BaseClass { |
||||
static void Main() { |
||||
$new DerivedClass().Test(3)$; |
||||
} |
||||
public virtual void Test(int a) { } |
||||
} |
||||
class MiddleClass : BaseClass { |
||||
public void Test(object a) { } |
||||
} |
||||
class DerivedClass : MiddleClass { |
||||
public override void Test(int a) { } |
||||
}";
|
||||
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("MiddleClass.Test", mrr.Member.FullName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,278 @@
@@ -0,0 +1,278 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture, Ignore("Expression Lambdas not supported by parser")] |
||||
public class LambdaTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void SimpleLambdaTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
Test(i => Console.WriteLine(i)); |
||||
} |
||||
public void Test(Action<int> ac) { ac(42); } |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program.Replace("(i)", "($i$)")); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
|
||||
lrr = Resolve<LocalResolveResult>(program.Replace("i =>", "$i$ =>")); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInConstructorTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
TestClass t = new TestClass(i => Console.WriteLine($i$)); |
||||
} |
||||
public TestClass(Action<int> ac) { ac(42); } |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInGenericConstructorTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
var t = new SomeClass<string>(i => Console.WriteLine($i$)); |
||||
} |
||||
} |
||||
class SomeClass<T> { |
||||
public SomeClass(Action<T> ac) { } |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
#region Lambda In Initializer
|
||||
[Test] |
||||
public void LambdaInCollectionInitializerTest1() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
Converter<int, string>[] arr = { |
||||
i => $i$.ToString() |
||||
}; |
||||
} |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInCollectionInitializerTest2() |
||||
{ |
||||
string program = @"using System; using System.Collections.Generic;
|
||||
class TestClass { |
||||
static void Main() { |
||||
a = new List<Converter<int, string>> { |
||||
i => $i$.ToString() |
||||
}; |
||||
} |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInCollectionInitializerTest3() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
a = new Converter<int, string>[] { |
||||
i => $i$.ToString() |
||||
}; |
||||
} |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInCollectionInitializerTest4() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
Converter<int, string>[] field = new Converter<int, string>[] { |
||||
i => $i$.ToString() |
||||
}; |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInCollectionInitializerTest5() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
Converter<int, string>[] field = { |
||||
i => $i$.ToString() |
||||
}; |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInObjectInitializerTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class X { |
||||
void SomeMethod() { |
||||
Helper h = new Helper { |
||||
F = i => $i$.ToString() |
||||
}; |
||||
} |
||||
} |
||||
class Helper { |
||||
public Converter<int, string> F; |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
#endregion
|
||||
|
||||
[Test] |
||||
public void LambdaExpressionInCastExpression() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void Main(string[] args) { |
||||
var f = (Func<int, string>) ( i => $i$ ); |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionInReturnStatement() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static Converter<int, string> GetToString() { |
||||
return i => $i$.ToString(); |
||||
} |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program, "i"); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionInReturnStatementInStatementLambda() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void SomeMethod() { |
||||
Func<Func<string, string>> getStringTransformer = () => { |
||||
return s => $s$.ToUpper(); |
||||
}; |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
public delegate R Func<R>(); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionInReturnStatementInAnonymousMethod() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void SomeMethod() { |
||||
Func<Func<string, string>> getStringTransformer = delegate { |
||||
return s => $s$.ToUpper(); |
||||
}; |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
public delegate R Func<R>(); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void CurriedLambdaExpressionInCastExpression() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void Main(string[] args) { |
||||
var f = (Func<char, Func<string, int>>) ( a => b => 0 ); |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program.Replace("a =>", "$a$ =>")); |
||||
Assert.AreEqual("System.Char", lrr.Type.ReflectionName); |
||||
|
||||
lrr = Resolve<LocalResolveResult>(program.Replace("b =>", "$b$ =>")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionInVariableInitializer() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void Main() { |
||||
Func<int, string> f = $i$ => i.ToString(); |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaExpressionInVariableAssignment() |
||||
{ |
||||
string program = @"using System;
|
||||
static class TestClass { |
||||
static void Main() { |
||||
Func<int, string> f; |
||||
f = $i$ => i.ToString(); |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LambdaInDelegateCall() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
Func<Func<int, string>, char> f; |
||||
f($i$ => i.ToString()); |
||||
} |
||||
public delegate R Func<T, R>(T arg); |
||||
}";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,136 @@
@@ -0,0 +1,136 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture, Ignore("LINQ not yet implemented")] |
||||
public class LinqTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void SimpleLinqTest() |
||||
{ |
||||
string program = @"using System; using System.Linq;
|
||||
class TestClass { |
||||
void Test(string[] input) { |
||||
var r = from e in input |
||||
where e.StartsWith(""/"") |
||||
select e.Trim(); |
||||
r.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult lrr = Resolve<LocalResolveResult>(program.Replace("where e", "where $e$")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("select e", "select $e$")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("from e", "from $e$")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
|
||||
lrr = Resolve<LocalResolveResult>(program.Replace("r.ToString", "$r$.ToString")); |
||||
Assert.AreEqual("System.Collections.Generic.IEnumerable", lrr.Type.FullName); |
||||
Assert.AreEqual("System.String", ((ParameterizedType)lrr.Type).TypeArguments[0].FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LinqGroupTest() |
||||
{ |
||||
string program = @"using System; using System.Linq;
|
||||
class TestClass { |
||||
void Test(string[] input) { |
||||
var r = from e in input |
||||
group e.ToUpper() by e.Length; |
||||
$r$.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Collections.Generic.IEnumerable", lrr.Type.FullName); |
||||
ParameterizedType rt = (ParameterizedType)((ParameterizedType)lrr.Type).TypeArguments[0]; |
||||
Assert.AreEqual("System.Linq.IGrouping", rt.FullName); |
||||
Assert.AreEqual("System.Int32", rt.TypeArguments[0].FullName); |
||||
Assert.AreEqual("System.String", rt.TypeArguments[1].FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LinqQueryableGroupTest() |
||||
{ |
||||
string program = @"using System; using System.Linq;
|
||||
class TestClass { |
||||
void Test(IQueryable<string> input) { |
||||
var r = from e in input |
||||
group e.ToUpper() by e.Length; |
||||
$r$.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Linq.IQueryable", lrr.Type.FullName); |
||||
ParameterizedType rt = (ParameterizedType)((ParameterizedType)lrr.Type).TypeArguments[0]; |
||||
Assert.AreEqual("System.Linq.IGrouping", rt.FullName); |
||||
Assert.AreEqual("System.Int32", rt.TypeArguments[0].FullName); |
||||
Assert.AreEqual("System.String", rt.TypeArguments[1].FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParenthesizedLinqTest() |
||||
{ |
||||
string program = @"using System; using System.Linq;
|
||||
class TestClass { |
||||
void Test(string[] input) { |
||||
$(from e in input select e.Length)$.ToArray(); |
||||
} |
||||
} |
||||
";
|
||||
ResolveResult rr = Resolve<ResolveResult>(program); |
||||
Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.Type.FullName); |
||||
Assert.AreEqual("System.Int32", ((ParameterizedType)rr.Type).TypeArguments[0].FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LinqSelectReturnTypeTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { static void M() { |
||||
$(from a in new XYZ() select a.ToUpper())$.ToString(); |
||||
}} |
||||
class XYZ { |
||||
public int Select<U>(Func<string, U> f) { return 42; } |
||||
}";
|
||||
ResolveResult rr = Resolve<ResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", rr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LinqQueryContinuationTest() |
||||
{ |
||||
string program = @"using System; using System.Linq;
|
||||
class TestClass { |
||||
void Test(string[] input) { |
||||
var r = from x in input |
||||
select x.GetHashCode() into x |
||||
where x == 42 |
||||
select x * x; |
||||
r.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult lrr = Resolve<LocalResolveResult>(program.Replace("from x", "from $x$")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("select x.G", "select $x$.G")); |
||||
Assert.AreEqual("System.String", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("into x", "into $x$")); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("where x", "where $x$")); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
lrr = Resolve<LocalResolveResult>(program.Replace("select x * x", "select x * $x$")); |
||||
Assert.AreEqual("System.Int32", lrr.Type.ReflectionName); |
||||
|
||||
lrr = Resolve<LocalResolveResult>(program.Replace("r.ToString", "$r$.ToString")); |
||||
Assert.AreEqual("System.Collections.Generic.IEnumerable`1[[System.Int32]]", lrr.Type.ReflectionName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,55 @@
@@ -0,0 +1,55 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class LocalTypeInferenceTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void TypeInferenceTest() |
||||
{ |
||||
string program = @"class TestClass {
|
||||
static void Test() { |
||||
var a = 3; |
||||
$a$.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", lrr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void TypeInferenceCycleTest() |
||||
{ |
||||
string program = @"class TestClass {
|
||||
static void Test() { |
||||
var a = a; |
||||
$a$.ToString(); |
||||
} |
||||
} |
||||
";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreSame(SharedTypes.UnknownType, lrr.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void InvalidAnonymousTypeDeclaration() |
||||
{ |
||||
// see SD-1393
|
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main() { |
||||
var contact = {id = 54321}; |
||||
$contact$.ToString(); |
||||
} }";
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual(SharedTypes.UnknownType, lrr.Type); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,755 @@
@@ -0,0 +1,755 @@
|
||||
// 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; |
||||
using System.Linq; |
||||
|
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class NameLookupTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void SimpleNameLookupWithoutContext() |
||||
{ |
||||
// nothing should be found without specifying any UsingScope - however, the resolver also must not crash
|
||||
resolver.UsingScope = null; |
||||
Assert.IsTrue(resolver.ResolveSimpleName("System", new IType[0]).IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleNamespaceLookup() |
||||
{ |
||||
NamespaceResolveResult nrr = (NamespaceResolveResult)resolver.ResolveSimpleName("System", new IType[0]); |
||||
Assert.AreEqual("System", nrr.NamespaceName); |
||||
Assert.AreSame(SharedTypes.UnknownType, nrr.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NamespaceInParentNamespaceLookup() |
||||
{ |
||||
resolver.UsingScope = MakeUsingScope("System.Collections.Generic"); |
||||
NamespaceResolveResult nrr = (NamespaceResolveResult)resolver.ResolveSimpleName("Text", new IType[0]); |
||||
Assert.AreEqual("System.Text", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void NamespacesAreNotImported() |
||||
{ |
||||
AddUsing("System"); |
||||
Assert.IsTrue(resolver.ResolveSimpleName("Collections", new IType[0]).IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImportedType() |
||||
{ |
||||
AddUsing("System"); |
||||
TypeResolveResult trr = (TypeResolveResult)resolver.ResolveSimpleName("String", new IType[0]); |
||||
Assert.AreEqual("System.String", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void UnknownIdentifierTest() |
||||
{ |
||||
UnknownIdentifierResolveResult uirr = (UnknownIdentifierResolveResult)resolver.ResolveSimpleName("xyz", new IType[0]); |
||||
Assert.IsTrue(uirr.IsError); |
||||
Assert.AreEqual("xyz", uirr.Identifier); |
||||
} |
||||
|
||||
[Test] |
||||
public void GlobalIsUnknownIdentifier() |
||||
{ |
||||
Assert.IsTrue(resolver.ResolveSimpleName("global", new IType[0]).IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void GlobalIsAlias() |
||||
{ |
||||
NamespaceResolveResult nrr = (NamespaceResolveResult)resolver.ResolveAlias("global"); |
||||
Assert.AreEqual("", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AliasToImportedType() |
||||
{ |
||||
AddUsing("System"); |
||||
AddUsingAlias("x", "String"); |
||||
TypeResolveResult trr = (TypeResolveResult)resolver.ResolveSimpleName("x", new IType[0]); |
||||
// Unknown type (as String isn't looked up in System)
|
||||
Assert.AreSame(SharedTypes.UnknownType, trr.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void AliasToImportedType2() |
||||
{ |
||||
AddUsing("System"); |
||||
resolver.UsingScope = new UsingScope(resolver.UsingScope, "SomeNamespace"); |
||||
AddUsingAlias("x", "String"); |
||||
TypeResolveResult trr = (TypeResolveResult)resolver.ResolveSimpleName("x", new IType[0]); |
||||
Assert.AreEqual("System.String", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AliasOperatorOnTypeAlias() |
||||
{ |
||||
AddUsingAlias("x", "System.String"); |
||||
Assert.IsTrue(resolver.ResolveAlias("x").IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void AliasOperatorOnNamespaceAlias() |
||||
{ |
||||
AddUsingAlias("x", "System.Collections.Generic"); |
||||
NamespaceResolveResult nrr = (NamespaceResolveResult)resolver.ResolveAlias("x"); |
||||
Assert.AreEqual("System.Collections.Generic", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void AliasOperatorOnNamespace() |
||||
{ |
||||
Assert.IsTrue(resolver.ResolveAlias("System").IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void FindClassInCurrentNamespace() |
||||
{ |
||||
resolver.UsingScope = MakeUsingScope("System.Collections"); |
||||
TypeResolveResult trr = (TypeResolveResult)resolver.ResolveSimpleName("String", new IType[0]); |
||||
Assert.AreEqual("System.String", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void FindNeighborNamespace() |
||||
{ |
||||
resolver.UsingScope = MakeUsingScope("System.Collections"); |
||||
NamespaceResolveResult nrr = (NamespaceResolveResult)resolver.ResolveSimpleName("Text", new IType[0]); |
||||
Assert.AreEqual("System.Text", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void FindTypeParameters() |
||||
{ |
||||
resolver.UsingScope = MakeUsingScope("System.Collections.Generic"); |
||||
resolver.CurrentTypeDefinition = context.GetClass(typeof(List<>)); |
||||
resolver.CurrentMember = resolver.CurrentTypeDefinition.Methods.Single(m => m.Name == "ConvertAll"); |
||||
|
||||
TypeResolveResult trr; |
||||
trr = (TypeResolveResult)resolver.ResolveSimpleName("TOutput", new IType[0]); |
||||
Assert.AreSame(((IMethod)resolver.CurrentMember).TypeParameters[0], trr.Type); |
||||
|
||||
trr = (TypeResolveResult)resolver.ResolveSimpleName("T", new IType[0]); |
||||
Assert.AreSame(resolver.CurrentTypeDefinition.TypeParameters[0], trr.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleParameter() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method(string a) { |
||||
string b = $a$; |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("a", result.Variable.Name); |
||||
Assert.IsTrue(result.IsParameter); |
||||
Assert.AreEqual("System.String", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void SimpleLocalVariable() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
string a; |
||||
string b = $a$; |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("a", result.Variable.Name); |
||||
Assert.IsFalse(result.IsParameter); |
||||
|
||||
Assert.AreEqual("System.String", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void UnknownTypeTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method($StringBuilder$ b) { |
||||
} |
||||
} |
||||
";
|
||||
UnknownIdentifierResolveResult result = Resolve<UnknownIdentifierResolveResult>(program); |
||||
Assert.AreEqual("StringBuilder", result.Identifier); |
||||
|
||||
Assert.AreSame(SharedTypes.UnknownType, result.Type); |
||||
} |
||||
|
||||
[Test, Ignore("not yet implemented (depends on distuishing types and expressions in the DOM)")] |
||||
public void PropertyNameAmbiguousWithTypeName() |
||||
{ |
||||
string program = @"class A {
|
||||
public Color Color { get; set; } |
||||
|
||||
void Method() { |
||||
$ |
||||
} |
||||
} |
||||
class Color { public static readonly Color Empty = null; } |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("$", "$Color$ c;")); |
||||
Assert.AreEqual("Color", trr.Type.Name); |
||||
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "x = $Color$;")); |
||||
Assert.AreEqual("Color", mrr.Member.Name); |
||||
|
||||
Resolve<MemberResolveResult>(program.Replace("$", "$Color$ = Color.Empty;")); |
||||
Resolve<TypeResolveResult>(program.Replace("$", "Color = $Color$.Empty;")); |
||||
Resolve<MemberResolveResult>(program.Replace("$", "x = $Color$.ToString();")); |
||||
} |
||||
|
||||
[Test] |
||||
public void ValueInsideSetterTest() |
||||
{ |
||||
string program = @"class A {
|
||||
public string Property { |
||||
set { |
||||
var a = $value$; |
||||
} |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.String", result.Type.FullName); |
||||
Assert.AreEqual("value", result.Variable.Name); |
||||
} |
||||
|
||||
[Test, Ignore("type references not supported")] |
||||
public void ValueInsideEventTest() |
||||
{ |
||||
string program = @"using System; class A {
|
||||
public event EventHandler Ev { |
||||
add { |
||||
var a = $value$; |
||||
} |
||||
remove {} |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.EventHandler", result.Type.FullName); |
||||
Assert.AreEqual("value", result.Variable.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void ValueInsideIndexerSetterTest() |
||||
{ |
||||
string program = @"using System; class A {
|
||||
public string this[int arg] { |
||||
set { |
||||
var a = $value$; |
||||
} |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.String", result.Type.FullName); |
||||
Assert.AreEqual("value", result.Variable.Name); |
||||
} |
||||
|
||||
[Test, Ignore("Anonymous method parameters not supported by parser")] |
||||
public void AnonymousMethodParameters() |
||||
{ |
||||
string program = @"using System;
|
||||
class A { |
||||
void Method() { |
||||
SomeEvent += delegate(object sender, EventArgs e) { |
||||
$e$.ToString(); |
||||
}; |
||||
} } |
||||
";
|
||||
LocalResolveResult result = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.EventArgs", result.Type.FullName); |
||||
Assert.AreEqual("e", result.Variable.Name); |
||||
} |
||||
|
||||
[Test] |
||||
public void DefaultTypeCSharp() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$int$ a; |
||||
} } |
||||
";
|
||||
TypeResolveResult result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("System.Int32", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void LoopVariableScopeTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
void Test() { |
||||
for (int i = 0; i < 10; i++) { |
||||
$1$.ToString(); |
||||
} |
||||
for (long i = 0; i < 10; i++) { |
||||
$2$.ToString(); |
||||
} |
||||
} |
||||
} |
||||
";
|
||||
LocalResolveResult lr = Resolve<LocalResolveResult>(program.Replace("$1$", "$i$").Replace("$2$", "i")); |
||||
Assert.AreEqual("System.Int32", lr.Type.ReflectionName); |
||||
|
||||
lr = Resolve<LocalResolveResult>(program.Replace("$1$", "i").Replace("$2$", "$i$")); |
||||
Assert.AreEqual("System.Int64", lr.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void NamespacePreferenceTest() |
||||
{ |
||||
// Classes in the current namespace are preferred over classes from
|
||||
// imported namespaces
|
||||
string program = @"using System;
|
||||
namespace Testnamespace { |
||||
class A { |
||||
$Activator$ a; |
||||
} |
||||
|
||||
class Activator { |
||||
|
||||
} |
||||
} |
||||
";
|
||||
var result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Testnamespace.Activator", result.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParentNamespaceTypeLookup() |
||||
{ |
||||
string program = @"using System;
|
||||
namespace Root { |
||||
class Alpha {} |
||||
} |
||||
namespace Root.Child { |
||||
class Beta { |
||||
$Alpha$ a; |
||||
} |
||||
} |
||||
";
|
||||
var result = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Root.Alpha", result.Type.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("type references not implemented")] |
||||
public void ImportAliasTest() |
||||
{ |
||||
string program = @"using COL = System.Collections;
|
||||
class TestClass { |
||||
COL.ArrayList ff; |
||||
} |
||||
";
|
||||
TypeResolveResult type = Resolve<TypeResolveResult>(program, "COL.ArrayList"); |
||||
Assert.IsNotNull(type, "COL.ArrayList should resolve to a type"); |
||||
Assert.AreEqual("System.Collections.ArrayList", type.Type.FullName, "TypeResolveResult"); |
||||
|
||||
MemberResolveResult member = Resolve<MemberResolveResult>(program, "ff"); |
||||
Assert.AreEqual("System.Collections.ArrayList", member.Type.FullName, "the full type should be resolved"); |
||||
} |
||||
|
||||
[Test] |
||||
public void ImportAliasNamespaceResolveTest() |
||||
{ |
||||
NamespaceResolveResult ns; |
||||
string program = "using COL = System.Collections;\r\nclass A {\r\n$.ArrayList a;\r\n}\r\n"; |
||||
ns = Resolve<NamespaceResolveResult>(program.Replace("$", "$COL$")); |
||||
Assert.AreEqual("System.Collections", ns.NamespaceName, "COL"); |
||||
ns = Resolve<NamespaceResolveResult>(program.Replace("$", "$COL.Generic$")); |
||||
Assert.AreEqual("System.Collections.Generic", ns.NamespaceName, "COL.Generic"); |
||||
} |
||||
|
||||
[Test, Ignore("Cannot resolve type references")] |
||||
public void ImportAliasClassResolveTest() |
||||
{ |
||||
string program = @"using COL = System.Collections.ArrayList;
|
||||
class TestClass { |
||||
void Test() { |
||||
COL a = new COL(); |
||||
|
||||
} |
||||
} |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("COL a", "$COL$ a")); |
||||
Assert.AreEqual("System.Collections.ArrayList", trr.Type.FullName, "COL"); |
||||
ResolveResult rr = Resolve<ResolveResult>(program.Replace("new COL()", "$new COL()$")); |
||||
Assert.AreEqual("System.Collections.ArrayList", rr.Type.FullName, "a"); |
||||
} |
||||
|
||||
[Test] |
||||
public void ResolveNamespaceSD_863() |
||||
{ |
||||
string program = @"using System;
|
||||
namespace A.C { class D {} } |
||||
namespace A.B.C { class D {} } |
||||
namespace A.B { |
||||
class TestClass { |
||||
void Test() { |
||||
C.D x; |
||||
} |
||||
} |
||||
} |
||||
";
|
||||
NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("C.D", "$C$.D")); |
||||
Assert.AreEqual("A.B.C", nrr.NamespaceName, "nrr.Name"); |
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("C.D", "$C.D$")); |
||||
Assert.AreEqual("A.B.C.D", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Broken due to parser returning incorrect positions")] |
||||
public void ResolveTypeSD_863() |
||||
{ |
||||
string program = @"using System;
|
||||
namespace A { class C {} } |
||||
namespace A.B { |
||||
class C {} |
||||
class TestClass { |
||||
void Test() { |
||||
$C$ a; |
||||
} |
||||
} |
||||
} |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("A.B.C", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShortMaxValueTest() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
object a = $short.MaxValue$; |
||||
} |
||||
";
|
||||
MemberResolveResult rr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("System.Int16", rr.Type.FullName); |
||||
Assert.AreEqual("System.Int16.MaxValue", rr.Member.FullName); |
||||
Assert.AreEqual(short.MaxValue, rr.ConstantValue); |
||||
} |
||||
|
||||
[Test, Ignore("Parser produces incorrect positions for :: operator")] |
||||
public void ClassWithSameNameAsNamespace() |
||||
{ |
||||
string program = @"using System; namespace XX {
|
||||
class Test { |
||||
static void X() { |
||||
a = $; |
||||
} |
||||
} |
||||
class XX { |
||||
public static void Test() {} |
||||
} }";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("$", "$XX$")); |
||||
Assert.AreEqual("XX.XX", trr.Type.FullName); |
||||
|
||||
NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("$", "$global::XX$.T")); |
||||
Assert.AreEqual("XX", nrr.NamespaceName); |
||||
|
||||
trr = Resolve<TypeResolveResult>(program.Replace("$", "$global::XX.XX$")); |
||||
Assert.AreEqual("XX.XX", trr.Type.FullName); |
||||
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$XX.Test()$")); |
||||
Assert.AreEqual("XX.XX.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ClassNameLookup1() |
||||
{ |
||||
string program = @"namespace MainNamespace {
|
||||
using Test.Subnamespace; |
||||
class Program { |
||||
static void M($Test.TheClass$ c) {} |
||||
} |
||||
} |
||||
|
||||
namespace Test { public class TheClass { } } |
||||
namespace Test.Subnamespace { |
||||
public class Test { public class TheClass { } } |
||||
} |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Test.Subnamespace.Test.TheClass", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ClassNameLookup2() |
||||
{ |
||||
string program = @"using Test.Subnamespace;
|
||||
namespace MainNamespace { |
||||
class Program { |
||||
static void M($Test.TheClass$ c) {} |
||||
} |
||||
} |
||||
|
||||
namespace Test { public class TheClass { } } |
||||
namespace Test.Subnamespace { |
||||
public class Test { public class TheClass { } } |
||||
} |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Test.TheClass", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ClassNameLookup3() |
||||
{ |
||||
string program = @"namespace MainNamespace {
|
||||
using Test.Subnamespace; |
||||
class Program { |
||||
static void M($Test$ c) {} |
||||
} |
||||
} |
||||
|
||||
namespace Test { public class TheClass { } } |
||||
namespace Test.Subnamespace { |
||||
public class Test { public class TheClass { } } |
||||
} |
||||
";
|
||||
TypeResolveResult trr = Resolve<TypeResolveResult>(program); |
||||
Assert.AreEqual("Test.Subnamespace.Test", trr.Type.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ClassNameLookup4() |
||||
{ |
||||
string program = @"using Test.Subnamespace;
|
||||
namespace MainNamespace { |
||||
class Program { |
||||
static void M($Test$ c) {} |
||||
} |
||||
} |
||||
|
||||
namespace Test { public class TheClass { } } |
||||
namespace Test.Subnamespace { |
||||
public class Test { public class TheClass { } } |
||||
} |
||||
";
|
||||
NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program); |
||||
Assert.AreEqual("Test", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test] |
||||
public void ClassNameLookup5() |
||||
{ |
||||
string program = @"namespace MainNamespace {
|
||||
using A; |
||||
|
||||
class M { |
||||
void X($Test$ a) {} |
||||
} |
||||
namespace Test { class B {} } |
||||
} |
||||
|
||||
namespace A { |
||||
class Test {} |
||||
}";
|
||||
NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program); |
||||
Assert.AreEqual("MainNamespace.Test", nrr.NamespaceName); |
||||
} |
||||
|
||||
[Test, Ignore("Fails because parser does not support base type references")] |
||||
public void InvocableRule() |
||||
{ |
||||
string program = @"using System;
|
||||
class DerivedClass : BaseClass { |
||||
static void X() { |
||||
a = $; |
||||
} |
||||
private static new int Test; |
||||
} |
||||
class BaseClass { |
||||
public static string Test() {} |
||||
}";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$BaseClass.Test()$")); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Test$")); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$")); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
|
||||
// returns BaseClass.Test because DerivedClass.Test is not invocable
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test()$")); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Fails because parser does not support base type references")] |
||||
public void InvocableRule2() |
||||
{ |
||||
string program = @"using System;
|
||||
class DerivedClass : BaseClass { |
||||
static void X() { |
||||
a = $; |
||||
} |
||||
private static new int Test; |
||||
} |
||||
delegate string SomeDelegate(); |
||||
class BaseClass { |
||||
public static SomeDelegate Test; |
||||
}";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$BaseClass.Test$()")); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Test$")); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$")); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
|
||||
// returns BaseClass.Test because DerivedClass.Test is not invocable
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$()")); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Fails because parser does not support base type references")] |
||||
public void AccessibleRule() |
||||
{ |
||||
string program = @"using System;
|
||||
class BaseClass { |
||||
static void X() { |
||||
a = $DerivedClass.Test$; |
||||
} |
||||
public static int Test; |
||||
} |
||||
class DerivedClass : BaseClass { |
||||
private static new int Test; |
||||
} |
||||
";
|
||||
// returns BaseClass.Test because DerivedClass.Test is not accessible
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("BaseClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void FieldHidingProperty() |
||||
{ |
||||
string program = @"using System;
|
||||
class DerivedClass : BaseClass { |
||||
static void X() { |
||||
a = $Test$; |
||||
} |
||||
public static new int Test; |
||||
} |
||||
class BaseClass { |
||||
public static int Test { get { return 0; } } |
||||
} |
||||
";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void PropertyHidingField() |
||||
{ |
||||
string program = @"using System;
|
||||
class DerivedClass : BaseClass { |
||||
static void X() { |
||||
a = $Test$; |
||||
} |
||||
public static new int Test { get { return 0; } } |
||||
} |
||||
class BaseClass { |
||||
public static int Test; |
||||
} |
||||
";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Parser doesn't support inheritance")] |
||||
public void SD_1487() |
||||
{ |
||||
string program = @"using System;
|
||||
class C2 : C1 { |
||||
public static void M() { |
||||
a = $; |
||||
} |
||||
} |
||||
class C1 { |
||||
protected static int Field; |
||||
}";
|
||||
MemberResolveResult mrr; |
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Field$")); |
||||
Assert.AreEqual("C1.Field", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$C1.Field$")); |
||||
Assert.AreEqual("C1.Field", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program.Replace("$", "$C2.Field$")); |
||||
Assert.AreEqual("C1.Field", mrr.Member.FullName); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableValue() |
||||
{ |
||||
string program = @"using System;
|
||||
class Test { |
||||
public static void M(int? a) { |
||||
$a.Value$.ToString(); |
||||
} |
||||
}";
|
||||
MemberResolveResult rr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("System.Nullable.Value", rr.Member.FullName); |
||||
Assert.AreEqual("System.Int32", rr.Member.ReturnType.Resolve(context).FullName); |
||||
} |
||||
|
||||
[Test, Ignore("Parser doesn't support inheritance")] |
||||
public void MethodHidesEvent() |
||||
{ |
||||
// see SD-1542
|
||||
string program = @"using System;
|
||||
class Test : Form { |
||||
public Test() { |
||||
a = $base.KeyDown$; |
||||
} |
||||
void KeyDown(object sender, EventArgs e) {} |
||||
} |
||||
class Form { |
||||
public event EventHandler KeyDown; |
||||
}";
|
||||
var mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("Form.KeyDown", mrr.Member.FullName); |
||||
|
||||
var mgrr = Resolve<MethodGroupResolveResult>(program.Replace("base", "this")); |
||||
Assert.AreEqual("Test.KeyDown", mgrr.Methods.Single().FullName); |
||||
} |
||||
|
||||
[Test, Ignore("partial classes not yet supported")] |
||||
public void ProtectedMemberVisibleWhenBaseTypeReferenceIsInOtherPart() |
||||
{ |
||||
string program = @"using System;
|
||||
partial class A { |
||||
void M1() { |
||||
$x$ = 0; |
||||
} |
||||
} |
||||
partial class A : B { } |
||||
class B |
||||
{ |
||||
protected int x; |
||||
}";
|
||||
var mrr = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("B.x", mrr.Member.FullName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,135 @@
@@ -0,0 +1,135 @@
|
||||
// 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class ObjectCreationTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void GenericObjectCreation() |
||||
{ |
||||
string program = @"using System.Collections.Generic;
|
||||
class A { |
||||
static void Main() { |
||||
var a = $new List<string>()$; |
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
Assert.AreEqual("System.Collections.Generic.List..ctor", result.Member.FullName); |
||||
|
||||
Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", result.Type.ReflectionName); |
||||
} |
||||
|
||||
[Test] |
||||
public void NonExistingClass() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
var a = $new ThisClassDoesNotExist()$; |
||||
} |
||||
} |
||||
";
|
||||
ResolveResult result = Resolve<ResolveResult>(program); |
||||
Assert.AreSame(SharedTypes.UnknownType, result.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void NonExistingClassTypeName() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
var a = new $ThisClassDoesNotExist$(); |
||||
} |
||||
} |
||||
";
|
||||
UnknownIdentifierResolveResult result = Resolve<UnknownIdentifierResolveResult>(program); |
||||
Assert.AreEqual("ThisClassDoesNotExist", result.Identifier); |
||||
Assert.AreSame(SharedTypes.UnknownType, result.Type); |
||||
} |
||||
|
||||
[Test] |
||||
public void CTorOverloadLookupTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$; |
||||
} |
||||
|
||||
static A() {} |
||||
A() {} |
||||
A(int intVal) {} |
||||
A(double dblVal) {} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program.Replace("$", "$new A()$")); |
||||
IMethod m = (IMethod)result.Member; |
||||
Assert.IsFalse(m.IsStatic, "new A() is static"); |
||||
Assert.AreEqual(0, m.Parameters.Count, "new A() parameter count"); |
||||
Assert.AreEqual("A", result.Type.FullName); |
||||
|
||||
result = Resolve<MemberResolveResult>(program.Replace("$", "$new A(10)$")); |
||||
m = (IMethod)result.Member; |
||||
Assert.AreEqual(1, m.Parameters.Count, "new A(10) parameter count"); |
||||
Assert.AreEqual("intVal", m.Parameters[0].Name, "new A(10) parameter"); |
||||
|
||||
result = Resolve<MemberResolveResult>(program.Replace("$", "$new A(11.1)$")); |
||||
m = (IMethod)result.Member; |
||||
Assert.AreEqual(1, m.Parameters.Count, "new A(11.1) parameter count"); |
||||
Assert.AreEqual("dblVal", m.Parameters[0].Name, "new A(11.1) parameter"); |
||||
} |
||||
|
||||
[Test] |
||||
public void DefaultCTorOverloadLookupTest() |
||||
{ |
||||
string program = @"class A {
|
||||
void Method() { |
||||
$new A()$; |
||||
} |
||||
} |
||||
";
|
||||
MemberResolveResult result = Resolve<MemberResolveResult>(program); |
||||
IMethod m = (IMethod)result.Member; |
||||
Assert.IsNotNull(m); |
||||
Assert.AreEqual("A", result.Type.ReflectionName); |
||||
Assert.AreEqual(0, m.Parameters.Count); |
||||
} |
||||
|
||||
[Test, Ignore("parser doesn't produce any nodes for base constructor calls")] |
||||
public void ChainedConstructorCall() |
||||
{ |
||||
string program = @"using System;
|
||||
class A { |
||||
public A(int a) {} |
||||
} |
||||
class B : A { |
||||
public B(int b) |
||||
: base(b) |
||||
{} |
||||
} |
||||
class C : B { |
||||
public C(int c) |
||||
: base(c) |
||||
{} |
||||
|
||||
public C() |
||||
: this(0) |
||||
{} |
||||
} |
||||
";
|
||||
MemberResolveResult mrr = Resolve<MemberResolveResult>(program, "base(b)"); |
||||
Assert.AreEqual("A..ctor", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program, "base(c)"); |
||||
Assert.AreEqual("B..ctor", mrr.Member.FullName); |
||||
|
||||
mrr = Resolve<MemberResolveResult>(program, "this(0)"); |
||||
Assert.AreEqual("C..ctor", mrr.Member.FullName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,185 @@
@@ -0,0 +1,185 @@
|
||||
// Copyright (c) 2010 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.Linq; |
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class OverloadResolutionTests |
||||
{ |
||||
readonly ITypeResolveContext context = CecilLoaderTests.Mscorlib; |
||||
readonly DefaultTypeDefinition dummyClass = new DefaultTypeDefinition(CecilLoaderTests.Mscorlib, string.Empty, "DummyClass"); |
||||
|
||||
ResolveResult[] MakeArgumentList(params Type[] argumentTypes) |
||||
{ |
||||
return argumentTypes.Select(t => new ResolveResult(t.ToTypeReference().Resolve(context))).ToArray(); |
||||
} |
||||
|
||||
DefaultMethod MakeMethod(params object[] parameterTypesOrDefaultValues) |
||||
{ |
||||
DefaultMethod m = new DefaultMethod(dummyClass, "Method"); |
||||
foreach (var typeOrDefaultValue in parameterTypesOrDefaultValues) { |
||||
Type type = typeOrDefaultValue as Type; |
||||
if (type != null) |
||||
m.Parameters.Add(new DefaultParameter(type.ToTypeReference(), string.Empty)); |
||||
else if (Type.GetTypeCode(typeOrDefaultValue.GetType()) > TypeCode.Object) |
||||
m.Parameters.Add(new DefaultParameter(typeOrDefaultValue.GetType().ToTypeReference(), string.Empty) { |
||||
DefaultValue = new SimpleConstantValue(typeOrDefaultValue.GetType().ToTypeReference(), typeOrDefaultValue) |
||||
}); |
||||
else |
||||
throw new ArgumentException(typeOrDefaultValue.ToString()); |
||||
} |
||||
return m; |
||||
} |
||||
|
||||
DefaultMethod MakeParamsMethod(params object[] parameterTypesOrDefaultValues) |
||||
{ |
||||
DefaultMethod m = MakeMethod(parameterTypesOrDefaultValues); |
||||
((DefaultParameter)m.Parameters.Last()).IsParams = true; |
||||
return m; |
||||
} |
||||
|
||||
DefaultParameter MakeOptionalParameter(IType type, string name) |
||||
{ |
||||
return new DefaultParameter(type, name) { |
||||
DefaultValue = new SimpleConstantValue(type, null) |
||||
}; |
||||
} |
||||
|
||||
[Test] |
||||
public void PreferIntOverUInt() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(ushort))); |
||||
var c1 = MakeMethod(typeof(int)); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(c1)); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(uint)))); |
||||
Assert.IsFalse(r.IsAmbiguous); |
||||
Assert.AreSame(c1, r.BestCandidate); |
||||
} |
||||
|
||||
[Test] |
||||
public void NullableIntAndNullableUIntIsAmbiguous() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(ushort?))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(int?)))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(uint?)))); |
||||
Assert.AreEqual(OverloadResolutionErrors.AmbiguousMatch, r.BestCandidateErrors); |
||||
|
||||
// then adding a matching overload solves the ambiguity:
|
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(ushort?)))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.BestCandidateErrors); |
||||
Assert.IsNull(r.BestCandidateAmbiguousWith); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParamsMethodMatchesEmptyArgumentList() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList()); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[])))); |
||||
Assert.IsTrue(r.BestCandidateIsExpandedForm); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParamsMethodMatchesOneArgumentInExpandedForm() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(int))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[])))); |
||||
Assert.IsTrue(r.BestCandidateIsExpandedForm); |
||||
} |
||||
|
||||
[Test] |
||||
public void ParamsMethodMatchesInUnexpandedForm() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(int[]))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[])))); |
||||
Assert.IsFalse(r.BestCandidateIsExpandedForm); |
||||
} |
||||
|
||||
[Test] |
||||
public void LessArgumentsPassedToParamsIsBetter() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(int), typeof(int), typeof(int))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[])))); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int), typeof(int[])))); |
||||
Assert.IsFalse(r.IsAmbiguous); |
||||
Assert.AreEqual(2, r.BestCandidate.Parameters.Count); |
||||
} |
||||
|
||||
[Test] |
||||
public void CallInvalidParamsDeclaration() |
||||
{ |
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList(typeof(int[,]))); |
||||
Assert.AreEqual(OverloadResolutionErrors.ArgumentTypeMismatch, r.AddCandidate(MakeParamsMethod(typeof(int)))); |
||||
Assert.IsFalse(r.BestCandidateIsExpandedForm); |
||||
} |
||||
|
||||
[Test] |
||||
public void PreferMethodWithoutOptionalParameters() |
||||
{ |
||||
var m1 = MakeMethod(); |
||||
var m2 = MakeMethod(1); |
||||
|
||||
OverloadResolution r = new OverloadResolution(context, MakeArgumentList()); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m1)); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m2)); |
||||
Assert.IsFalse(r.IsAmbiguous); |
||||
Assert.AreSame(m1, r.BestCandidate); |
||||
} |
||||
|
||||
[Test] |
||||
public void SkeetEvilOverloadResolution() |
||||
{ |
||||
// http://msmvps.com/blogs/jon_skeet/archive/2010/11/02/evil-code-overload-resolution-workaround.aspx
|
||||
|
||||
// static void Foo<T>(T? ignored = default(T?)) where T : struct
|
||||
var m1 = MakeMethod(); |
||||
m1.TypeParameters.Add(new DefaultTypeParameter(m1, 0, "T") { HasValueTypeConstraint = true }); |
||||
m1.Parameters.Add(MakeOptionalParameter( |
||||
NullableType.Create(m1.TypeParameters[0], context), |
||||
"ignored" |
||||
)); |
||||
|
||||
// class ClassConstraint<T> where T : class {}
|
||||
DefaultTypeDefinition classConstraint = new DefaultTypeDefinition(dummyClass, "ClassConstraint"); |
||||
classConstraint.TypeParameters.Add(new DefaultTypeParameter(classConstraint, 0, "T") { HasReferenceTypeConstraint = true }); |
||||
|
||||
// static void Foo<T>(ClassConstraint<T> ignored = default(ClassConstraint<T>))
|
||||
// where T : class
|
||||
var m2 = MakeMethod(); |
||||
m2.TypeParameters.Add(new DefaultTypeParameter(m2, 0, "T") { HasReferenceTypeConstraint = true }); |
||||
m2.Parameters.Add(MakeOptionalParameter( |
||||
new ParameterizedType(classConstraint, new[] { m2.TypeParameters[0] }), |
||||
"ignored" |
||||
)); |
||||
|
||||
// static void Foo<T>()
|
||||
var m3 = MakeMethod(); |
||||
m3.TypeParameters.Add(new DefaultTypeParameter(m3, 0, "T")); |
||||
|
||||
// Call: Foo<int>();
|
||||
OverloadResolution o; |
||||
o = new OverloadResolution(context, new ResolveResult[0], typeArguments: new[] { typeof(int).ToTypeReference().Resolve(context) }); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(m1)); |
||||
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(m2)); |
||||
Assert.AreSame(m1, o.BestCandidate); |
||||
|
||||
// Call: Foo<string>();
|
||||
o = new OverloadResolution(context, new ResolveResult[0], typeArguments: new[] { typeof(string).ToTypeReference().Resolve(context) }); |
||||
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(m1)); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(m2)); |
||||
Assert.AreSame(m2, o.BestCandidate); |
||||
|
||||
// Call: Foo<int?>();
|
||||
o = new OverloadResolution(context, new ResolveResult[0], typeArguments: new[] { typeof(int?).ToTypeReference().Resolve(context) }); |
||||
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(m1)); |
||||
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(m2)); |
||||
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(m3)); |
||||
Assert.AreSame(m3, o.BestCandidate); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,207 @@
@@ -0,0 +1,207 @@
|
||||
// Copyright (c) 2010 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; |
||||
using System.IO; |
||||
using System.Linq; |
||||
|
||||
using ICSharpCode.NRefactory.CSharp.Parser; |
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
/// <summary>
|
||||
/// Base class with helper functions for resolver unit tests.
|
||||
/// </summary>
|
||||
public abstract class ResolverTestBase |
||||
{ |
||||
protected readonly IProjectContent mscorlib = CecilLoaderTests.Mscorlib; |
||||
protected SimpleProjectContent project; |
||||
protected ITypeResolveContext context; |
||||
protected CSharpResolver resolver; |
||||
|
||||
[SetUp] |
||||
public virtual void SetUp() |
||||
{ |
||||
project = new SimpleProjectContent(); |
||||
context = new CompositeTypeResolveContext(new [] { project, mscorlib }); |
||||
resolver = new CSharpResolver(context); |
||||
resolver.UsingScope = MakeUsingScope(""); |
||||
} |
||||
|
||||
protected UsingScope MakeUsingScope(string namespaceName) |
||||
{ |
||||
UsingScope u = new UsingScope(project); |
||||
if (!string.IsNullOrEmpty(namespaceName)) { |
||||
foreach (string element in namespaceName.Split('.')) { |
||||
u = new UsingScope(u, string.IsNullOrEmpty(u.NamespaceName) ? element : u.NamespaceName + "." + element); |
||||
} |
||||
} |
||||
return u; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Adds a using to the current using scope.
|
||||
/// </summary>
|
||||
protected void AddUsing(string namespaceName) |
||||
{ |
||||
resolver.UsingScope.Usings.Add(MakeReference(namespaceName)); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Adds a using alias to the current using scope.
|
||||
/// </summary>
|
||||
protected void AddUsingAlias(string alias, string target) |
||||
{ |
||||
resolver.UsingScope.UsingAliases.Add(new KeyValuePair<string, ITypeOrNamespaceReference>(alias, MakeReference(target))); |
||||
} |
||||
|
||||
protected ITypeOrNamespaceReference MakeReference(string namespaceName) |
||||
{ |
||||
string[] nameParts = namespaceName.Split('.'); |
||||
ITypeOrNamespaceReference r = new SimpleTypeOrNamespaceReference(nameParts[0], new ITypeReference[0], resolver.CurrentTypeDefinition, resolver.UsingScope, true); |
||||
for (int i = 1; i < nameParts.Length; i++) { |
||||
r = new MemberTypeOrNamespaceReference(r, nameParts[i], new ITypeReference[0], resolver.CurrentTypeDefinition, resolver.UsingScope); |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
protected IType ResolveType(Type type) |
||||
{ |
||||
IType t = type.ToTypeReference().Resolve(context); |
||||
if (t == SharedTypes.UnknownType) |
||||
throw new InvalidOperationException("Could not resolve type"); |
||||
return t; |
||||
} |
||||
|
||||
protected ConstantResolveResult MakeConstant(object value) |
||||
{ |
||||
if (value == null) |
||||
return new ConstantResolveResult(SharedTypes.Null, null); |
||||
IType type = ResolveType(value.GetType()); |
||||
if (type.IsEnum()) |
||||
value = Convert.ChangeType(value, Enum.GetUnderlyingType(value.GetType())); |
||||
return new ConstantResolveResult(type, value); |
||||
} |
||||
|
||||
protected ResolveResult MakeResult(Type type) |
||||
{ |
||||
return new ResolveResult(ResolveType(type)); |
||||
} |
||||
|
||||
protected void AssertConstant(object expectedValue, ResolveResult rr) |
||||
{ |
||||
Assert.IsFalse(rr.IsError, rr.ToString() + " is an error"); |
||||
Assert.IsTrue(rr.IsCompileTimeConstant, rr.ToString() + " is not a compile-time constant"); |
||||
Type expectedType = expectedValue.GetType(); |
||||
Assert.AreEqual(ResolveType(expectedType), rr.Type, "ResolveResult.Type is wrong"); |
||||
if (expectedType.IsEnum) { |
||||
Assert.AreEqual(Enum.GetUnderlyingType(expectedType), rr.ConstantValue.GetType(), "ResolveResult.ConstantValue has wrong Type"); |
||||
Assert.AreEqual(Convert.ChangeType(expectedValue, Enum.GetUnderlyingType(expectedType)), rr.ConstantValue); |
||||
} else { |
||||
Assert.AreEqual(expectedType, rr.ConstantValue.GetType(), "ResolveResult.ConstantValue has wrong Type"); |
||||
Assert.AreEqual(expectedValue, rr.ConstantValue); |
||||
} |
||||
} |
||||
|
||||
protected void AssertType(Type expectedType, ResolveResult rr) |
||||
{ |
||||
Assert.IsFalse(rr.IsError, rr.ToString() + " is an error"); |
||||
Assert.IsFalse(rr.IsCompileTimeConstant, rr.ToString() + " is a compile-time constant"); |
||||
Assert.AreEqual(expectedType.ToTypeReference().Resolve(context), rr.Type); |
||||
} |
||||
|
||||
protected void AssertError(Type expectedType, ResolveResult rr) |
||||
{ |
||||
Assert.IsTrue(rr.IsError, rr.ToString() + " is not an error, but an error was expected"); |
||||
Assert.IsFalse(rr.IsCompileTimeConstant, rr.ToString() + " is a compile-time constant"); |
||||
Assert.AreEqual(expectedType.ToTypeReference().Resolve(context), rr.Type); |
||||
} |
||||
|
||||
IEnumerable<AstLocation> FindDollarSigns(string code) |
||||
{ |
||||
int line = 1; |
||||
int col = 1; |
||||
foreach (char c in code) { |
||||
if (c == '$') { |
||||
yield return new AstLocation(line, col); |
||||
} else if (c == '\n') { |
||||
line++; |
||||
col = 1; |
||||
} else { |
||||
col++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
protected ResolveResult Resolve(string code) |
||||
{ |
||||
CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", ""))); |
||||
|
||||
AstLocation[] dollars = FindDollarSigns(code).ToArray(); |
||||
Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); |
||||
|
||||
UsingScope rootUsingScope = resolver.UsingScope; |
||||
while (rootUsingScope.Parent != null) |
||||
rootUsingScope = rootUsingScope.Parent; |
||||
|
||||
ParsedFile parsedFile = new ParsedFile("test.cs", rootUsingScope); |
||||
TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(parsedFile, resolver.UsingScope, null); |
||||
cu.AcceptVisitor(convertVisitor, null); |
||||
project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null); |
||||
|
||||
FindNodeVisitor fnv = new FindNodeVisitor(dollars[0], dollars[1]); |
||||
cu.AcceptVisitor(fnv, null); |
||||
Assert.IsNotNull(fnv.ResultNode, "Did not find DOM node at the specified location"); |
||||
|
||||
var navigator = new NodeListResolveVisitorNavigator(new[] { fnv.ResultNode }); |
||||
ResolveResult rr; |
||||
using (var context = this.context.Synchronize()) { |
||||
ResolveVisitor rv = new ResolveVisitor(new CSharpResolver(context), convertVisitor.ParsedFile, navigator); |
||||
rv.Scan(cu); |
||||
rr = rv.GetResolveResult(fnv.ResultNode); |
||||
} |
||||
Assert.IsNotNull(rr, "ResolveResult is null - did something go wrong while navigating to the target node?"); |
||||
return rr; |
||||
} |
||||
|
||||
protected T Resolve<T>(string code) where T : ResolveResult |
||||
{ |
||||
ResolveResult rr = Resolve(code); |
||||
Assert.IsInstanceOf(typeof(T), rr); |
||||
return (T)rr; |
||||
} |
||||
|
||||
protected T Resolve<T>(string code, string exprToResolve) where T : ResolveResult |
||||
{ |
||||
return Resolve<T>(code.Replace(exprToResolve, "$" + exprToResolve + "$")); |
||||
} |
||||
|
||||
sealed class FindNodeVisitor : DepthFirstAstVisitor<object, object> |
||||
{ |
||||
readonly AstLocation start; |
||||
readonly AstLocation end; |
||||
public AstNode ResultNode; |
||||
|
||||
public FindNodeVisitor(AstLocation start, AstLocation end) |
||||
{ |
||||
this.start = start; |
||||
this.end = end; |
||||
} |
||||
|
||||
protected override object VisitChildren(AstNode node, object data) |
||||
{ |
||||
if (node.StartLocation == start && node.EndLocation == end) { |
||||
if (ResultNode != null) |
||||
throw new InvalidOperationException("found multiple nodes with same start+end"); |
||||
return ResultNode = node; |
||||
} else { |
||||
return base.VisitChildren(node, data); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,158 @@
@@ -0,0 +1,158 @@
|
||||
// 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.Collections.ObjectModel; |
||||
using System.Linq; |
||||
|
||||
using ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class TypeInferenceTests |
||||
{ |
||||
TypeInference ti; |
||||
|
||||
[SetUp] |
||||
public void Setup() |
||||
{ |
||||
ti = new TypeInference(CecilLoaderTests.Mscorlib); |
||||
} |
||||
|
||||
IType[] Resolve(params Type[] types) |
||||
{ |
||||
IType[] r = new IType[types.Length]; |
||||
for (int i = 0; i < types.Length; i++) { |
||||
r[i] = types[i].ToTypeReference().Resolve(CecilLoaderTests.Mscorlib); |
||||
Assert.AreNotSame(r[i], SharedTypes.UnknownType); |
||||
} |
||||
Array.Sort(r, (a,b)=>a.ReflectionName.CompareTo(b.ReflectionName)); |
||||
return r; |
||||
} |
||||
|
||||
IType[] FindAllTypesInBounds(IList<IType> lowerBounds, IList<IType> upperBounds = null) |
||||
{ |
||||
ti.Algorithm = TypeInferenceAlgorithm.ImprovedReturnAllResults; |
||||
IType type = ti.FindTypeInBounds(lowerBounds, upperBounds ?? new IType[0]); |
||||
return ExpandIntersections(type).OrderBy(t => t.ReflectionName).ToArray(); |
||||
} |
||||
|
||||
static IEnumerable<IType> ExpandIntersections(IType type) |
||||
{ |
||||
IntersectionType it = type as IntersectionType; |
||||
if (it != null) { |
||||
return it.Types.SelectMany(t => ExpandIntersections(t)); |
||||
} |
||||
ParameterizedType pt = type as ParameterizedType; |
||||
if (pt != null) { |
||||
IType[][] typeArguments = new IType[pt.TypeArguments.Count][]; |
||||
for (int i = 0; i < typeArguments.Length; i++) { |
||||
typeArguments[i] = ExpandIntersections(pt.TypeArguments[i]).ToArray(); |
||||
} |
||||
return AllCombinations(typeArguments).Select(ta => new ParameterizedType(pt.GetDefinition(), ta)); |
||||
} |
||||
return new [] { type }; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Performs the combinatorial explosion.
|
||||
/// </summary>
|
||||
static IEnumerable<IType[]> AllCombinations(IType[][] typeArguments) |
||||
{ |
||||
int[] index = new int[typeArguments.Length]; |
||||
index[typeArguments.Length - 1] = -1; |
||||
while (true) { |
||||
int i; |
||||
for (i = index.Length - 1; i >= 0; i--) { |
||||
if (++index[i] == typeArguments[i].Length) |
||||
index[i] = 0; |
||||
else |
||||
break; |
||||
} |
||||
if (i < 0) |
||||
break; |
||||
IType[] r = new IType[typeArguments.Length]; |
||||
for (i = 0; i < r.Length; i++) { |
||||
r[i] = typeArguments[i][index[i]]; |
||||
} |
||||
yield return r; |
||||
} |
||||
} |
||||
|
||||
[Test] |
||||
public void ListOfShortAndInt() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(IList)), |
||||
FindAllTypesInBounds(Resolve(typeof(List<short>), typeof(List<int>)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ListOfStringAndObject() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(IList), typeof(IEnumerable<object>)), |
||||
FindAllTypesInBounds(Resolve(typeof(List<string>), typeof(List<object>)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ListOfListOfStringAndObject() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(IList), typeof(IEnumerable<IList>), typeof(IEnumerable<IEnumerable<object>>)), |
||||
FindAllTypesInBounds(Resolve(typeof(List<List<string>>), typeof(List<List<object>>)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void ShortAndInt() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(int)), |
||||
FindAllTypesInBounds(Resolve(typeof(short), typeof(int)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void StringAndVersion() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(ICloneable), typeof(IComparable)), |
||||
FindAllTypesInBounds(Resolve(typeof(string), typeof(Version)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void CommonSubTypeClonableComparable() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(string), typeof(Version)), |
||||
FindAllTypesInBounds(Resolve(), Resolve(typeof(ICloneable), typeof(IComparable)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void EnumerableOfStringAndVersion() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(IEnumerable<ICloneable>), typeof(IEnumerable<IComparable>)), |
||||
FindAllTypesInBounds(Resolve(typeof(IList<string>), typeof(IList<Version>)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void CommonSubTypeIEnumerableClonableIEnumerableComparable() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(IEnumerable<string>), typeof(IEnumerable<Version>)), |
||||
FindAllTypesInBounds(Resolve(), Resolve(typeof(IEnumerable<ICloneable>), typeof(IEnumerable<IComparable>)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void CommonSubTypeIEnumerableClonableIEnumerableComparableList() |
||||
{ |
||||
Assert.AreEqual( |
||||
Resolve(typeof(List<string>), typeof(List<Version>), typeof(Collection<string>), typeof(Collection<Version>), typeof(ReadOnlyCollection<string>), typeof(ReadOnlyCollection<Version>)), |
||||
FindAllTypesInBounds(Resolve(), Resolve(typeof(IEnumerable<ICloneable>), typeof(IEnumerable<IComparable>), typeof(IList)))); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,147 @@
@@ -0,0 +1,147 @@
|
||||
// Copyright (c) 2010 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 ICSharpCode.NRefactory.TypeSystem; |
||||
using NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
// assign short name to the fake reflection type
|
||||
using dynamic = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Dynamic; |
||||
|
||||
[TestFixture] |
||||
public unsafe class UnaryOperatorTests : ResolverTestBase |
||||
{ |
||||
[Test] |
||||
public void TestAddressOf() |
||||
{ |
||||
AssertType(typeof(int*), resolver.ResolveUnaryOperator(UnaryOperatorType.AddressOf, MakeResult(typeof(int)))); |
||||
AssertType(typeof(byte**), resolver.ResolveUnaryOperator(UnaryOperatorType.AddressOf, MakeResult(typeof(byte*)))); |
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.AddressOf, MakeResult(typeof(dynamic)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestDereference() |
||||
{ |
||||
AssertType(typeof(int), resolver.ResolveUnaryOperator(UnaryOperatorType.Dereference, MakeResult(typeof(int*)))); |
||||
AssertType(typeof(long*), resolver.ResolveUnaryOperator(UnaryOperatorType.Dereference, MakeResult(typeof(long**)))); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Dereference, MakeResult(typeof(int))).IsError); |
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.Dereference, MakeResult(typeof(dynamic)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestIncrementDecrement() |
||||
{ |
||||
AssertType(typeof(byte), resolver.ResolveUnaryOperator(UnaryOperatorType.Increment, MakeResult(typeof(byte)))); |
||||
AssertType(typeof(ulong), resolver.ResolveUnaryOperator(UnaryOperatorType.Decrement, MakeResult(typeof(ulong)))); |
||||
AssertType(typeof(short?), resolver.ResolveUnaryOperator(UnaryOperatorType.PostDecrement, MakeResult(typeof(short?)))); |
||||
AssertType(typeof(TypeCode), resolver.ResolveUnaryOperator(UnaryOperatorType.PostIncrement, MakeResult(typeof(TypeCode)))); |
||||
AssertType(typeof(TypeCode?), resolver.ResolveUnaryOperator(UnaryOperatorType.PostIncrement, MakeResult(typeof(TypeCode?)))); |
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.PostIncrement, MakeResult(typeof(dynamic)))); |
||||
AssertError(typeof(object), resolver.ResolveUnaryOperator(UnaryOperatorType.Increment, MakeResult(typeof(object)))); |
||||
|
||||
AssertType(typeof(int*), resolver.ResolveUnaryOperator(UnaryOperatorType.Increment, MakeResult(typeof(int*)))); |
||||
AssertType(typeof(uint*), resolver.ResolveUnaryOperator(UnaryOperatorType.PostDecrement, MakeResult(typeof(uint*)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestUnaryPlus() |
||||
{ |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((sbyte)1))); |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((byte)1))); |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((short)1))); |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((ushort)1))); |
||||
AssertConstant(65, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant('A'))); |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant(1))); |
||||
AssertConstant((uint)1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((uint)1))); |
||||
AssertConstant(1L, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((long)1))); |
||||
AssertConstant((ulong)1, resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant((ulong)1))); |
||||
|
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeResult(typeof(dynamic)))); |
||||
AssertType(typeof(int?), resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeResult(typeof(ushort?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestUnaryMinus() |
||||
{ |
||||
AssertConstant(-1, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(1))); |
||||
AssertConstant(-1L, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant((uint)1))); |
||||
AssertConstant(-2147483648L, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(2147483648))); |
||||
AssertConstant(-1.0f, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(1.0f))); |
||||
AssertConstant(-1.0, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(1.0))); |
||||
AssertConstant(1m, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(-1m))); |
||||
AssertConstant(-65, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant('A'))); |
||||
|
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeResult(typeof(dynamic)))); |
||||
AssertType(typeof(long?), resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeResult(typeof(uint?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestUnaryMinusUncheckedOverflow() |
||||
{ |
||||
AssertConstant(-2147483648, resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(-2147483648))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestUnaryMinusCheckedOverflow() |
||||
{ |
||||
resolver.CheckForOverflow = true; |
||||
AssertError(typeof(int), resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(-2147483648))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestBitwiseNot() |
||||
{ |
||||
AssertConstant(1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant(-2))); |
||||
AssertConstant(~'A', resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant('A'))); |
||||
AssertConstant(~(sbyte)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((sbyte)1))); |
||||
AssertConstant(~(byte)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((byte)1))); |
||||
AssertConstant(~(short)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((short)1))); |
||||
AssertConstant(~(ushort)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((ushort)1))); |
||||
AssertConstant(~(uint)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((uint)1))); |
||||
AssertConstant(~(long)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((long)1))); |
||||
AssertConstant(~(ulong)1, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant((ulong)1))); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant(1.0)).IsError); |
||||
|
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeResult(typeof(dynamic)))); |
||||
AssertType(typeof(uint), resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeResult(typeof(uint)))); |
||||
AssertType(typeof(int?), resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeResult(typeof(ushort?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestLogicalNot() |
||||
{ |
||||
AssertConstant(true, resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeConstant(false))); |
||||
AssertConstant(false, resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeConstant(true))); |
||||
AssertType(typeof(dynamic), resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeResult(typeof(dynamic)))); |
||||
AssertType(typeof(bool), resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeResult(typeof(bool)))); |
||||
AssertType(typeof(bool?), resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeResult(typeof(bool?)))); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestInvalidUnaryOperatorsOnEnum() |
||||
{ |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeConstant(StringComparison.Ordinal)).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeConstant(StringComparison.Ordinal)).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeConstant(StringComparison.Ordinal)).IsError); |
||||
|
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeResult(typeof(StringComparison))).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeResult(typeof(StringComparison))).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeResult(typeof(StringComparison))).IsError); |
||||
|
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Not, MakeResult(typeof(StringComparison?))).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Plus, MakeResult(typeof(StringComparison?))).IsError); |
||||
Assert.IsTrue(resolver.ResolveUnaryOperator(UnaryOperatorType.Minus, MakeResult(typeof(StringComparison?))).IsError); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestBitwiseNotOnEnum() |
||||
{ |
||||
AssertConstant(~StringComparison.Ordinal, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant(StringComparison.Ordinal))); |
||||
AssertConstant(~StringComparison.CurrentCultureIgnoreCase, resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeConstant(StringComparison.CurrentCultureIgnoreCase))); |
||||
AssertType(typeof(StringComparison), resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeResult(typeof(StringComparison)))); |
||||
AssertType(typeof(StringComparison?), resolver.ResolveUnaryOperator(UnaryOperatorType.BitNot, MakeResult(typeof(StringComparison?)))); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,29 @@
@@ -0,0 +1,29 @@
|
||||
// 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 NUnit.Framework; |
||||
|
||||
namespace ICSharpCode.NRefactory.CSharp.Resolver |
||||
{ |
||||
[TestFixture] |
||||
public class UnsafeCodeTests : ResolverTestBase |
||||
{ |
||||
[Test, Ignore("Parser produces parse tree that doesn't match DOM definition??")] |
||||
public void FixedStatement() |
||||
{ |
||||
string program = @"using System;
|
||||
class TestClass { |
||||
static void Main(byte[] a) { |
||||
fixed (byte* p = a) { |
||||
a = $p$; |
||||
} } }";
|
||||
|
||||
var lrr = Resolve<LocalResolveResult>(program); |
||||
Assert.AreEqual("System.Byte*", lrr.Type.ReflectionName); |
||||
|
||||
var rr = Resolve<ResolveResult>(program.Replace("$p$", "$*p$")); |
||||
Assert.AreEqual("System.Byte", lrr.Type.ReflectionName); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,530 @@
@@ -0,0 +1,530 @@
|
||||
//
|
||||
// TestBraceStyle.cs
|
||||
//
|
||||
// Author:
|
||||
// Mike Krüger <mkrueger@novell.com>
|
||||
//
|
||||
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
// 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; |
||||
using NUnit.Framework; |
||||
using MonoDevelop.Ide.Gui; |
||||
using MonoDevelop.Projects; |
||||
using MonoDevelop.Core; |
||||
using MonoDevelop.Ide.CodeCompletion; |
||||
using MonoDevelop.Ide.Gui.Content; |
||||
using MonoDevelop.Projects.Dom.Parser; |
||||
using MonoDevelop.CSharp.Parser; |
||||
using MonoDevelop.CSharp.Resolver; |
||||
using MonoDevelop.CSharp.Completion; |
||||
using Mono.TextEditor; |
||||
using MonoDevelop.CSharp.Formatting; |
||||
|
||||
namespace MonoDevelop.CSharpBinding.FormattingTests |
||||
{ |
||||
[TestFixture()] |
||||
public class TestBraceStyle : UnitTests.TestBase |
||||
{ |
||||
[Test()] |
||||
[Ignore("currently failing because namespaces are not inserted")] |
||||
public void TestNamespaceBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"namespace A
|
||||
{ |
||||
namespace B { |
||||
class Test {} |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.NamespaceBraceStyle = BraceStyle.EndOfLine; |
||||
policy.ClassBraceStyle = BraceStyle.DoNotChange; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"namespace A {
|
||||
namespace B { |
||||
class Test {} |
||||
} |
||||
}", data.Document.Text);
|
||||
|
||||
policy.NamespaceBraceStyle = BraceStyle.NextLineShifted; |
||||
compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"namespace A
|
||||
{ |
||||
namespace B |
||||
{ |
||||
class Test {} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
|
||||
[Test()] |
||||
public void TestClassBraceStlye () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test {}"; |
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.ClassBraceStyle = BraceStyle.EndOfLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"class Test {
|
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestStructBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"struct Test {}"; |
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.StructBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"struct Test
|
||||
{ |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestInterfaceBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"interface Test {}"; |
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.InterfaceBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"interface Test
|
||||
{ |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestEnumBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"enum Test {
|
||||
A |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.EnumBraceStyle = BraceStyle.NextLineShifted; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
Assert.AreEqual (@"enum Test
|
||||
{ |
||||
A |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestMethodBraceStlye () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test MyMethod() {} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.MethodBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test MyMethod() |
||||
{ |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestConstructorBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test() {} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.ConstructorBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test() |
||||
{ |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestDestructorBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
~Test() {} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.DestructorBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
~Test() |
||||
{ |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestPropertyBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test A { |
||||
get; |
||||
set; |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PropertyBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A |
||||
{ |
||||
get; |
||||
set; |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestPropertyGetBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test A { |
||||
get { |
||||
return null; |
||||
} |
||||
set; |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PropertyGetBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get |
||||
{ |
||||
return null; |
||||
} |
||||
set; |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestAllowPropertyGetBlockInline () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test A { |
||||
get { return null; } |
||||
set { ; } |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PropertyBraceStyle = BraceStyle.DoNotChange; |
||||
policy.AllowPropertyGetBlockInline = true; |
||||
policy.AllowPropertySetBlockInline = false; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get { return null; } |
||||
set { |
||||
; |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
|
||||
policy.AllowPropertyGetBlockInline = false; |
||||
compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get { |
||||
return null; |
||||
} |
||||
set { |
||||
; |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestAllowPropertySetBlockInline () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test A { |
||||
get { return null; } |
||||
set { ; } |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PropertyBraceStyle = BraceStyle.DoNotChange; |
||||
policy.AllowPropertyGetBlockInline = false; |
||||
policy.AllowPropertySetBlockInline = true; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get { |
||||
return null; |
||||
} |
||||
set { ; } |
||||
} |
||||
}", data.Document.Text);
|
||||
|
||||
policy.AllowPropertySetBlockInline = false; |
||||
compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get { |
||||
return null; |
||||
} |
||||
set { |
||||
; |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestPropertySetBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
Test A { |
||||
get; |
||||
set { |
||||
; |
||||
} |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PropertySetBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
Test A { |
||||
get; |
||||
set |
||||
{ |
||||
; |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestEventBraceStyle () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
public event EventHandler Handler { |
||||
add { |
||||
} |
||||
remove { |
||||
} |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.EventBraceStyle = BraceStyle.NextLine; |
||||
policy.EventAddBraceStyle = BraceStyle.NextLine; |
||||
policy.EventRemoveBraceStyle = BraceStyle.NextLine; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
public event EventHandler Handler |
||||
{ |
||||
add |
||||
{ |
||||
} |
||||
remove |
||||
{ |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestAllowEventAddBlockInline () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
public event EventHandler Handler { |
||||
add { ; } |
||||
remove { ; } |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.AllowEventAddBlockInline = true; |
||||
policy.AllowEventRemoveBlockInline = false; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
public event EventHandler Handler { |
||||
add { ; } |
||||
remove { |
||||
; |
||||
} |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
[Test()] |
||||
public void TestAllowEventRemoveBlockInline () |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = @"class Test
|
||||
{ |
||||
public event EventHandler Handler { |
||||
add { ; } |
||||
remove { ; } |
||||
} |
||||
}";
|
||||
|
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.AllowEventAddBlockInline = false; |
||||
policy.AllowEventRemoveBlockInline = true; |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
compilationUnit.AcceptVisitor (new DomIndentationVisitor (policy, data), null); |
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
Assert.AreEqual (@"class Test
|
||||
{ |
||||
public event EventHandler Handler { |
||||
add { |
||||
; |
||||
} |
||||
remove { ; } |
||||
} |
||||
}", data.Document.Text);
|
||||
} |
||||
|
||||
|
||||
|
||||
} |
||||
}*/ |
||||
@ -0,0 +1,162 @@
@@ -0,0 +1,162 @@
|
||||
//
|
||||
// TestFormattingBugs.cs
|
||||
//
|
||||
// Author:
|
||||
// Mike Krüger <mkrueger@novell.com>
|
||||
//
|
||||
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
// 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; |
||||
using NUnit.Framework; |
||||
using MonoDevelop.Ide.Gui; |
||||
using MonoDevelop.Projects; |
||||
using MonoDevelop.Core; |
||||
using MonoDevelop.Ide.CodeCompletion; |
||||
using MonoDevelop.Ide.Gui.Content; |
||||
using MonoDevelop.Projects.Dom.Parser; |
||||
using MonoDevelop.CSharp.Parser; |
||||
using MonoDevelop.CSharp.Resolver; |
||||
using MonoDevelop.CSharp.Completion; |
||||
using Mono.TextEditor; |
||||
using MonoDevelop.CSharp.Formatting; |
||||
using System.Collections.Generic; |
||||
using MonoDevelop.Refactoring; |
||||
|
||||
namespace MonoDevelop.CSharpBinding.FormattingTests |
||||
{ |
||||
[TestFixture()] |
||||
public class TestFormattingBugs : UnitTests.TestBase |
||||
{ |
||||
/// <summary>
|
||||
/// Bug 325187 - Bug in smart indent
|
||||
/// </summary>
|
||||
[Test()] |
||||
public void TestBug325187 () |
||||
{ |
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
policy.PlaceElseOnNewLine = true; |
||||
|
||||
TestStatementFormatting (policy, |
||||
@"foreach (int i in myints)
|
||||
if (i == 6) |
||||
Console.WriteLine (""Yeah""); |
||||
else |
||||
Console.WriteLine (""Bad indent"");",
|
||||
@"foreach (int i in myints)
|
||||
if (i == 6) |
||||
Console.WriteLine (""Yeah""); |
||||
else |
||||
Console.WriteLine (""Bad indent"");");
|
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Bug 415469 - return ternary in a switch is not tabbed properly
|
||||
/// </summary>
|
||||
[Test()] |
||||
[Ignore("currently failing because of 'string' has the wrong offset - mcs bug")] |
||||
public void TestBug415469 () |
||||
{ |
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
|
||||
TestStatementFormatting (policy, |
||||
@"switch (condition) {
|
||||
case CONDITION1: |
||||
return foo != null ? foo.Bar : null; |
||||
case CONDITION2: |
||||
string goo = foo != null ? foo.Bar : null; |
||||
return ""Should be indented like this""; |
||||
}", @"switch (condition) { |
||||
case CONDITION1: |
||||
return foo != null ? foo.Bar : null; |
||||
case CONDITION2: |
||||
string goo = foo != null ? foo.Bar : null; |
||||
return ""Should be indented like this""; |
||||
}");
|
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Bug 540043 - Format option for alignment of using-statements
|
||||
/// </summary>
|
||||
[Test()] |
||||
public void TestBug540043 () |
||||
{ |
||||
CSharpFormattingPolicy policy = new CSharpFormattingPolicy (); |
||||
|
||||
TestStatementFormatting (policy, |
||||
@"using (IDisposable a = null)
|
||||
using (IDisposable b = null) { |
||||
int c; |
||||
} |
||||
", @"using (IDisposable a = null) |
||||
using (IDisposable b = null) { |
||||
int c; |
||||
}");
|
||||
} |
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static void TestStatementFormatting (CSharpFormattingPolicy policy, string input, string expectedOutput) |
||||
{ |
||||
TextEditorData data = new TextEditorData (); |
||||
data.Document.FileName = "a.cs"; |
||||
data.Document.Text = |
||||
@"class Test
|
||||
{ |
||||
MyType TestMethod () |
||||
{ |
||||
" + input + @" |
||||
} |
||||
}";
|
||||
|
||||
Console.WriteLine (data.Document.Text); |
||||
|
||||
CSharp.Dom.CompilationUnit compilationUnit = new CSharpParser ().Parse (data); |
||||
DomSpacingVisitor domSpacingVisitor = new DomSpacingVisitor (policy, data); |
||||
domSpacingVisitor.AutoAcceptChanges = false; |
||||
compilationUnit.AcceptVisitor (domSpacingVisitor, null); |
||||
|
||||
DomIndentationVisitor domIndentationVisitor = new DomIndentationVisitor (policy, data); |
||||
domIndentationVisitor.AutoAcceptChanges = false; |
||||
compilationUnit.AcceptVisitor (domIndentationVisitor, null); |
||||
|
||||
List<Change> changes = new List<Change> (); |
||||
changes.AddRange (domSpacingVisitor.Changes); |
||||
changes.AddRange (domIndentationVisitor.Changes); |
||||
RefactoringService.AcceptChanges (null, null, changes); |
||||
|
||||
for (int i = 0; i < data.Document.LineCount; i++) { |
||||
LineSegment line = data.Document.GetLine (i); |
||||
if (line.EditableLength < 2) |
||||
continue; |
||||
data.Remove (line.Offset, 2); |
||||
} |
||||
string text = data.Document.GetTextBetween (data.Document.GetLine (4).Offset, |
||||
data.Document.GetLine (data.Document.LineCount - 2).Offset).Trim (); |
||||
Console.WriteLine (text); |
||||
Assert.AreEqual (expectedOutput, text); |
||||
} |
||||
|
||||
|
||||
} |
||||
} |
||||
*/ |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue