pimhwang
/
SharpDevelop
mirror of https://github.com/icsharpcode/SharpDevelop.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Implement EnvDTE.CodeProperty2

pull/375/head
Matt Ward 12 years ago
parent
73eb90fe9d
commit
9c6217e718
11 changed files with 489 additions and 885 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeElement.cs
  2. 1
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs
  3. 136
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeProperty.cs
  4. 82
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeProperty2.cs
  5. 3
      src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
  6. 61
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs
  7. 655
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeProperty2Tests.cs
  8. 67
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/AttributeHelper.cs
  9. 228
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ClassHelper.cs
  10. 8
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/CodeElementsExtensions.cs
  11. 128
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PropertyHelper.cs

5
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeElement.cs
Unescape View File

@ -49,10 +49,9 @@ namespace ICSharpCode.PackageManagement.EnvDTE
return new CodeVariable(context, (IField)member); return new CodeVariable(context, (IField)member);
case SymbolKind.Property: case SymbolKind.Property:
case SymbolKind.Indexer: case SymbolKind.Indexer:
// return new CodeProperty2(m); return new CodeProperty2(context, (IProperty)member);
throw new NotImplementedException();
case SymbolKind.Event: case SymbolKind.Event:
return null; // events are not supported in EnvDTE? return null;
case SymbolKind.Method: case SymbolKind.Method:
case SymbolKind.Operator: case SymbolKind.Operator:
case SymbolKind.Constructor: case SymbolKind.Constructor:

1
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs
Unescape View File

@ -13,6 +13,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
public CodeFunction(CodeModelContext context, IMethod method) public CodeFunction(CodeModelContext context, IMethod method)
: base(context, method) : base(context, method)
{ {
this.method = method;
} }
public CodeFunction() public CodeFunction()

136
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeProperty.cs
Unescape View File

@ -1,68 +1,68 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System; using System;
//using ICSharpCode.SharpDevelop.Dom; using ICSharpCode.NRefactory.TypeSystem;
//
//namespace ICSharpCode.PackageManagement.EnvDTE namespace ICSharpCode.PackageManagement.EnvDTE
//{ {
// public class CodeProperty : CodeElement, global::EnvDTE.CodeProperty public class CodeProperty : CodeElement, global::EnvDTE.CodeProperty
// { {
// public CodeProperty() protected readonly IProperty property;
// {
// } public CodeProperty()
// {
// public CodeProperty(IProperty property) }
// : base(property)
// { public CodeProperty(CodeModelContext context, IProperty property)
// this.Property = property; : base(context, property)
// } {
// this.property = property;
// protected IProperty Property { get; private set; } }
//
// public override global::EnvDTE.vsCMElement Kind { public override global::EnvDTE.vsCMElement Kind {
// get { return global::EnvDTE.vsCMElement.vsCMElementProperty; } get { return global::EnvDTE.vsCMElement.vsCMElementProperty; }
// } }
//
// public virtual global::EnvDTE.vsCMAccess Access { public virtual global::EnvDTE.vsCMAccess Access {
// get { return GetAccess(); } get { return property.Accessibility.ToAccess(); }
// set { } set { }
// } }
//
// public virtual global::EnvDTE.CodeClass Parent { public virtual global::EnvDTE.CodeClass Parent {
// get { return new CodeClass(Property.ProjectContent, Property.DeclaringType); } get { return new CodeClass(context, property.DeclaringTypeDefinition); }
// } }
//
// public virtual global::EnvDTE.CodeElements Attributes { public virtual global::EnvDTE.CodeElements Attributes {
// get { return new CodeAttributes(Property); } get { return GetAttributes(property); }
// } }
//
// public virtual global::EnvDTE.CodeTypeRef Type { public virtual global::EnvDTE.CodeTypeRef Type {
// get { return new CodeTypeRef2(Property.ProjectContent, this, Property.ReturnType); } get { return new CodeTypeRef2(context, this, property.ReturnType); }
// } }
//
// public virtual global::EnvDTE.CodeFunction Getter { public virtual global::EnvDTE.CodeFunction Getter {
// get { return GetGetter(); } get { return GetGetter(); }
// } }
//
// CodeFunction GetGetter() CodeFunction GetGetter()
// { {
// if (Property.CanGet) { if (property.CanGet) {
// return new CodeGetterFunction(Property); return new CodeFunction2(context, property.Getter);
// } }
// return null; return null;
// } }
//
// public virtual global::EnvDTE.CodeFunction Setter { public virtual global::EnvDTE.CodeFunction Setter {
// get { return GetSetter(); } get { return GetSetter(); }
// } }
//
// CodeFunction GetSetter() CodeFunction GetSetter()
// { {
// if (Property.CanSet) { if (property.CanSet) {
// return new CodeSetterFunction(Property); return new CodeFunction2(context, property.Setter);
// } }
// return null; return null;
// } }
// } }
//} }

82
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeProperty2.cs
Unescape View File

