Inheritance: CodeTypeMember
		public SuggestedHandlerCompletionData (Project project, CodeMemberMethod methodInfo, IType codeBehindClass, IType codeBehindClassPart)
		{
			this.project = project;
			this.methodInfo = methodInfo;
			this.codeBehindClass = codeBehindClass;
			this.codeBehindClassPart = codeBehindClassPart;
		}
        public void SetTestFixtureSetup(CodeMemberMethod fixtureSetupMethod)
        {
            // xUnit uses IUseFixture<T> on the class

            fixtureSetupMethod.Attributes |= MemberAttributes.Static;

            _currentFixtureTypeDeclaration = new CodeTypeDeclaration("FixtureData");
            _currentTestTypeDeclaration.Members.Add(_currentFixtureTypeDeclaration);

            var fixtureDataType = 
                CodeDomHelper.CreateNestedTypeReference(_currentTestTypeDeclaration, _currentFixtureTypeDeclaration.Name);
            
            var useFixtureType = new CodeTypeReference(IUSEFIXTURE_INTERFACE, fixtureDataType);
            CodeDomHelper.SetTypeReferenceAsInterface(useFixtureType);

            _currentTestTypeDeclaration.BaseTypes.Add(useFixtureType);

            // public void SetFixture(T) { } // explicit interface implementation for generic interfaces does not work with codedom

            CodeMemberMethod setFixtureMethod = new CodeMemberMethod();
            setFixtureMethod.Attributes = MemberAttributes.Public;
            setFixtureMethod.Name = "SetFixture";
            setFixtureMethod.Parameters.Add(new CodeParameterDeclarationExpression(fixtureDataType, "fixtureData"));
            setFixtureMethod.ImplementationTypes.Add(useFixtureType);
            _currentTestTypeDeclaration.Members.Add(setFixtureMethod);

            // public <_currentFixtureTypeDeclaration>() { <fixtureSetupMethod>(); }
            CodeConstructor ctorMethod = new CodeConstructor();
            ctorMethod.Attributes = MemberAttributes.Public;
            _currentFixtureTypeDeclaration.Members.Add(ctorMethod);
            ctorMethod.Statements.Add(
                new CodeMethodInvokeExpression(
                    new CodeTypeReferenceExpression(new CodeTypeReference(_currentTestTypeDeclaration.Name)),
                    fixtureSetupMethod.Name));
        }
 private void AddCustomAttributesToMethod(CodeMemberMethod dbMethod)
 {
     if (base.methodSource.EnableWebMethods)
     {
         CodeAttributeDeclaration declaration = new CodeAttributeDeclaration("System.Web.Services.WebMethod");
         declaration.Arguments.Add(new CodeAttributeArgument("Description", CodeGenHelper.Str(base.methodSource.WebMethodDescription)));
         dbMethod.CustomAttributes.Add(declaration);
     }
     DataObjectMethodType select = DataObjectMethodType.Select;
     if (base.methodSource.CommandOperation == CommandOperation.Update)
     {
         select = DataObjectMethodType.Update;
     }
     else if (base.methodSource.CommandOperation == CommandOperation.Delete)
     {
         select = DataObjectMethodType.Delete;
     }
     else if (base.methodSource.CommandOperation == CommandOperation.Insert)
     {
         select = DataObjectMethodType.Insert;
     }
     if (select != DataObjectMethodType.Select)
     {
         dbMethod.CustomAttributes.Add(new CodeAttributeDeclaration(CodeGenHelper.GlobalType(typeof(DataObjectMethodAttribute)), new CodeAttributeArgument[] { new CodeAttributeArgument(CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(DataObjectMethodType)), select.ToString())), new CodeAttributeArgument(CodeGenHelper.Primitive(false)) }));
     }
 }
 private void AddParametersToMethod(CodeMemberMethod dbMethod)
 {
     CodeParameterDeclarationExpression expression = null;
     if (base.activeCommand.Parameters != null)
     {
         DesignConnection connection = (DesignConnection) base.methodSource.Connection;
         if (connection == null)
         {
             throw new InternalException("Connection for query '" + base.methodSource.Name + "' is null.");
         }
         string parameterPrefix = connection.ParameterPrefix;
         foreach (DesignParameter parameter in base.activeCommand.Parameters)
         {
             if (parameter.Direction != ParameterDirection.ReturnValue)
             {
                 Type parameterUrtType = base.GetParameterUrtType(parameter);
                 string name = base.nameHandler.AddParameterNameToList(parameter.ParameterName, parameterPrefix);
                 CodeTypeReference type = null;
                 if (parameter.AllowDbNull && parameterUrtType.IsValueType)
                 {
                     type = CodeGenHelper.NullableType(parameterUrtType);
                 }
                 else
                 {
                     type = CodeGenHelper.Type(parameterUrtType);
                 }
                 expression = CodeGenHelper.ParameterDecl(type, name);
                 expression.Direction = CodeGenHelper.ParameterDirectionToFieldDirection(parameter.Direction);
                 dbMethod.Parameters.Add(expression);
             }
         }
     }
 }
        /// <summary>
        /// Generates control fields
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="classType">Type of the class.</param>
        /// <param name="method">The initialize method.</param>
        /// <param name="generateField">if set to <c>true</c> [generate field].</param>
        /// <returns></returns>
        public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
        {
            CodeExpression fieldReference = new CodeThisReferenceExpression();

            CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.BackgroundProperty);
            CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.BorderBrushProperty);
            CodeComHelper.GenerateThicknessField(method, fieldReference, source, Control.BorderThicknessProperty);
            CodeComHelper.GenerateThicknessField(method, fieldReference, source, Control.PaddingProperty);
            CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.ForegroundProperty);
            CodeComHelper.GenerateField<bool>(method, fieldReference, source, UIRoot.IsTabNavigationEnabledProperty);
            CodeComHelper.GenerateColorField(method, fieldReference, source, UIRoot.MessageBoxOverlayProperty);

            CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, FrameworkElement.StyleProperty);

            Control control = source as Control;
            if (!CodeComHelper.IsDefaultValue(source, Control.FontFamilyProperty) ||
                !CodeComHelper.IsDefaultValue(source, Control.FontSizeProperty) ||
                !CodeComHelper.IsDefaultValue(source, Control.FontStyleProperty) ||
                !CodeComHelper.IsDefaultValue(source, Control.FontWeightProperty))
            {
                FontGenerator.Instance.AddFont(control.FontFamily, control.FontSize, control.FontStyle, control.FontWeight, method);
            }

            CodeComHelper.GenerateFontFamilyField(method, fieldReference, source, Control.FontFamilyProperty);
            CodeComHelper.GenerateFieldDoubleToFloat(method, fieldReference, source, Control.FontSizeProperty);
            CodeComHelper.GenerateFontStyleField(method, fieldReference, source, Control.FontStyleProperty, Control.FontWeightProperty);

            return fieldReference;
        }
        /// <summary>
        /// Generates code for value
        /// </summary>
        /// <param name="parentClass">The parent class.</param>
        /// <param name="method">The method.</param>
        /// <param name="value">The value.</param>
        /// <param name="baseName">Name of the base.</param>
        /// <param name="dictionary">The dictionary.</param>
        /// <returns></returns>
        public CodeExpression Generate(CodeTypeDeclaration parentClass, CodeMemberMethod method, object value, string baseName, ResourceDictionary dictionary = null)
        {
            string bitmapVarName = baseName + "_bm";

            BitmapImage bitmap = value as BitmapImage;
            return CodeComHelper.GenerateBitmapImageValue(method, bitmap.UriSource, bitmapVarName);
        }
		public SuggestedHandlerCompletionData (MonoDevelop.Projects.Project project, CodeMemberMethod methodInfo, INamedTypeSymbol codeBehindClass, Location codeBehindClassLocation)
		{
			this.project = project;
			this.methodInfo = methodInfo;
			this.codeBehindClass = codeBehindClass;
			this.codeBehindClassLocation = codeBehindClassLocation;
		}
		CodeMemberMethod CreateMethod()
		{
			CodeMemberMethod method = new CodeMemberMethod();
			
			// BeginInit method call.
			CodeExpressionStatement statement = new CodeExpressionStatement();
			CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
			statement.Expression = methodInvoke;
			
			CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression();
			methodRef.MethodName = "BeginInit";
			
			CodeCastExpression cast = new CodeCastExpression();
			cast.TargetType = new CodeTypeReference();
			cast.TargetType.BaseType = "System.ComponentModel.ISupportInitialize";
			
			CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression();
			fieldRef.FieldName = "pictureBox1";
			fieldRef.TargetObject = new CodeThisReferenceExpression();
			cast.Expression = fieldRef;

			methodRef.TargetObject = cast;
			methodInvoke.Method = methodRef;

			method.Statements.Add(statement);
			return method;
		}
 public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod)
 {
     if (!String.IsNullOrWhiteSpace(Inherits))
     {
         derivedType.BaseTypes[0] = new CodeTypeReference(Inherits);
     }
 }
 private void AddCustomAttributesToMethod(CodeMemberMethod dbMethod)
 {
     DataObjectMethodType update = DataObjectMethodType.Update;
     if (base.methodSource.EnableWebMethods)
     {
         CodeAttributeDeclaration declaration = new CodeAttributeDeclaration("System.Web.Services.WebMethod");
         declaration.Arguments.Add(new CodeAttributeArgument("Description", CodeGenHelper.Str(base.methodSource.WebMethodDescription)));
         dbMethod.CustomAttributes.Add(declaration);
     }
     if (base.MethodType != MethodTypeEnum.GenericUpdate)
     {
         if (base.activeCommand == base.methodSource.DeleteCommand)
         {
             update = DataObjectMethodType.Delete;
         }
         else if (base.activeCommand == base.methodSource.InsertCommand)
         {
             update = DataObjectMethodType.Insert;
         }
         else if (base.activeCommand == base.methodSource.UpdateCommand)
         {
             update = DataObjectMethodType.Update;
         }
         dbMethod.CustomAttributes.Add(new CodeAttributeDeclaration(CodeGenHelper.GlobalType(typeof(DataObjectMethodAttribute)), new CodeAttributeArgument[] { new CodeAttributeArgument(CodeGenHelper.Field(CodeGenHelper.GlobalTypeExpr(typeof(DataObjectMethodType)), update.ToString())), new CodeAttributeArgument(CodeGenHelper.Primitive(true)) }));
     }
 }
        public override void SetTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string scenarioTitle)
        {
            base.SetTestMethod(generationContext, testMethod, scenarioTitle);

            if (generationContext.GenerateAsynchTests)
                SetupAsyncTest(testMethod);
        }
		public override void Visit(ActionTreeNode node)
		{
			CodeTypeDeclaration type = _typeStack.Peek();
			List<Type> actionArgumentTypes = new List<Type>();

			CodeMemberMethod method = new CodeMemberMethod();
			method.Name = node.Name;
			method.ReturnType = _source[typeof (IControllerActionReference)];
			method.Attributes = MemberAttributes.Public;
			method.CustomAttributes.Add(_source.DebuggerAttribute);
			List<CodeExpression> actionArguments = CreateActionArgumentsAndAddParameters(method, node, actionArgumentTypes);
			method.Statements.Add(
				new CodeMethodReturnStatement(CreateNewActionReference(node, actionArguments, actionArgumentTypes)));
			type.Members.Add(method);


			if (actionArguments.Count > 0 && _occurences[node.Name] == 1)
			{
				method = new CodeMemberMethod();
				method.Comments.Add(
					new CodeCommentStatement("Empty argument Action... Not sure if we want to pass MethodInformation to these..."));
				method.Name = node.Name;
				method.ReturnType = _source[typeof (IArgumentlessControllerActionReference)];
				method.Attributes = MemberAttributes.Public;
				method.CustomAttributes.Add(_source.DebuggerAttribute);
				method.Statements.Add(
					new CodeMethodReturnStatement(CreateNewActionReference(node, new List<CodeExpression>(), actionArgumentTypes)));
				type.Members.Add(method);
			}

			base.Visit(node);
		}
		private void RegisterClasspath(CodeMemberMethod composeMethod, XmlElement classpathElement, IList assemblies)
		{
			XmlNodeList children = classpathElement.ChildNodes;
			for (int i = 0; i < children.Count ; i++) 
			{
				if (children[i] is XmlElement) 
				{
					XmlElement childElement = (XmlElement) children[i];

					string fileName = childElement.GetAttribute(FILE);
					string urlSpec = childElement.GetAttribute(URL);

					UriBuilder url = null;
					if (urlSpec != null && urlSpec.Length > 0) 
					{
						url = new UriBuilder(urlSpec);
						assemblies.Add(url.ToString());
					} 
					else 
					{
						if (!File.Exists(fileName)) 
						{
							throw new IOException(Environment.CurrentDirectory + Path.DirectorySeparatorChar + fileName + " doesn't exist");
						}

						assemblies.Add(fileName);
					}
				}
			}
		}
