public void AddAssignmentWithSameKeyShouldThrow() { var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(item); Assert.AreEqual(1, testObject.Count); Assert.Throws<ArgumentException>(() => testObject.AddAssignment(item)); Assert.AreEqual(1, testObject.Count); var item2 = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); Assert.Throws<ArgumentException>(() => testObject.AddAssignment(item2)); Assert.AreEqual(1, testObject.Count); }
public void AddAssignmentTest() { var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected); Assert.AreEqual(1, testObject.Count); var actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); var expected2 = new ConstructorAssignment("OtherParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected2); actual = testObject["OtherParameterName"]; Assert.AreEqual(2, testObject.Count); Assert.AreEqual(expected2, actual); actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); }
/// <summary> /// Tries to find a matching constructor assignment for a parameter. /// </summary> /// <param name="parameter">The name of the parameter to find the constructor assignment for.</param> /// <param name="constructorAssignment">The found constructor assignment. Is <c>null</c> when none is found.</param> /// <param name="caseSensitive">if set to <c>true</c> if case sensitive parameter name matching should be used.</param> /// <returns> /// <c>true</c> if a matching constructor assignment was found; otherwise <c>false</c>. /// </returns> public bool TryFindConstructorAssignment( string parameter, out ConstructorAssignment constructorAssignment, bool caseSensitive) { Guard.NotNullOrEmpty(() => parameter, parameter); // Guard.NotNull(() => this.assignments, this.assignments); if (CtorAssignments == null) { constructorAssignment = null; return(false); } Func <string, string, bool> comparer; if (caseSensitive) { comparer = (x, y) => x == y; } else { comparer = (x, y) => x.ToLower() == y.ToLower(); } foreach (var ctorAssignments in CtorAssignments) { foreach (var assignment in ctorAssignments) { if (comparer(assignment.ParameterName, parameter)) { constructorAssignment = assignment; return(true); } } } constructorAssignment = null; return(false); }
public void PropertyItemIndexNormalBehavior() { // Test read access of 'Indexer' Property. var expected = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(expected); var actual = testObject["ParameterName"]; Assert.AreEqual(expected, actual); }
public void PropertyItemIndexWithNotPresentKey() { // Test read access of 'Indexer' Property with a key that is not present. var actual = testObject["NotPresent"]; Assert.IsNull(actual); var item = new ConstructorAssignment("ParameterName", new CodeAssignStatement(), new CodeMemberField(), typeof(string)); testObject.AddAssignment(item); actual = testObject["AnotherNotPresent"]; Assert.IsNull(actual); }
private void CreateMocker( CodeTypeDeclaration testClassDeclaration, CodeMemberMethod setUpMethod, CodeMemberField mockRepositoryMemberField, List<CodeAssignStatement> mockAssignments, Type paraType, string paraName, ConstructorAssignment data) { if(data != null && data.MemberFieldName != data.ParameterName) { } // reuse already present field assignments. var mockMemberField = testClassDeclaration .Members.OfType<CodeMemberField>() .Where(e => e.Name == paraName) .FirstOrDefault(); var mockMemberFieldCreated = false; if (mockMemberField == null) { mockMemberField = AddTestMemberField( testClassDeclaration, paraType.FullName, paraName); mockMemberFieldCreated = true; } var mockAssignment = this.AddMockObject(mockRepositoryMemberField, paraType.FullName, paraName); if (mockMemberFieldCreated) { // none found, add a new assignment. setUpMethod.Statements.Add(mockAssignment); } else { if (data != null) { data.AssignStatement.Right = mockAssignment.Right; } } mockAssignments.Add(mockAssignment); }
/// <summary> /// Builds a assignment info for the specified constructor. /// </summary> /// <param name="bindingAttr">A bit mask comprised of one or more <see cref="BindingFlags"/> /// that specify how the search is conducted. -or- Zero, to return <c>null</c>.</param> /// <param name="constructor">The constructor to build the parameter assignment info's for.</param> /// <returns> /// An <see cref="AssignmentInfoCollection"/> initialized with the data from the specified /// <paramref name="constructor"/>. /// </returns> private AssignmentInfoCollection BuildAssignmentInfoForConstructor( BindingFlags bindingAttr, ConstructorInfo constructor) { // var ctorParameterTypesInterface = new List<ParameterInfo>(); // var ctorParameterTypesStd = new List<ParameterInfo>(); var ctorParameterTypes = new ParameterInfoCollection(); var ctorParameters = constructor.GetParameters(); foreach (var para in ctorParameters) { { // if (!para.ParameterType.IsGenericType) ctorParameterTypes.AddParameterInfo(para); /*if (para.ParameterType.IsInterface) * { * hasInterfaceInCtorParameters = true; * ctorParameterTypesInterface.Add(para); * } * else * { * ctorParameterTypesStd.Add(para); * }*/ } } // BuildAssignmentInfoForConstructor var assignmentInfoCollection = new AssignmentInfoCollection { UsedConstructor = constructor }; var addTypesFrom = ctorParameterTypes; /*var addTypesFrom = ctorParameterTypes.StandardTypes; * * // Todo: do not use bindingAttr here, use the MemberVisibility enumeration * if ((bindingAttr & BindingFlags.NonPublic) == BindingFlags.NonPublic) * { * addTypesFrom = ctorParameterTypes; * }*/ foreach (var paraInfo in addTypesFrom) { if (!paraInfo.ParameterType.IsGenericType) { var memberField = CreateMemberField(paraInfo.ParameterType.FullName, paraInfo.Name); // var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField( // paraInfo.ParameterType, paraInfo.Name); // var assignment = new ConstructorAssignment( // paraInfo.Name, fieldAssignment, memberField, paraInfo.ParameterType); var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField( paraInfo.ParameterType, memberField.Name); var assignment = new ConstructorAssignment( memberField.Name, fieldAssignment, memberField, paraInfo.ParameterType); assignmentInfoCollection.AddAssignment(assignment); } else { var genericTypeDefinition = paraInfo.ParameterType.GetGenericTypeDefinition(); if (TestObjectMemberField.Type.BaseType == "DefaultMemberBuilderFactory") { } if (CheckForItemizable(paraInfo, genericTypeDefinition)) { var genArgs = paraInfo.ParameterType.GetGenericArguments(); if (genArgs.Length == 1) { var memberFieldName = paraInfo.Name + "Item"; var memberField = CreateMemberField(genArgs[0].FullName, memberFieldName); var fieldAssignment = CodeMethodComposer.CreateAndInitializeMemberField( genArgs[0], memberField.Name); var assignment = new ConstructorAssignment( memberField.Name, fieldAssignment, memberField, genArgs[0]); // assignmentInfoCollection.AddAssignment(assignment); // AddAssignStatement(fieldAssignment); var collectionFieldName = paraInfo.Name; var collectionField = CreateMemberField(paraInfo.ParameterType.FullName, collectionFieldName); var collectionAssignment = CodeMethodComposer.CreateAndInitializeCollectionField( /*paraInfo.ParameterType,*/ collectionFieldName, memberFieldName); var collection = new ConstructorAssignment( collectionFieldName, collectionAssignment, collectionField, paraInfo.ParameterType); collection.CreateAssignments.Add(assignment); assignmentInfoCollection.AddAssignment(collection); } } if (typeof(IEnumerable).IsAssignableFrom(paraInfo.ParameterType)) { } if (paraInfo.ParameterType.IsAssignableFrom(typeof(IEnumerable <>))) { } } } return(assignmentInfoCollection); }