@ -1,38 +1,44 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System; using System;
//using ICSharpCode.SharpDevelop.Dom; using System.Linq;
// using ICSharpCode.NRefactory.TypeSystem;
//namespace ICSharpCode.PackageManagement.EnvDTE using ICSharpCode.SharpDevelop;
//{
// public class CodeProperty2 : CodeProperty, global::EnvDTE.CodeProperty2 namespace ICSharpCode.PackageManagement.EnvDTE
// { {
// public CodeProperty2() public class CodeProperty2 : CodeProperty, global::EnvDTE.CodeProperty2
// { {
// } public CodeProperty2()
// {
// public CodeProperty2(IProperty property) }
// : base(property)
// { public CodeProperty2(CodeModelContext context, IProperty property)
// } : base(context, property)
// {
// public global::EnvDTE.vsCMPropertyKind ReadWrite { }
// get { return GetPropertyKind(); }
// } public global::EnvDTE.vsCMPropertyKind ReadWrite {
// get { return GetPropertyKind(); }
// global::EnvDTE.vsCMPropertyKind GetPropertyKind() }
// {
// if (Property.CanSet && Property.CanGet) { global::EnvDTE.vsCMPropertyKind GetPropertyKind()
// return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadWrite; {
// } else if (Property.CanSet) { if (property.CanSet && property.CanGet) {
// return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindWriteOnly; return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadWrite;
// } } else if (property.CanSet) {
// return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadOnly; return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindWriteOnly;
// } }
// return global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadOnly;
// public global::EnvDTE.CodeElements Parameters { }
// get { return new CodeParameters(null, Property.Parameters); }
// } public global::EnvDTE.CodeElements Parameters {
// } get {
//} var parameters = new CodeElementsList<CodeElement>();
parameters.AddRange(property.Parameters.Select(parameter => new CodeParameter2(context, parameter)));
return parameters;
}
}
}
}

3
src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
Unescape View File

@ -114,8 +114,6 @@
<Compile Include="Src\EnvDTE\SolutionGlobalsTests.cs" /> <Compile Include="Src\EnvDTE\SolutionGlobalsTests.cs" />
<Compile Include="Src\EnvDTE\SolutionPropertyTests.cs" /> <Compile Include="Src\EnvDTE\SolutionPropertyTests.cs" />
<Compile Include="Src\EnvDTE\SolutionTests.cs" /> <Compile Include="Src\EnvDTE\SolutionTests.cs" />
<Compile Include="Src\Helpers\AttributeHelper.cs" />
<Compile Include="Src\Helpers\ClassHelper.cs" />
<Compile Include="Src\Helpers\CodeElementsExtensions.cs" /> <Compile Include="Src\Helpers\CodeElementsExtensions.cs" />
<Compile Include="Src\Helpers\CompilationUnitHelper.cs" /> <Compile Include="Src\Helpers\CompilationUnitHelper.cs" />
<Compile Include="Src\Helpers\ExceptionThrowingPackageActionRunner.cs" /> <Compile Include="Src\Helpers\ExceptionThrowingPackageActionRunner.cs" />
@ -132,7 +130,6 @@
<Compile Include="Src\Helpers\ParameterHelper.cs" /> <Compile Include="Src\Helpers\ParameterHelper.cs" />
<Compile Include="Src\Helpers\ProjectContentHelper.cs" /> <Compile Include="Src\Helpers\ProjectContentHelper.cs" />
<Compile Include="Src\Helpers\PropertiesHelper.cs" /> <Compile Include="Src\Helpers\PropertiesHelper.cs" />
<Compile Include="Src\Helpers\PropertyHelper.cs" />
<Compile Include="Src\Helpers\ReturnTypeHelper.cs" /> <Compile Include="Src\Helpers\ReturnTypeHelper.cs" />
<Compile Include="Src\Helpers\SelectedProjectCollectionAssert.cs" /> <Compile Include="Src\Helpers\SelectedProjectCollectionAssert.cs" />
<Compile Include="Src\Helpers\SolutionHelper.cs" /> <Compile Include="Src\Helpers\SolutionHelper.cs" />

61
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs
Unescape View File

@ -147,20 +147,20 @@ namespace PackageManagement.Tests.EnvDTE
Assert.AreEqual("MyMethod", codeFunction.Name); Assert.AreEqual("MyMethod", codeFunction.Name);
} }
// [Test] [Test]
// public void Members_ClassHasOneProperty_ReturnsOneProperty() public void Members_ClassHasOneProperty_ReturnsOneProperty()
// { {
// CreateClass( CreateClass(
// "public class MyClass {\r\n" + "public class MyClass {\r\n" +
// " public int MyProperty { get; set; }\r\n" + " public int MyProperty { get; set; }\r\n" +
// "}"); "}");
//
// global::EnvDTE.CodeElements codeElements = codeClass.Members; global::EnvDTE.CodeElements codeElements = codeClass.Members;
//
// CodeProperty2 codeFunction = codeElements.FirstCodeProperty2OrDefault(); CodeProperty2 codeProperty = codeElements.FirstCodeProperty2OrDefault();
// Assert.AreEqual(1, codeElements.Count); Assert.AreEqual(1, codeElements.Count);
// Assert.AreEqual("MyProperty", codeFunction.Name); Assert.AreEqual("MyProperty", codeProperty.Name);
// } }
[Test] [Test]
public void Members_ClassHasOneField_ReturnsOneField() public void Members_ClassHasOneField_ReturnsOneField()
@ -224,22 +224,23 @@ namespace PackageManagement.Tests.EnvDTE
Assert.AreEqual(1, partialClasses.Count); Assert.AreEqual(1, partialClasses.Count);
Assert.AreEqual(codeClass, firstClass); Assert.AreEqual(codeClass, firstClass);
} }
//
// [Test] [Test]
// public void Members_GetFirstPropertyTwice_PropertiesAreConsideredEqualWhenAddedToList() public void Members_GetFirstPropertyTwice_PropertiesAreConsideredEqualWhenAddedToList()
// { {
// CreateProjectContent(); CreateClass(
// CreatePublicClass("MyClass"); "public class MyClass {\r\n" +
// helper.AddPropertyToClass("MyClass.MyProperty"); " public int MyProperty { get; set; }\r\n" +
// CodeProperty2 property = codeClass.Members.FirstCodeProperty2OrDefault(); "}");
// var properties = new List<CodeProperty2>(); CodeProperty2 property = codeClass.Members.FirstCodeProperty2OrDefault();
// properties.Add(property); var properties = new List<CodeProperty2>();
// properties.Add(property);
// CodeProperty2 property2 = codeClass.Members.FirstCodeProperty2OrDefault();
// CodeProperty2 property2 = codeClass.Members.FirstCodeProperty2OrDefault();
// bool contains = properties.Contains(property2);
// Assert.IsTrue(contains); bool contains = properties.Contains(property2);
// } Assert.IsTrue(contains);
}
[Test] [Test]
public void IsAbstract_ClassIsAbstract_ReturnsTrue() public void IsAbstract_ClassIsAbstract_ReturnsTrue()