Example #14
0
        public void BuildTest()
        {
            var typeMember = new CodeMemberMethod() { Name = "TypeMemberTest" };
            var propData = mocks.Stub<IBuilderData>();
            Expect.Call(buildcontext.TypeMember).Return(typeMember);
            //Expect.Call(buildcontext.GetBuilderData("Property")).Return(propData);

            // is not relevant ... just a devel-testing call to
            // "var userData = context.GetBuilderData<BuildParametersOfPropertyBuilder>(this);"
            Expect.Call(buildcontext.GetBuilderData<BuildParametersOfPropertyBuilder>(testObject)).Return(null);
            Expect.Call(buildcontext.GetBuilderData("Property")).Return(propData).Repeat.Any();
            var testClass = new CodeTypeDeclaration("TheClass");
            Expect.Call(buildcontext.TestClassDeclaration).Return(testClass).Repeat.Any();
            //Expect.Call(buildcontext.IsProperty).Return(true);
            mocks.ReplayAll();

            testObject.Build(this.buildcontext);

            // Todo: check if only the ending "Test" gets replaced.
            var expected = "TypeMemberNormalBehavior";
            var actual = typeMember.Name;
            Assert.AreEqual(expected, actual);

            mocks.VerifyAll();
        }
Example #15
0
 public override void ProcessGeneratedCode(
     CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType,
     CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod)
 {
     ExampleDependencyInjectionLogic(buildMethod);
       base.ProcessGeneratedCode(codeCompileUnit, baseType, derivedType, buildMethod, dataBindingMethod);
 }
 internal void AddMethods(CodeTypeDeclaration dataSourceClass)
 {
     this.AddSchemaSerializationModeMembers(dataSourceClass);
     this.initExpressionsMethod = this.InitExpressionsMethod();
     dataSourceClass.Members.Add(this.PublicConstructor());
     dataSourceClass.Members.Add(this.DeserializingConstructor());
     dataSourceClass.Members.Add(this.InitializeDerivedDataSet());
     dataSourceClass.Members.Add(this.CloneMethod(this.initExpressionsMethod));
     dataSourceClass.Members.Add(this.ShouldSerializeTablesMethod());
     dataSourceClass.Members.Add(this.ShouldSerializeRelationsMethod());
     dataSourceClass.Members.Add(this.ReadXmlSerializableMethod());
     dataSourceClass.Members.Add(this.GetSchemaSerializableMethod());
     dataSourceClass.Members.Add(this.InitVarsParamLess());
     CodeMemberMethod initClassMethod = null;
     CodeMemberMethod initVarsMethod = null;
     this.InitClassAndInitVarsMethods(out initClassMethod, out initVarsMethod);
     dataSourceClass.Members.Add(initVarsMethod);
     dataSourceClass.Members.Add(initClassMethod);
     this.AddShouldSerializeSingleTableMethods(dataSourceClass);
     dataSourceClass.Members.Add(this.SchemaChangedMethod());
     dataSourceClass.Members.Add(this.GetTypedDataSetSchema());
     dataSourceClass.Members.Add(this.TablesProperty());
     dataSourceClass.Members.Add(this.RelationsProperty());
     if (this.initExpressionsMethod != null)
     {
         dataSourceClass.Members.Add(this.initExpressionsMethod);
     }
 }
