public void GetMethodInvokeExpressionStatementForTest(bool isCSharp)
        {
            string comments = this.TestContext.DataRow["comments"].ToString();

            string[] baseMethodNames = this.TestContext.DataRow["baseMethodNames"].ToString().Split(new char[] { ',' });
            string   paramDeclsArgs  = this.TestContext.DataRow["parameters"].ToString();

            NotificationMethodGenerator target = new NotificationMethodGenerator(CreateProxyGenerator(isCSharp));

            CodeParameterDeclarationExpressionCollection expressions = GetCodeParameterDeclaraionExpressions(paramDeclsArgs);

            CodeParameterDeclarationExpression[] parameters = new CodeParameterDeclarationExpression[expressions.Count];

            expressions.CopyTo(parameters, 0);

            foreach (string baseMethodName in baseMethodNames)
            {
                target.AddMethodFor(baseMethodName, expressions, comments);

                CodeExpressionStatement    actual           = target.GetMethodInvokeExpressionStatementFor(baseMethodName);
                CodeMethodInvokeExpression actualExpression = actual.Expression as CodeMethodInvokeExpression;

                Assert.AreEqual(actualExpression.Method.MethodName, "On" + baseMethodName);

                for (int idx = 0; idx < parameters.Length; idx++)
                {
                    string paramName = ((CodeArgumentReferenceExpression)actualExpression.Parameters[idx]).ParameterName;
                    Assert.AreEqual(paramName, parameters[idx].Name);
                }
            }
        }
        static CodeParameterDeclarationExpression[] _ToArray(CodeParameterDeclarationExpressionCollection refs)
        {
            var result = new CodeParameterDeclarationExpression[refs.Count];

            refs.CopyTo(result, 0);
            return(result);
        }
示例#3
0
        public void Constructor1_Deny_Unrestricted()
        {
            CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection(array);

            coll.CopyTo(array, 0);
            Assert.AreEqual(1, coll.Add(cpde), "Add");
            Assert.AreSame(cpde, coll[0], "this[int]");
            coll.AddRange(array);
            coll.AddRange(coll);
            Assert.IsTrue(coll.Contains(cpde), "Contains");
            Assert.AreEqual(0, coll.IndexOf(cpde), "IndexOf");
            coll.Insert(0, cpde);
            coll.Remove(cpde);
        }
示例#4
0
        // CodeParameterDeclarationExpressionCollection
        public void CodeParameterDeclarationExpressionCollectionExample()
        {
            //<Snippet1>
            //<Snippet2>
            // Creates an empty CodeParameterDeclarationExpressionCollection.
            CodeParameterDeclarationExpressionCollection collection = new CodeParameterDeclarationExpressionCollection();

            //</Snippet2>

            //<Snippet3>
            // Adds a CodeParameterDeclarationExpression to the collection.
            collection.Add(new CodeParameterDeclarationExpression(typeof(int), "testIntArgument"));
            //</Snippet3>

            //<Snippet4>
            // Adds an array of CodeParameterDeclarationExpression objects
            // to the collection.
            CodeParameterDeclarationExpression[] parameters = { new CodeParameterDeclarationExpression(typeof(int), "testIntArgument"), new CodeParameterDeclarationExpression(typeof(bool), "testBoolArgument") };
            collection.AddRange(parameters);

            // Adds a collection of CodeParameterDeclarationExpression objects
            // to the collection.
            CodeParameterDeclarationExpressionCollection parametersCollection = new CodeParameterDeclarationExpressionCollection();

            parametersCollection.Add(new CodeParameterDeclarationExpression(typeof(int), "testIntArgument"));
            parametersCollection.Add(new CodeParameterDeclarationExpression(typeof(bool), "testBoolArgument"));
            collection.AddRange(parametersCollection);
            //</Snippet4>

            //<Snippet5>
            // Tests for the presence of a CodeParameterDeclarationExpression
            // in the collection, and retrieves its index if it is found.
            CodeParameterDeclarationExpression testParameter = new CodeParameterDeclarationExpression(typeof(int), "testIntArgument");
            int itemIndex = -1;

            if (collection.Contains(testParameter))
            {
                itemIndex = collection.IndexOf(testParameter);
            }
            //</Snippet5>

            //<Snippet6>
            // Copies the contents of the collection beginning at index 0 to the specified CodeParameterDeclarationExpression array.
            // 'parameters' is a CodeParameterDeclarationExpression array.
            collection.CopyTo(parameters, 0);
            //</Snippet6>

            //<Snippet7>
            // Retrieves the count of the items in the collection.
            int collectionCount = collection.Count;

            //</Snippet7>

            //<Snippet8>
            // Inserts a CodeParameterDeclarationExpression at index 0
            // of the collection.
            collection.Insert(0, new CodeParameterDeclarationExpression(typeof(int), "testIntArgument"));
            //</Snippet8>

            //<Snippet9>
            // Removes the specified CodeParameterDeclarationExpression
            // from the collection.
            CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(typeof(int), "testIntArgument");

            collection.Remove(parameter);
            //</Snippet9>

            //<Snippet10>
            // Removes the CodeParameterDeclarationExpression at index 0.
            collection.RemoveAt(0);
            //</Snippet10>
            //</Snippet1>
        }
示例#5
0
 public static CodeParameterDeclarationExpression[] ToArray(this CodeParameterDeclarationExpressionCollection col)
 {
     CodeParameterDeclarationExpression[] param = new CodeParameterDeclarationExpression[col.Count];
     col.CopyTo(param, 0);
     return(param);
 }