655
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeProperty2Tests.cs
Unescape View File

@ -1,316 +1,339 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System; using System;
//using ICSharpCode.PackageManagement.EnvDTE; using System.Linq;
//using NUnit.Framework; using ICSharpCode.NRefactory.TypeSystem;
//using PackageManagement.Tests.Helpers; using ICSharpCode.PackageManagement.EnvDTE;
// using NUnit.Framework;
//namespace PackageManagement.Tests.EnvDTE using PackageManagement.Tests.Helpers;
//{
// [TestFixture] namespace PackageManagement.Tests.EnvDTE
// public class CodeProperty2Tests {
// { [TestFixture]
// CodeProperty2 property; public class CodeProperty2Tests : CodeModelTestBase
// PropertyHelper helper; {
// CodeProperty2 property;
// [SetUp]
// public void Init() void CreateCodeProperty2(string code)
// { {
// helper = new PropertyHelper(); AddCodeFile("class.cs", code);
// } IProperty member = assemblyModel
// .TopLevelTypeDefinitions
// void CreateCodeProperty2() .First()
// { .Members
// property = new CodeProperty2(helper.Property); .First()
// } .Resolve() as IProperty;
//
// [Test] property = new CodeProperty2(codeModelContext, member);
// public void Attributes_PropertyHasOneAttribute_ReturnsOneAttribute() }
// {
// helper.CreateProperty("MyProperty"); [Test]
// helper.AddAttribute("Tests.TestAttribute", "TestAttribute"); public void Attributes_PropertyHasOneAttribute_ReturnsOneAttribute()
// CreateCodeProperty2(); {
// CreateCodeProperty2(
// global::EnvDTE.CodeElements attributes = property.Attributes; "class MyClass {\r\n" +
// " [System.Obsolete]\r\n" +
// CodeAttribute2 attribute = attributes.Item(1) as CodeAttribute2; " public int MyProperty { get; set; }\r\n" +
// "}");
// Assert.AreEqual(1, attributes.Count);
// Assert.AreEqual("Tests.TestAttribute", attribute.FullName); global::EnvDTE.CodeElements attributes = property.Attributes;
// }
// CodeAttribute2 attribute = attributes.Item(1) as CodeAttribute2;
// [Test] Assert.AreEqual(1, attributes.Count);
// public void Name_PropertyCalledMyProperty_ReturnsMyProperty() Assert.AreEqual("System.ObsoleteAttribute", attribute.FullName);
// { }
// helper.CreateProperty("MyProperty");
// CreateCodeProperty2(); [Test]
// public void Name_PropertyCalledMyProperty_ReturnsMyProperty()
// string name = property.Name; {
// CreateCodeProperty2(
// Assert.AreEqual("MyProperty", name); "class MyClass {\r\n" +
// } " public int MyProperty { get; set; }\r\n" +
// "}");
// [Test]
// public void Parent_Class1ContainsProperty_ReturnsClass1() string name = property.Name;
// {
// helper.CreateProperty("MyProperty"); Assert.AreEqual("MyProperty", name);
// helper.AddParentClass("Tests.Class1"); }
// CreateCodeProperty2();
// [Test]
// global::EnvDTE.CodeClass parentClass = property.Parent; public void Parent_Class1ContainsProperty_ReturnsClass1()
// {
// Assert.AreEqual("Tests.Class1", parentClass.FullName); CreateCodeProperty2(
// } "namespace Tests {\r\n" +
// " class Class1 {\r\n" +
// [Test] " public int MyProperty { get; set; }\r\n" +
// public void Access_PublicProperty_AccessIsPublic() " }\r\n" +
// { "}");
// helper.CreatePublicProperty("MyProperty");
// CreateCodeProperty2(); global::EnvDTE.CodeClass parentClass = property.Parent;
//
// global::EnvDTE.vsCMAccess access = property.Access; Assert.AreEqual("Tests.Class1", parentClass.FullName);
// }
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access);
// } [Test]
// public void Access_PublicProperty_AccessIsPublic()
// [Test] {
// public void Access_PrivateProperty_AccessIsPrivate() CreateCodeProperty2(
// { "class MyClass {\r\n" +
// helper.CreatePrivateProperty("MyProperty"); " public int MyProperty { get; set; }\r\n" +
// CreateCodeProperty2(); "}");
//
// global::EnvDTE.vsCMAccess access = property.Access; global::EnvDTE.vsCMAccess access = property.Access;
//
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access);
// } }
//
// [Test] [Test]
// public void ReadWrite_PropertyHasGetterAndSetter_ReturnsReadWriteProperty() public void Access_PrivateProperty_AccessIsPrivate()
// { {
// helper.CreatePublicProperty("MyProperty"); CreateCodeProperty2(
// helper.HasGetterAndSetter(); "class MyClass {\r\n" +
// CreateCodeProperty2(); " private int MyProperty { get; set; }\r\n" +
// "}");
// global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite;
// global::EnvDTE.vsCMAccess access = property.Access;
// Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadWrite, kind);
// } Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
// }
// [Test]
// public void ReadWrite_PropertyHasGetterOnly_ReturnsReadOnlyProperty() [Test]
// { public void ReadWrite_PropertyHasGetterAndSetter_ReturnsReadWriteProperty()
// helper.CreatePublicProperty("MyProperty"); {
// helper.HasGetterOnly(); CreateCodeProperty2(
// CreateCodeProperty2(); "class MyClass {\r\n" +
// " public int MyProperty { get; set; }\r\n" +
// global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite; "}");
//
// Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadOnly, kind); global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite;
// }
// Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadWrite, kind);
// [Test] }
// public void ReadWrite_PropertyHasSetterOnly_ReturnsWriteOnlyProperty()
// { [Test]
// helper.CreatePublicProperty("MyProperty"); public void ReadWrite_PropertyHasGetterOnly_ReturnsReadOnlyProperty()
// helper.HasSetterOnly(); {
// CreateCodeProperty2(); CreateCodeProperty2(
// "class MyClass {\r\n" +
// global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite; " public int MyProperty { get { return 0; } }\r\n" +
// "}");
// Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindWriteOnly, kind);
// } global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite;
//
// [Test] Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindReadOnly, kind);
// public void Parameters_PropertyIsIndexerWithOneParameter_ReturnsOneParameter() }
// {
// helper.CreatePublicProperty("MyProperty"); [Test]
// helper.AddParameter("item"); public void ReadWrite_PropertyHasSetterOnly_ReturnsWriteOnlyProperty()
// CreateCodeProperty2(); {
// CreateCodeProperty2(
// global::EnvDTE.CodeElements parameters = property.Parameters; "class MyClass {\r\n" +
// CodeParameter parameter = parameters.FirstCodeParameterOrDefault(); " public int MyProperty { set { } }\r\n" +
// "}");
// Assert.AreEqual(1, parameters.Count);
// Assert.AreEqual("item", parameter.Name); global::EnvDTE.vsCMPropertyKind kind = property.ReadWrite;
// }
// Assert.AreEqual(global::EnvDTE.vsCMPropertyKind.vsCMPropertyKindWriteOnly, kind);
// [Test] }
// public void Getter_PublicGetter_ReturnsPublicGetterCodeFunction()
// { [Test]
// helper.CreatePublicProperty("MyProperty"); public void Parameters_PropertyIsIndexerWithOneParameter_ReturnsOneParameter()
// helper.HasGetterOnly(); {
// helper.GetterModifierIsNone(); CreateCodeProperty2(
// CreateCodeProperty2(); "class MyClass {\r\n" +
// " public int this[int item] { get { return 0; } }\r\n" +
// global::EnvDTE.CodeFunction getter = property.Getter; "}");
// global::EnvDTE.vsCMAccess access = getter.Access;
// global::EnvDTE.CodeElements parameters = property.Parameters;
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access);
// } CodeParameter parameter = parameters.FirstCodeParameterOrDefault();
// Assert.AreEqual(1, parameters.Count);
// [Test] Assert.AreEqual("item", parameter.Name);
// public void Getter_PrivateGetter_ReturnsPrivateGetterCodeFunction() }
// {
// helper.CreatePrivateProperty("MyProperty"); [Test]
// helper.HasGetterOnly(); public void Getter_PublicGetter_ReturnsPublicGetterCodeFunction()
// helper.GetterModifierIsNone(); {
// CreateCodeProperty2(); CreateCodeProperty2(
// "class MyClass {\r\n" +
// global::EnvDTE.CodeFunction getter = property.Getter; " public int MyProperty { get { return 0; } }\r\n" +
// global::EnvDTE.vsCMAccess access = getter.Access; "}");
//
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); global::EnvDTE.CodeFunction getter = property.Getter;
// } global::EnvDTE.vsCMAccess access = getter.Access;
//
// [Test] Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access);
// public void Getter_NoGetter_ReturnsNull() }
// {
// helper.CreatePublicProperty("MyProperty"); [Test]
// CreateCodeProperty2(); public void Getter_PrivateGetter_ReturnsPrivateGetterCodeFunction()
// {
// global::EnvDTE.CodeFunction getter = property.Getter; CreateCodeProperty2(
// "class MyClass {\r\n" +
// Assert.IsNull(getter); " private int MyProperty { get { return 0; } }\r\n" +
// } "}");
//
// [Test] global::EnvDTE.CodeFunction getter = property.Getter;
// public void Getter_PublicPropertyButPrivateGetter_ReturnsPrivateGetterCodeFunction() global::EnvDTE.vsCMAccess access = getter.Access;
// {
// helper.CreatePublicProperty("MyProperty"); Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
// helper.HasGetterAndSetter(); }
// helper.GetterModifierIsPrivate();
// CreateCodeProperty2(); [Test]
// public void Getter_NoGetter_ReturnsNull()
// global::EnvDTE.CodeFunction getter = property.Getter; {
// global::EnvDTE.vsCMAccess access = getter.Access; CreateCodeProperty2(
// "class MyClass {\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); " public int MyProperty { set { } }\r\n" +
// } "}");
//
// [Test] global::EnvDTE.CodeFunction getter = property.Getter;
// public void Setter_PublicSetter_ReturnsPublicSetterCodeFunction()
// { Assert.IsNull(getter);
// helper.CreatePublicProperty("MyProperty"); }
// helper.HasSetterOnly();
// helper.SetterModifierIsNone(); [Test]
// CreateCodeProperty2(); public void Getter_PublicPropertyButPrivateGetter_ReturnsPrivateGetterCodeFunction()
// {
// global::EnvDTE.CodeFunction setter = property.Setter; CreateCodeProperty2(
// global::EnvDTE.vsCMAccess access = setter.Access; "class MyClass {\r\n" +
// " public int MyProperty { private get; public set; }\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access); "}");
// }
// global::EnvDTE.CodeFunction getter = property.Getter;
// [Test] global::EnvDTE.vsCMAccess access = getter.Access;
// public void Setter_PrivateSetter_ReturnsPrivateSetterCodeFunction()
// { Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
// helper.CreatePrivateProperty("MyProperty"); }
// helper.HasSetterOnly();
// helper.SetterModifierIsNone(); [Test]
// CreateCodeProperty2(); public void Setter_PublicSetter_ReturnsPublicSetterCodeFunction()
// {
// global::EnvDTE.CodeFunction setter = property.Setter; CreateCodeProperty2(
// global::EnvDTE.vsCMAccess access = setter.Access; "class MyClass {\r\n" +
// " public int MyProperty { set { } }\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); "}");
// }
// global::EnvDTE.CodeFunction setter = property.Setter;
// [Test] global::EnvDTE.vsCMAccess access = setter.Access;
// public void Setter_NoSetter_ReturnsNull()
// { Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPublic, access);
// helper.CreatePublicProperty("MyProperty"); }
// CreateCodeProperty2();
// [Test]
// global::EnvDTE.CodeFunction setter = property.Setter; public void Setter_PrivateSetter_ReturnsPrivateSetterCodeFunction()
// {
// Assert.IsNull(setter); CreateCodeProperty2(
// } "class MyClass {\r\n" +
// " private int MyProperty { set { } }\r\n" +
// [Test] "}");
// public void Setter_PublicPropertyButPrivateSetter_ReturnsPrivateSetterCodeFunction()
// { global::EnvDTE.CodeFunction setter = property.Setter;
// helper.CreatePublicProperty("MyProperty"); global::EnvDTE.vsCMAccess access = setter.Access;
// helper.HasGetterAndSetter();
// helper.SetterModifierIsPrivate(); Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
// CreateCodeProperty2(); }
//
// global::EnvDTE.CodeFunction setter = property.Setter; [Test]
// global::EnvDTE.vsCMAccess access = setter.Access; public void Setter_NoSetter_ReturnsNull()
// {
// Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); CreateCodeProperty2(
// } "class MyClass {\r\n" +
// " public int MyProperty { get { return 0; } }\r\n" +
// [Test] "}");
// public void Type_PropertyTypeIsSystemString_ReturnsSystemString()
// { global::EnvDTE.CodeFunction setter = property.Setter;
// helper.CreatePublicProperty("MyProperty");
// helper.SetPropertyReturnType("System.String"); Assert.IsNull(setter);
// CreateCodeProperty2(); }
//
// global::EnvDTE.CodeTypeRef typeRef = property.Type; [Test]
// string fullName = typeRef.AsFullName; public void Setter_PublicPropertyButPrivateSetter_ReturnsPrivateSetterCodeFunction()
// {
// Assert.AreEqual("System.String", fullName); CreateCodeProperty2(
// } "class MyClass {\r\n" +
// " public int MyProperty { get; private set; }\r\n" +
// [Test] "}");
// public void Type_PropertyTypeIsSystemString_TypesParentIsProperty()
// { global::EnvDTE.CodeFunction setter = property.Setter;
// helper.CreatePublicProperty("MyProperty"); global::EnvDTE.vsCMAccess access = setter.Access;
// helper.SetPropertyReturnType("System.String");
// CreateCodeProperty2(); Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
// }
// global::EnvDTE.CodeTypeRef typeRef = property.Type;
// global::EnvDTE.CodeElement parent = typeRef.Parent; [Test]
// public void Type_PropertyTypeIsSystemString_ReturnsSystemString()
// Assert.AreEqual(property, parent); {
// } CreateCodeProperty2(
// "using System;\r\n" +
// [Test] "class MyClass {\r\n" +
// public void Type_PropertyTypeIsSystemString_TypeRefTypeInfoLocationIsExternal() " public string MyProperty { get; set; }\r\n" +
// { "}");
// helper.CreatePublicProperty("MyProperty");
// helper.SetPropertyReturnType("System.String"); global::EnvDTE.CodeTypeRef typeRef = property.Type;
// helper.CreateProjectForProjectContent(); string fullName = typeRef.AsFullName;
// var classHelper = new ClassHelper();
// classHelper.CreateClass("System.String"); Assert.AreEqual("System.String", fullName);
// classHelper.SetProjectForProjectContent(null); }
// helper.ReturnTypeHelper.AddUnderlyingClass(classHelper.Class);
// CreateCodeProperty2(); [Test]
// public void Type_PropertyTypeIsSystemString_TypesParentIsProperty()
// global::EnvDTE.CodeTypeRef typeRef = property.Type; {
// global::EnvDTE.vsCMInfoLocation location = typeRef.CodeType.InfoLocation; CreateCodeProperty2(
// "using System;\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal, location); "class MyClass {\r\n" +
// } " public string MyProperty { get; set; }\r\n" +
// "}");
// [Test]
// public void Type_PropertyTypeExistsInProject_TypeRefTypeInfoLocationIsProject() global::EnvDTE.CodeTypeRef typeRef = property.Type;
// { global::EnvDTE.CodeElement parent = typeRef.Parent;
// helper.CreatePublicProperty("MyProperty");
// helper.SetPropertyReturnType("MyType"); Assert.AreEqual(property, parent);
// helper.CreateProjectForProjectContent(); }
// var classHelper = new ClassHelper();
// classHelper.CreateClass("MyType"); [Test]
// classHelper.SetProjectForProjectContent(helper.Project); public void Type_PropertyTypeIsSystemString_TypeRefTypeInfoLocationIsExternal()
// helper.ReturnTypeHelper.AddUnderlyingClass(classHelper.Class); {
// CreateCodeProperty2(); CreateCodeProperty2(
// "using System;\r\n" +
// global::EnvDTE.CodeTypeRef typeRef = property.Type; "class MyClass {\r\n" +
// global::EnvDTE.vsCMInfoLocation location = typeRef.CodeType.InfoLocation; " public string MyProperty { get; set; }\r\n" +
// "}");
// Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationProject, location);
// } global::EnvDTE.CodeTypeRef typeRef = property.Type;
// global::EnvDTE.vsCMInfoLocation location = typeRef.CodeType.InfoLocation;
// [Test]
// public void Kind_PublicProperty_ReturnsProperty() Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal, location);
// { }
// helper.CreatePublicProperty("MyProperty");
// [Test]
// global::EnvDTE.vsCMElement kind = property.Kind; public void Type_PropertyTypeExistsInProject_TypeRefTypeInfoLocationIsProject()
// {
// Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementProperty, kind); CreateCodeProperty2(
// } "using System;\r\n" +
// } "public class MyClass {\r\n" +
//} " public MyType MyProperty { get; set; }\r\n" +
"}\r\n" +
"public class MyType {}");
global::EnvDTE.CodeTypeRef typeRef = property.Type;
global::EnvDTE.vsCMInfoLocation location = typeRef.CodeType.InfoLocation;
Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationProject, location);
}
[Test]
public void Kind_PublicProperty_ReturnsProperty()
{
CreateCodeProperty2(
"class MyClass {\r\n" +
" public int MyProperty { get; set; }\r\n" +
"}");
global::EnvDTE.vsCMElement kind = property.Kind;
Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementProperty, kind);
}
}
}