Example #17
0
 public static void ExampleDependencyInjectionLogic(CodeMemberMethod buildMethod)
 {
     // Non file based controls are different than file based controls.
       // Non file based controls are instantiated with "new" inside of a method and returned.
       // They are declared in the first statement.
       CodeVariableDeclarationStatement declaration = (CodeVariableDeclarationStatement)buildMethod.Statements[0];
       // Use the type of the declaration to get the type of the control.
       Type type = Type.GetType(declaration.Type.BaseType);
       // Standard reflection to get all of the properties. You could also look for fields.
       PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
       foreach(PropertyInfo property in properties) {
     // See if the property has the specific attribute we care about.
     object[] injectDeps = property.GetCustomAttributes(typeof(InjectDepAttribute), true);
     if(injectDeps.Length == 1) {
       // Create the code dom to perform the injection.
       // In this example, set the property to the literal the attribute was given.
       CodeStatement setProperty = new CodeAssignStatement(
     new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(declaration.Name), property.Name),
     new CodePrimitiveExpression((injectDeps[0] as InjectDepAttribute).Name + " (the builder method this is set in is '" + buildMethod.Name + "')")
       );
       // Add the statement to the list of statements that make up the builder method.
       // The last statement is the return statement that returns the control.
       // So we insert out injection statement(s) right before it.
       buildMethod.Statements.Insert(buildMethod.Statements.Count - 1, setProperty);
     }
       }
 }
        private void BuildAddContentPlaceHolderNames(CodeMemberMethod method, string placeHolderID) {
            CodePropertyReferenceExpression propertyExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ContentPlaceHolders");
            CodeExpressionStatement stmt = new CodeExpressionStatement();
            stmt.Expression = new CodeMethodInvokeExpression(propertyExpr, "Add", new CodePrimitiveExpression(placeHolderID.ToLower(CultureInfo.InvariantCulture)));

            method.Statements.Add(stmt);
        }
Example #19
0
        static void GenerateWidgetCode(SteticCompilationUnit globalUnit, CodeNamespace globalNs, GenerationOptions options, List<SteticCompilationUnit> units, Gtk.Widget w, ArrayList warnings)
        {
            // Generate the build method

            CodeTypeDeclaration type = CreatePartialClass (globalUnit, units, options, w.Name);
            CodeMemberMethod met = new CodeMemberMethod ();
            met.Name = "Build";
            type.Members.Add (met);
            met.ReturnType = new CodeTypeReference (typeof(void));
            met.Attributes = MemberAttributes.Family;

            if (options.GenerateEmptyBuildMethod) {
                GenerateWrapperFields (type, Wrapper.Widget.Lookup (w));
                return;
            }

            met.Statements.Add (
                    new CodeMethodInvokeExpression (
                        new CodeTypeReferenceExpression (globalNs.Name + ".Gui"),
                        "Initialize",
                        new CodeThisReferenceExpression ()
                    )
            );

            Stetic.Wrapper.Widget wwidget = Stetic.Wrapper.Widget.Lookup (w);
            if (wwidget.GeneratePublic)
                type.TypeAttributes = TypeAttributes.Public;
            else
                type.TypeAttributes = TypeAttributes.NotPublic;

            Stetic.WidgetMap map = Stetic.CodeGenerator.GenerateCreationCode (globalNs, type, w, new CodeThisReferenceExpression (), met.Statements, options, warnings);
            CodeGenerator.BindSignalHandlers (new CodeThisReferenceExpression (), wwidget, map, met.Statements, options);
        }
        public void CanCreateDataTableAssignment()
        {
            CodeNamespace nsdecl = new CodeNamespace("My.Data");
            CodeTypeDeclaration cdecl = new CodeTypeDeclaration("ResultSet");
            CodeMemberMethod method = new CodeMemberMethod();
            method.Name = "GetData";
            method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            method.ReturnType = new CodeTypeReference("System.Data.DataTable");
            method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
            method.Statements.Add(new CodeVariableDeclarationStatement(
                typeof(DataTable),
                "result",
                new CodeObjectCreateExpression(typeof(DataTable))));
            cdecl.Members.Add(method);
            method.Statements.Add(
                new CodeVariableDeclarationStatement(
                    typeof(DataColumnCollection),
                    "columns",
                    new CodePropertyReferenceExpression(
                        new CodeVariableReferenceExpression("result"),
                        "Columns")));
            method.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("columns"), "Add", new CodeTypeOfExpression(typeof(string)), new CodeSnippetExpression("name")));

            nsdecl.Types.Add(cdecl);
            CSharpCodeProvider provider = new CSharpCodeProvider();
            provider.GenerateCodeFromNamespace(nsdecl, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
        }
Example #21
0
        public override void GenerateMappingCode(CodeGenerationContext ctx, CodeMemberMethod method)
        {
            if (!String.IsNullOrEmpty(To))
                MappedProperty = TypeReflector.GetProperty(ctx.MappedObjectType, To);

            if (MappedProperty != null)
            {
                if (MapNotBoolProperty)
                {
                    // type value = bitReader.ReadBits(length);
                    method.Statements.Add(new CodeVariableDeclarationStatement(MappedValueType, "value",
                        new CodeMethodInvokeExpression(ctx.DataReader, "ReadBits", new CodePrimitiveExpression(Length))));
                }
                else
                {
                    method.Statements.Add(
                        new CodeVariableDeclarationStatement(MappedValueType, "value",
                            new CodeBinaryOperatorExpression(
                                new CodeMethodInvokeExpression(ctx.DataReader, "ReadBits", new CodePrimitiveExpression(Length)),
                                CodeBinaryOperatorType.GreaterThan, new CodePrimitiveExpression(0))));
                }

                // add operations code
                CodeVariableReferenceExpression value = new CodeVariableReferenceExpression("value");
                foreach (IOperation op in Operations)
                    method.Statements.AddRange(op.BuildOperation(ctx, this, value));

                method.Statements.AddRange(GenerateSetMappedPropertyCode(ctx.MappedObject, value));
            }
            else
            {   // just read
                method.Statements.Add(
                    new CodeMethodInvokeExpression(ctx.DataReader, "ReadBits", new CodePrimitiveExpression(Length)));
            }
        }
		public override void SetTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, string friendlyTestName)
		{
			base.SetTestMethod(generationContext, testMethod, friendlyTestName);
			if(generationContext.CustomData.ContainsKey("featureCategories"))
			{
				var featureCategories = (string[])generationContext.CustomData["featureCategories"];
				CodeDomHelper.AddAttributeForEachValue(testMethod, CATEGORY_ATTR, featureCategories);
			}

			if(generationContext.CustomData.ContainsKey(OWNER_TAG))
			{
				string ownerName = generationContext.CustomData[OWNER_TAG] as string;
				if(!String.IsNullOrEmpty(ownerName))
				{
					CodeDomHelper.AddAttribute(testMethod, OWNER_ATTR, ownerName);
				}
			}

			if(generationContext.CustomData.ContainsKey(WORKITEM_TAG))
			{
				IEnumerable<int> workitems = generationContext.CustomData[WORKITEM_TAG] as IEnumerable<int>;
				foreach(int workitem in workitems)
				{
					CodeDomHelper.AddAttribute(testMethod, WORKITEM_ATTR, workitem);
				}
			}
		}
        public void PostProcessGeneratedCodeAddsApplicationInstanceProperty() {
            const string expectedPropertyCode = @"
protected Foo.Bar ApplicationInstance {
    get {
        return ((Foo.Bar)(Context.ApplicationInstance));
    }
}
";

            // Arrange
            CodeCompileUnit generatedCode = new CodeCompileUnit();
            CodeNamespace generatedNamespace = new CodeNamespace();
            CodeTypeDeclaration generatedClass = new CodeTypeDeclaration();
            CodeMemberMethod executeMethod = new CodeMemberMethod();
            WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml") {
                GlobalAsaxTypeName = "Foo.Bar"
            };

            // Act
            host.PostProcessGeneratedCode(generatedCode, generatedNamespace, generatedClass, executeMethod);

            // Assert
            CodeMemberProperty property = generatedClass.Members[0] as CodeMemberProperty;
            Assert.IsNotNull(property);

            CSharpCodeProvider provider = new CSharpCodeProvider();
            StringBuilder builder = new StringBuilder();
            using(StringWriter writer = new StringWriter(builder)) {
                provider.GenerateCodeFromMember(property, writer, new CodeDom.Compiler.CodeGeneratorOptions());
            }

            Assert.AreEqual(expectedPropertyCode, builder.ToString());
        }