67
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/AttributeHelper.cs
Unescape View File

@ -1,67 +0,0 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System;
//using System.Collections.Generic;
//using ICSharpCode.SharpDevelop.Dom;
//using Rhino.Mocks;
//
//namespace PackageManagement.Tests.Helpers
//{
// public class AttributeHelper
// {
// public IAttribute Attribute;
// public IReturnType AttributeType;
// public List<object> PositionalArguments = new List<object>();
// public Dictionary<string, object> NamedArguments = new Dictionary<string, object>();
//
// public void CreateAttribute(string fullName)
// {
// CreateAttribute(fullName, fullName);
// }
//
// public void CreateAttribute(string fullName, string shortName)
// {
// var returnTypeHelper = new ReturnTypeHelper();
// returnTypeHelper.CreateReturnType(fullName);
// returnTypeHelper.AddShortName(shortName);
// AttributeType = returnTypeHelper.ReturnType;
//
// Attribute = MockRepository.GenerateStub<IAttribute>();
// Attribute.Stub(a => a.AttributeType).Return(AttributeType);
// Attribute.Stub(a => a.PositionalArguments).Return(PositionalArguments);
// Attribute.Stub(a => a.NamedArguments).Return(NamedArguments);
// }
//
// public void AddPositionalArguments(params object[] args)
// {
// PositionalArguments.AddRange(args);
// }
//
// public void AddNamedArgument(string name, object value)
// {
// NamedArguments.Add(name, value);
// }
//
// public void AddAttributeToClass(IClass c)
// {
// var attributes = new List<IAttribute>();
// attributes.Add(Attribute);
// c.Stub(item => item.Attributes).Return(attributes);
// }
//
// public void AddAttributeToMethod(IMethod method)
// {
// var attributes = new List<IAttribute>();
// attributes.Add(Attribute);
// method.Stub(m => m.Attributes).Return(attributes);
// }
//
// public void AddAttributeToParameter(IParameter parameter)
// {
// var attributes = new List<IAttribute>();
// attributes.Add(Attribute);
// parameter.Stub(p => p.Attributes).Return(attributes);
// }
// }
//}