Example #24
0
        static CodeNamespace BuildProgram()
        {
            // namespaceの作成
            var ns = new CodeNamespace("MetaWorld");
            // import編成
            var systemImport = new CodeNamespaceImport("System");
            // class作成
            var programClass = new CodeTypeDeclaration("Program");

            // mainメソッドの定義
            var methodMain = new CodeMemberMethod()
            {
                Attributes = MemberAttributes.Static,
                Name = "Main"
            };
            methodMain.Statements.Add(
                new CodeMethodInvokeExpression(
                    new CodeSnippetExpression("Console"),
                    "WriteLine",
                    new CodePrimitiveExpression("Hello World")
                    )
                );

            // コード構造の編成
            programClass.Members.Add(methodMain);
            ns.Imports.Add(systemImport);
            ns.Types.Add(programClass);
            return ns;
        }
Example #25
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CodeLocalVariableBinder"/> class
 /// with a local variable declaration.
 /// </summary>
 /// <param name="method">The method to add a <see cref="CodeTypeReference"/> to.</param>
 /// <param name="variableDeclaration">The variable declaration to add.</param>
 internal CodeLocalVariableBinder(CodeMemberMethod method, CodeVariableDeclarationStatement variableDeclaration)
 {
     Guard.NotNull(() => method, method);
     Guard.NotNull(() => variableDeclaration, variableDeclaration);
     this.method = method;
     this.variableDeclaration = variableDeclaration;
 }
Example #26
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CodeLocalVariableBinder"/> class
 /// with a reference to a variable.
 /// </summary>
 /// <param name="method">The method to add a <see cref="CodeTypeReference"/> to.</param>
 /// <param name="reference">The reference to a local variable.</param>
 internal CodeLocalVariableBinder(CodeMemberMethod method, CodeVariableReferenceExpression reference)
 {
     Guard.NotNull(() => method, method);
     Guard.NotNull(() => reference, reference);
     this.method = method;
     this.reference = reference;
 }
 protected override CodeMemberMethod GetInitializeMethod(IDesignerSerializationManager manager, CodeTypeDeclaration typeDecl, object value)
 {
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     if (typeDecl == null)
     {
         throw new ArgumentNullException("typeDecl");
     }
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     CodeMemberMethod method = typeDecl.UserData[_initMethodKey] as CodeMemberMethod;
     if (method == null)
     {
         method = new CodeMemberMethod {
             Name = "InitializeComponent",
             Attributes = MemberAttributes.Private
         };
         typeDecl.UserData[_initMethodKey] = method;
         CodeConstructor constructor = new CodeConstructor {
             Attributes = MemberAttributes.Public
         };
         constructor.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "InitializeComponent", new CodeExpression[0]));
         typeDecl.Members.Add(constructor);
     }
     return method;
 }
Example #28
0
        protected override void WriteFunctionDefinition(CodeMemberMethod func) {
            Writer.Write("def ");
            Writer.Write(func.Name);
            Writer.Write("(");
            for (int i = 0; i < func.Parameters.Count; ++i) {
                if (i != 0) {
                    Writer.Write(",");
                }
                Writer.Write(func.Parameters[i].Name);
            }
            Writer.Write("):\n");

            int baseIndent = _indents.Peek();

            _generatedIndent += 4;

            foreach (CodeStatement stmt in func.Statements) {
                WriteStatement(stmt);
            }

            _generatedIndent -= 4;

            while (_indents.Peek() > baseIndent) {
                _indents.Pop();
            }
        }
        /// <summary>
        /// Generates code
        /// </summary>
        /// <param name="source">The dependence object</param>
        /// <param name="classType">Type of the class.</param>
        /// <param name="initMethod">The initialize method.</param>
        /// <param name="generateField"></param>
        /// <returns></returns>
        public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
        {
            CodeExpression fieldReference = base.Generate(source, classType, initMethod, generateField);
            CodeComHelper.GenerateEnumField<Stretch>(initMethod, fieldReference, source, ImageButton.ImageStretchProperty);

            ImageButton imageButton = source as ImageButton;
            BitmapImage bitmap = imageButton.ImageNormal as BitmapImage;
            if (bitmap != null)
            {
                CodeComHelper.GenerateBitmapImageField(initMethod, fieldReference, source, bitmap.UriSource, imageButton.Name + "_normal_bm", ImageButton.ImageNormalProperty);
            }

            bitmap = imageButton.ImageDisabled as BitmapImage;
            if (bitmap != null)
            {
                CodeComHelper.GenerateBitmapImageField(initMethod, fieldReference, source, bitmap.UriSource, imageButton.Name + "_disabled_bm", ImageButton.ImageDisabledProperty);
            }

            bitmap = imageButton.ImageHover as BitmapImage;
            if (bitmap != null)
            {
                CodeComHelper.GenerateBitmapImageField(initMethod, fieldReference, source, bitmap.UriSource, imageButton.Name + "_hover_bm", ImageButton.ImageHoverProperty);
            }

            bitmap = imageButton.ImagePressed as BitmapImage;
            if (bitmap != null)
            {
                CodeComHelper.GenerateBitmapImageField(initMethod, fieldReference, source, bitmap.UriSource, imageButton.Name + "_pressed_bm", ImageButton.ImagePressedProperty);
            }

            return fieldReference;
        }
		public override void SetTestMethodCategories(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> scenarioCategories)
		{
			IEnumerable<string> tags = scenarioCategories.ToList();

			IEnumerable<string> ownerTags = tags.Where(t => t.StartsWith(OWNER_TAG, StringComparison.InvariantCultureIgnoreCase)).Select(t => t);
			if(ownerTags.Any())
			{
				string ownerName = ownerTags.Select(t => t.Substring(OWNER_TAG.Length).Trim('\"')).FirstOrDefault();
				if(!String.IsNullOrEmpty(ownerName))
				{
					CodeDomHelper.AddAttribute(testMethod, OWNER_ATTR, ownerName);
				}
			}

			IEnumerable<string> workitemTags = tags.Where(t => t.StartsWith(WORKITEM_TAG, StringComparison.InvariantCultureIgnoreCase)).Select(t => t);
			if(workitemTags.Any())
			{
				int temp;
				IEnumerable<string> workitemsAsStrings = workitemTags.Select(t => t.Substring(WORKITEM_TAG.Length).Trim('\"'));
				IEnumerable<int> workitems = workitemsAsStrings.Where(t => int.TryParse(t, out temp)).Select(t => int.Parse(t));
				foreach(int workitem in workitems)
				{
					CodeDomHelper.AddAttribute(testMethod, WORKITEM_ATTR, workitem);
				}
			}

			CodeDomHelper.AddAttributeForEachValue(testMethod, CATEGORY_ATTR, GetNonMSTestSpecificTags(tags));
		}
Example #31
0
        public async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(System.CodeDom.CodeMemberMethod Method, string valueName)
        {
            await EngineNS.Thread.AsyncDummyClass.DummyFunc();

            var param = CSParam as CreateObjectConstructionParams;

            // 生成创建的代码
            if (mVarDec == null || !Method.Statements.Contains(mVarDec))
            {
                //var valueName = GCode_GetValueName(null, context);
                if (mTemplateClassInstance != null)
                {
                    var type = mTemplateClassInstance.GetType();
                    foreach (var pro in mClassProperties)
                    {
                        var proInfo = type.GetProperty(pro.PropertyName);
                        if (proInfo == null)
                        {
                            continue;
                        }

                        var defProInfo = param.CreateType.GetProperty(pro.PropertyName);
                        var curValue   = proInfo.GetValue(mTemplateClassInstance);
                        var defValue   = defProInfo.GetValue(mDefaultValueObj);
                        if (object.Equals(curValue, defValue))
                        {
                            continue;
                        }
                        if (pro.PropertyType.FullName == typeof(EngineNS.RName).FullName)
                        {
                            var rname = curValue as EngineNS.RName;
                            if (rname == null)
                            {
                                Method.Statements.Insert(0, new CodeAssignStatement(new CodeVariableReferenceExpression(valueName + "." + pro.PropertyName), new CodePrimitiveExpression(null)));
                            }
                            else
                            {
                                Method.Statements.Insert(0, new CodeAssignStatement(new CodeVariableReferenceExpression(valueName + "." + pro.PropertyName),
                                                                                    new CodeSnippetExpression($"EngineNS.CEngine.Instance.FileManager.GetRName(\"{rname.Name}\", {EngineNS.Rtti.RttiHelper.GetAppTypeString(typeof(EngineNS.RName.enRNameType))}.{rname.RNameType.ToString()})")));
                            }
                        }
                        else if (pro.PropertyType.IsEnum)
                        {
                            Method.Statements.Insert(0, new CodeAssignStatement(new CodeVariableReferenceExpression(valueName + "." + pro.PropertyName), new CodeVariableReferenceExpression(EngineNS.Rtti.RttiHelper.GetAppTypeString(pro.PropertyType) + "." + curValue.ToString())));
                        }
                        else
                        {
                            Method.Statements.Insert(0, new CodeAssignStatement(new CodeVariableReferenceExpression(valueName + "." + pro.PropertyName), new CodePrimitiveExpression(curValue)));
                        }
                    }
                }

                mVarDec = new System.CodeDom.CodeVariableDeclarationStatement(param.CreateType, valueName, new CodeObjectCreateExpression(param.CreateType, new CodeExpression[0]));
                Method.Statements.Insert(0, mVarDec);
            }
        }
Example #32
0
        public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Class context)
        {
            if (!mCtrlValueInputHandle.HasLink)
            {
                return;
            }

            System.CodeDom.CodeMemberMethod initMethod = null;

            foreach (var member in codeClass.Members)
            {
                if (member.GetType() == typeof(CodeMemberMethod))
                {
                    var method = member as CodeMemberMethod;
                    if (method.Name == "Init")
                    {
                        initMethod = method;
                    }
                }
            }
            if (initMethod == null)
            {
                initMethod            = new CodeMemberMethod();
                initMethod.Name       = "Init";
                initMethod.Attributes = MemberAttributes.Override | MemberAttributes.Public;
                codeClass.Members.Add(initMethod);
            }

            var linkObj       = mCtrlValueInputHandle.GetLinkedObject(0, true);
            var linkElm       = mCtrlValueInputHandle.GetLinkedPinControl(0, true);
            var methodContext = new GenerateCodeContext_Method(context, initMethod);

            methodContext.InstanceAnimPoseReferenceExpression       = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "AnimationPoseProxy");
            methodContext.AnimAssetAnimPoseProxyReferenceExpression = methodContext.InstanceAnimPoseReferenceExpression;
            methodContext.AnimAssetTickHostReferenceExpression      = new CodeThisReferenceExpression();
            await linkObj.GCode_CodeDom_GenerateCode(codeClass, initMethod.Statements, linkElm, methodContext);

            var returnExpression = linkObj.GCode_CodeDom_GetSelfRefrence(mCtrlValueInputHandle, methodContext);


            CodeMethodInvokeExpression createCachedPose = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "GetCachedAnimPose"), new CodePrimitiveExpression("CachedPose_" + NodeName));
            //CodeVariableDeclarationStatement cachedPoseRef = new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(EngineNS.Graphics.Mesh.Animation.CGfxAnimationPose)), NodeName);
            //CodeAssignStatement cachedPoseAssign = new CodeAssignStatement();
            //cachedPoseAssign.Left = cachedPoseRef;
            //cachedPoseAssign.Right = createCachedPose;
            //initMethod.Statements.Add(cachedPoseAssign);

            CodeFieldReferenceExpression animPoseField  = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(returnExpression, "AnimationPoseProxy"), "Pose");
            CodeAssignStatement          animPoseAssign = new CodeAssignStatement();

            animPoseAssign.Left  = animPoseField;
            animPoseAssign.Right = new CodeFieldReferenceExpression(createCachedPose, "CachedAnimationPose");
            initMethod.Statements.Add(animPoseAssign);
        }