228
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ClassHelper.cs
Unescape View File

@ -1,228 +0,0 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using ICSharpCode.SharpDevelop.Dom;
//using Rhino.Mocks;
//
//namespace PackageManagement.Tests.Helpers
//{
// public class ClassHelper
// {
// public IClass Class;
// public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
// public CompilationUnitHelper CompilationUnitHelper = new CompilationUnitHelper();
//
// List<IMethod> methods = new List<IMethod>();
// List<IProperty> properties = new List<IProperty>();
// List<IField> fields = new List<IField>();
//
// public void CreateClass(string name)
// {
// Class = ProjectContentHelper.AddClassToProjectContent(name);
// InitializeClassCommon();
// }
//
// void InitializeClassCommon()
// {
// Class.Stub(c => c.Methods).Return(methods);
// Class.Stub(c => c.Properties).Return(properties);
// Class.Stub(c => c.Fields).Return(fields);
// Class.Stub(c => c.CompilationUnit).Return(CompilationUnitHelper.CompilationUnit);
// }
//
// public void AddAttributeToClass(string attributeTypeName)
// {
// var attributeHelper = new AttributeHelper();
// attributeHelper.CreateAttribute(attributeTypeName);
// attributeHelper.AddAttributeToClass(Class);
// }
//
// public void CreatePublicClass(string name)
// {
// Class = ProjectContentHelper.AddPublicClassToProjectContent(name);
// InitializeClassCommon();
// }
//
// public void CreatePrivateClass(string name)
// {
// Class = ProjectContentHelper.AddPrivateClassToProjectContent(name);
// InitializeClassCommon();
// }
//
// public void AddInterfaceToClassBaseTypes(string interfaceFullName, string dotNetName)
// {
// IClass interfaceClass = ProjectContentHelper.AddInterfaceToProjectContent(interfaceFullName);
// AddClassToClassBaseTypes(interfaceClass, interfaceFullName, dotNetName);
// }
//
// public void AddClassToClassBaseTypes(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
// {
// IReturnType baseType = CreateBaseType(baseTypeClass, baseTypeFullName, baseTypeDotNetName);
// var baseTypes = new List<IReturnType>();
// baseTypes.Add(baseType);
//
// Class.Stub(c => c.BaseTypes).Return(baseTypes);
// }
//
// ReturnTypeHelper CreateBaseTypeHelper(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
// {
// var returnTypeHelper = new ReturnTypeHelper();
// returnTypeHelper.CreateReturnType(baseTypeFullName);
// returnTypeHelper.AddUnderlyingClass(baseTypeClass);
// returnTypeHelper.AddDotNetName(baseTypeDotNetName);
// return returnTypeHelper;
// }
//
// IReturnType CreateBaseType(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
// {
// return CreateBaseTypeHelper(baseTypeClass, baseTypeFullName, baseTypeDotNetName).ReturnType;
// }
//
// public void AddClassToClassBaseTypes(string fullName)
// {
// IClass baseTypeClass = ProjectContentHelper.AddClassToProjectContent(fullName);
// AddClassToClassBaseTypes(baseTypeClass, fullName, fullName);
// }
//
// public void AddBaseTypeToClass(string fullName)
// {
// IClass baseTypeClass = ProjectContentHelper.AddClassToProjectContent(fullName);
// IReturnType baseType = CreateBaseType(baseTypeClass, fullName, fullName);
//
// Class.Stub(c => c.BaseType).Return(baseType);
// }
//
// /// <summary>
// /// Name should include the class prefix (e.g. "Class1.MyMethod");
// /// </summary>
// public void AddMethodToClass(string fullyQualifiedName)
// {
// AddMethodToClass(fullyQualifiedName, DomRegion.Empty, DomRegion.Empty);
// }
//
// public void AddMethodToClass(string fullyQualifiedName, DomRegion region, DomRegion bodyRegion)
// {
// var helper = new MethodHelper();
// helper.ProjectContentHelper = ProjectContentHelper;
// helper.CreateMethod(fullyQualifiedName);
// helper.SetRegion(region);
// helper.SetBodyRegion(bodyRegion);
// helper.SetDeclaringType(Class);
// methods.Add(helper.Method);
// }
//
// /// <summary>
// /// Name should include the class prefix (e.g. "Class1.MyProperty");
// /// </summary>
// public void AddPropertyToClass(string fullyQualifiedName)
// {
// var helper = new PropertyHelper();
// helper.ProjectContentHelper = ProjectContentHelper;
// helper.CreateProperty(fullyQualifiedName);
//
// properties.Add(helper.Property);
// }
//
// /// <summary>
// /// Name should include the class prefix (e.g. "Class1.MyField");
// /// </summary>
// public void AddFieldToClass(string fullyQualifiedName)
// {
// AddFieldToClass(fullyQualifiedName, DomRegion.Empty);
// }
//
// public void AddFieldToClass(string fullyQualifiedName, DomRegion region)
// {
// var helper = new FieldHelper();
// helper.ProjectContentHelper = ProjectContentHelper;
// helper.CreateField(fullyQualifiedName);
// helper.SetRegion(region);
//
// fields.Add(helper.Field);
// }
//
// public void AddClassNamespace(string name)
// {
// Class.Stub(c => c.Namespace).Return(name);
// }
//
// public void SetClassRegion(DomRegion classRegion)
// {
// Class.Stub(c => c.Region).Return(classRegion);
// }
//
// public void SetClassFileName(string fileName)
// {
// CompilationUnitHelper.SetFileName(fileName);
// }
//
// public void SetClassType(ClassType type)
// {
// Class.Stub(c => c.ClassType).Return(type);
// }
//
// public void SetProjectForProjectContent(object project)
// {
// ProjectContentHelper.SetProjectForProjectContent(project);
// }
//
// public void MakeClassAbstract()
// {
// Class.Stub(c => c.IsAbstract).Return(true);
// }
//
// public void MakeClassPartial()
// {
// Class.Stub(c => c.IsPartial).Return(true);
// }
//
// public void AddNamespaceUsingScopeToClass(string namespaceName)
// {
// var usingScopeHelper = new UsingScopeHelper();
// usingScopeHelper.SetNamespaceName(namespaceName);
//
// Class.Stub(c => c.UsingScope).Return(usingScopeHelper.UsingScope);
// }
//
// public void SetDotNetName(string className)
// {
// Class.Stub(c => c.DotNetName).Return(className);
// }
//
// /// <summary>
// /// Classes at the end of the array are at the top of the inheritance tree.
// /// </summary>
// public void AddClassInheritanceTreeClassesOnly(params string[] classNames)
// {
// List<IClass> classes = CreateClassInheritanceTree(classNames);
// Class.Stub(c => c.ClassInheritanceTreeClassesOnly).Return(classes);
// }
//
// List<IClass> CreateClassInheritanceTree(string[] classNames)
// {
// return classNames
// .Select(name => CreateClassHelperWithPublicClass(name).Class)
// .ToList();
// }
//
// ClassHelper CreateClassHelperWithPublicClass(string name)
// {
// var classHelper = new ClassHelper();
// classHelper.CreatePublicClass(name);
// return classHelper;
// }
//
// public void SetRegionBeginLine(int line)
// {
// SetRegion(new DomRegion(line, 1));
// }
//
// public void SetRegion(DomRegion region)
// {
// Class.Stub(c => c.Region).Return(region);
// }
// }
//}