Example #33
0
 protected override void GenerateMethod(System.CodeDom.CodeMemberMethod e, System.CodeDom.CodeTypeDeclaration c)
 {
     if (e.ReturnType.BaseType == string_consts.void_type)
     {
         Output.Write("procedure ");
     }
     else
     {
         Output.Write("function ");
     }
     OutputMethodSignature(e.Attributes, e.ReturnType, e.Name, e.Parameters, false, false);
     GenerateBlock(e.Statements);
     Output.WriteLine(";");
 }
Example #34
0
        public void ConstructWithParametersBuildDataSetUpMethodTestObjectMemberFieldTestObjectNameTestObjectTypeTest()
        {
            this.buildData             = new NStub.CSharp.ObjectGeneration.BuildDataDictionary();
            this.setUpMethod           = new System.CodeDom.CodeMemberMethod();
            this.testObjectMemberField = new System.CodeDom.CodeMemberField();
            this.testObjectName        = "myTestObjectName";
            this.testObjectType        = typeof(object);
            this.testObject            = new TestObjectComposer(this.buildData, this.setUpMethod, this.testObjectMemberField, this.testObjectName, this.testObjectType);

            Assert.Throws <ArgumentNullException>(() => new TestObjectComposer(null, this.setUpMethod, this.testObjectMemberField, this.testObjectName, this.testObjectType));
            Assert.Throws <ArgumentNullException>(() => new TestObjectComposer(this.buildData, null, this.testObjectMemberField, this.testObjectName, this.testObjectType));
            Assert.Throws <ArgumentNullException>(() => new TestObjectComposer(this.buildData, this.setUpMethod, null, this.testObjectName, this.testObjectType));
            Assert.Throws <ArgumentNullException>(() => new TestObjectComposer(this.buildData, this.setUpMethod, this.testObjectMemberField, null, this.testObjectType));
            Assert.Throws <ArgumentException>(() => new TestObjectComposer(this.buildData, this.setUpMethod, this.testObjectMemberField, string.Empty, this.testObjectType));
            Assert.Throws <ArgumentNullException>(() => new TestObjectComposer(this.buildData, this.setUpMethod, this.testObjectMemberField, this.testObjectName, null));
        }
        public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Class context)
        {
            if (!mCtrlValueInputHandle.HasLink)
                return;
            System.CodeDom.CodeMemberMethod initMethod = null;

            foreach (var member in codeClass.Members)
            {
                if (member is CodeGenerateSystem.CodeDom.CodeMemberMethod)
                {
                    var method = member as CodeGenerateSystem.CodeDom.CodeMemberMethod;
                    if (method.Name == "Init")
                        initMethod = method;
                }
            }
            if (initMethod == null)
            {
                initMethod = new CodeGenerateSystem.CodeDom.CodeMemberMethod();
                initMethod.Name = "Init";
                initMethod.Attributes = MemberAttributes.Override | MemberAttributes.Public;
                codeClass.Members.Add(initMethod);
            }


            var linkObj = mCtrlValueInputHandle.GetLinkedObject(0, true);
            var linkElm = mCtrlValueInputHandle.GetLinkedPinControl(0, true);
            var methodContext = new GenerateCodeContext_Method(context, initMethod);

            await GenerateCachedPose(codeClass, initMethod.Statements, linkElm, methodContext);

            methodContext.InstanceAnimPoseReferenceExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "AnimationPoseProxy");
            methodContext.AnimAssetAnimPoseProxyReferenceExpression = methodContext.InstanceAnimPoseReferenceExpression;
            methodContext.AnimAssetTickHostReferenceExpression = new CodeThisReferenceExpression();
            await linkObj.GCode_CodeDom_GenerateCode(codeClass, initMethod.Statements, linkElm, methodContext);
            var returnExp = linkObj.GCode_CodeDom_GetSelfRefrence(mCtrlValueInputHandle, methodContext);
            if (returnExp != null)
            {
                CodeFieldReferenceExpression animPoseField = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(returnExp, "AnimationPoseProxy"),"Pose");
                CodeAssignStatement animPoseAssign = new CodeAssignStatement();
                animPoseAssign.Left = animPoseField;
                animPoseAssign.Right = new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "AnimationPoseProxy"),"Pose");
                initMethod.Statements.Add(animPoseAssign);
            }
        }
Example #36
0
 protected override void GenerateMethod(System.CodeDom.CodeMemberMethod e, System.CodeDom.CodeTypeDeclaration c)
 {
     if (e.Name == "InitializeComponent" && own_output || !own_output && e.Name != "InitializeComponent")
     {
         if (e.ReturnType.BaseType == string_consts.void_type)
         {
             Output.Write("procedure ");
         }
         else
         {
             Output.Write("function ");
         }
         OutputMethodSignature(e.Attributes, e.ReturnType, e.Name, e.Parameters, false, false);
         GenerateBlock(e.Statements);
         Output.WriteLine(";");
     }
     else if (!own_output && e.Name == "InitializeComponent")
     {
         Output.WriteLine(string.Format("{{$include {0}}}", UnitName + "." + c.Name + ".inc"));
     }
 }
        public override void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug)
        {
            IMathExpression mathExp = MathExp;

            if (mathExp != null)
            {
                CodeExpression ceCondition = null;
                if (Condition != null)
                {
                    ceCondition = Condition.ExportCode(methodToCompile);
                    if (ceCondition != null)
                    {
                        ceCondition = CompilerUtil.ConvertToBool(Condition.DataType, ceCondition);
                    }
                }
                CodeExpression ce = mathExp.ReturnCodeExpression(methodToCompile);
                if (ce != null)
                {
                    if (ceCondition == null)
                    {
                        statements.Add(new CodeMethodReturnStatement(ce));
                    }
                    else
                    {
                        CodeConditionStatement cd = new CodeConditionStatement();
                        cd.Condition = ceCondition;
                        cd.TrueStatements.Add(new CodeMethodReturnStatement(ce));
                        statements.Add(cd);
                    }
                }
            }
        }
 public void SetTestMethod(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle)
 {
     this.codeDomHelper.AddAttribute(testMethod, TEST_ATTR);
     this.codeDomHelper.AddAttribute(testMethod, DESCRIPTION_ATTR, scenarioTitle);
 }
 public void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, MathExp.IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug)
 {
 }
 public void SetTestMethodIgnore(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod)
 {
     this.codeDomHelper.AddAttribute(testMethod, IGNORE_ATTR);
 }
 public void SetRowTest(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle)
 {
     this.SetTestMethod(generationContext, testMethod, scenarioTitle);
 }
        public void SetRow(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, IEnumerable <string> arguments, IEnumerable <string> tags, bool isIgnored)
        {
            var args = arguments.Select(
                arg => new CodeAttributeArgument(new CodePrimitiveExpression(arg))).ToList();

            // addressing ReSharper bug: TestCase attribute with empty string[] param causes inconclusive result - https://github.com/techtalk/SpecFlow/issues/116
            var            exampleTagExpressionList = tags.Select(t => new CodePrimitiveExpression(t)).ToArray();
            CodeExpression exampleTagsExpression    = exampleTagExpressionList.Length == 0 ?
                                                      (CodeExpression) new CodePrimitiveExpression(null) :
                                                      new CodeArrayCreateExpression(typeof(string[]), exampleTagExpressionList);

            args.Add(new CodeAttributeArgument(exampleTagsExpression));

            if (isIgnored)
            {
                args.Add(new CodeAttributeArgument("Ignored", new CodePrimitiveExpression(true)));
            }

            var browsers = testMethod.UserData.Keys.OfType <string>()
                           .Where(key => key.StartsWith("Browser:"))
                           .Select(key => (string)testMethod.UserData[key]).ToArray();

            if (browsers.Any())
            {
                foreach (var codeAttributeDeclaration in testMethod.CustomAttributes.Cast <CodeAttributeDeclaration>().Where(attr => attr.Name == ROW_ATTR && attr.Arguments.Count == 3).ToList())
                {
                    testMethod.CustomAttributes.Remove(codeAttributeDeclaration);
                }

                foreach (var browser in browsers)
                {
                    var argsString = string.Concat(args.Take(args.Count - 1).Select(arg => string.Format("\"{0}\" ,", ((CodePrimitiveExpression)arg.Value).Value)));
                    argsString = argsString.TrimEnd(' ', ',');

                    var withBrowserArgs = new[] { new CodeAttributeArgument(new CodePrimitiveExpression(browser)) }
                    .Concat(args)
                    .Concat(new [] {
                        new CodeAttributeArgument("Category", new CodePrimitiveExpression(browser)),
                        new CodeAttributeArgument("TestName", new CodePrimitiveExpression(string.Format("{0} on {1} with: {2}", testMethod.Name, browser, argsString)))
                    })
                    .ToArray();

                    this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, withBrowserArgs);
                }
            }
            else
            {
                this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, args.ToArray());
            }
        }
        public void SetTestMethodCategories(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, IEnumerable <string> scenarioCategories)
        {
            this.codeDomHelper.AddAttributeForEachValue(testMethod, CATEGORY_ATTR, scenarioCategories.Where(cat => !cat.StartsWith("Browser:")));

            bool hasBrowser = false;

            foreach (var browser in scenarioCategories.Where(cat => cat.StartsWith("Browser:")).Select(cat => cat.Replace("Browser:", "")))
            {
                testMethod.UserData.Add("Browser:" + browser, browser);

                var withBrowserArgs = new[] { new CodeAttributeArgument(new CodePrimitiveExpression(browser)) }
                .Concat(new[] {
                    new CodeAttributeArgument("Category", new CodePrimitiveExpression(browser)),
                    new CodeAttributeArgument("TestName", new CodePrimitiveExpression(string.Format("{0} on {1}", testMethod.Name, browser)))
                })
                .ToArray();

                this.codeDomHelper.AddAttribute(testMethod, ROW_ATTR, withBrowserArgs);

                hasBrowser = true;
            }

            if (hasBrowser)
            {
                if (!scenarioSetupMethodsAdded)
                {
                    generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement("            if(this.driver != null)"));
                    generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement("                ScenarioContext.Current.Add(\"Driver\", this.driver);"));
                    generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement("            if(this.container != null)"));
                    generationContext.ScenarioInitializeMethod.Statements.Add(new CodeSnippetStatement("                ScenarioContext.Current.Add(\"Container\", this.container);"));
                    scenarioSetupMethodsAdded = true;
                }

                testMethod.Statements.Insert(0, new CodeSnippetStatement("            InitializeSelenium(browser);"));
                testMethod.Parameters.Insert(0, new System.CodeDom.CodeParameterDeclarationExpression("System.string", "browser"));
            }
        }
 public void SetTestMethodAsRow(TechTalk.SpecFlow.Generator.TestClassGenerationContext generationContext, System.CodeDom.CodeMemberMethod testMethod, string scenarioTitle, string exampleSetName, string variantName, IEnumerable <KeyValuePair <string, string> > arguments)
 {
 }