8
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/CodeElementsExtensions.cs
Unescape View File

@ -74,10 +74,10 @@ namespace PackageManagement.Tests.Helpers
return codeElements.FirstOrDefault() as CodeAttribute2; return codeElements.FirstOrDefault() as CodeAttribute2;
} }
// public static CodeProperty2 FirstCodeProperty2OrDefault(this global::EnvDTE.CodeElements codeElements) public static CodeProperty2 FirstCodeProperty2OrDefault(this global::EnvDTE.CodeElements codeElements)
// { {
// return codeElements.FirstOrDefault() as CodeProperty2; return codeElements.FirstOrDefault() as CodeProperty2;
// } }
public static CodeVariable FirstCodeVariableOrDefault(this global::EnvDTE.CodeElements codeElements) public static CodeVariable FirstCodeVariableOrDefault(this global::EnvDTE.CodeElements codeElements)
{ {

128
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PropertyHelper.cs
Unescape View File

@ -1,128 +0,0 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System;
//using System.Collections.Generic;
//using ICSharpCode.NRefactory.TypeSystem;
//using ICSharpCode.SharpDevelop.Dom;
//using Rhino.Mocks;
//
//namespace PackageManagement.Tests.Helpers
//{
// public class PropertyHelper : MethodOrPropertyHelper
// {
// public IProperty Property;
// public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
// public ReturnTypeHelper ReturnTypeHelper = new ReturnTypeHelper();
//
// List<IAttribute> attributes = new List<IAttribute>();
//
// /// <summary>
// /// Property name should include class prefix (e.g. "Class1.MyProperty")
// /// </summary>
// public void CreateProperty(string fullyQualifiedName)
// {
// Property = MockRepository.GenerateMock<IProperty, IEntity>();
// Property.Stub(p => p.FullyQualifiedName).Return(fullyQualifiedName);
// Property.Stub(p => p.Attributes).Return(attributes);
// Property.Stub(p => p.Parameters).Return(parameters);
// Property.Stub(p => p.ProjectContent).Return(ProjectContentHelper.ProjectContent);
// }
//
// public void AddAttribute(string fullName, string shortName)
// {
// var attributeHelper = new AttributeHelper();
// attributeHelper.CreateAttribute(fullName, shortName);
// attributes.Add(attributeHelper.Attribute);
// }
//
// public void AddParentClass(string className)
// {
// IClass c = ProjectContentHelper.AddClassToProjectContent(className);
// Property.Stub(p => p.DeclaringType).Return(c);
// }
//
// public void CreatePublicProperty(string name)
// {
// CreateProperty(name);
// Property.Stub(p => p.IsPublic).Return(true);
// }
//
// public void CreatePrivateProperty(string name)
// {
// CreateProperty(name);
// Property.Stub(p => p.IsPublic).Return(false);
// Property.Stub(p => p.IsPrivate).Return(true);
// }
//
// public void HasGetterAndSetter()
// {
// HasGetter = true;
// HasSetter = true;
// }
//
// public bool HasSetter {
// set { Property.Stub(p => p.CanSet).Return(value); }
// }
//
// public bool HasGetter {
// set { Property.Stub(p => p.CanGet).Return(value); }
// }
//
// public void HasGetterOnly()
// {
// HasGetter = true;
// HasSetter = false;
// }
//
// public void HasSetterOnly()
// {
// HasGetter = false;
// HasSetter = true;
// }
//
// public void GetterModifierIsPrivate()
// {
// GetterModifier = ModifierEnum.Private;
// }
//
// ModifierEnum GetterModifier {
// set { Property.Stub(p => p.GetterModifiers).Return(value); }
// }
//
// public void GetterModifierIsNone()
// {
// GetterModifier = ModifierEnum.None;
// }
//
// public void SetterModifierIsPrivate()
// {
// SetterModifier = ModifierEnum.Private;
// }
//
// ModifierEnum SetterModifier {
// set { Property.Stub(p => p.SetterModifiers).Return(value); }
// }
//
// public void SetterModifierIsNone()
// {
// GetterModifier = ModifierEnum.None;
// }
//
// public void SetPropertyReturnType(string fullName)
// {
// ReturnTypeHelper.CreateReturnType(fullName);
// ReturnTypeHelper.AddDotNetName(fullName);
// Property.Stub(p => p.ReturnType).Return(ReturnTypeHelper.ReturnType);
// }
//
// public object Project {
// get { return ProjectContentHelper.ProjectContent.Project; }
// }
//
// public void CreateProjectForProjectContent()
// {
// ProjectContentHelper.SetProjectForProjectContent(ProjectHelper.CreateTestProject());
// }
// }
//}
Write Preview
Loading…
Cancel
Save