Beispiel #1
0
        public void AUT_LoggingService_ProvideAreas_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodProvideAreasPrametersTypes = null;
            object[]  parametersOfProvideAreas = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodProvideAreas, methodProvideAreasPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <LoggingService, IEnumerable <SPDiagnosticsArea> >(_loggingServiceInstanceFixture, out exception1, parametersOfProvideAreas);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <LoggingService, IEnumerable <SPDiagnosticsArea> >(_loggingServiceInstance, MethodProvideAreas, parametersOfProvideAreas, methodProvideAreasPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfProvideAreas.ShouldBeNull();
            methodProvideAreasPrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_loggingServiceInstanceFixture, parametersOfProvideAreas));
        }
        public void AUT_Licensing_GetAdminUser_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodGetAdminUserPrametersTypes = null;
            object[]  parametersOfGetAdminUser = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetAdminUser, methodGetAdminUserPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <Licensing, string>(_licensingInstanceFixture, out exception1, parametersOfGetAdminUser);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <Licensing, string>(_licensingInstance, MethodGetAdminUser, parametersOfGetAdminUser, methodGetAdminUserPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetAdminUser.ShouldBeNull();
            methodGetAdminUserPrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_licensingInstanceFixture, parametersOfGetAdminUser));
        }
Beispiel #3
0
        public void AUT_SetupPPM_overriden_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodoverridenPrametersTypes = null;
            object[]  parametersOfoverriden = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(Methodoverriden, methodoverridenPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <SetupPPM, bool>(_setupPPMInstanceFixture, out exception1, parametersOfoverriden);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <SetupPPM, bool>(_setupPPMInstance, Methodoverriden, parametersOfoverriden, methodoverridenPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfoverriden.ShouldBeNull();
            methodoverridenPrametersTypes.ShouldBeNull();
        }
        public void AUT_CommonActionsAjaxDataHost_BuildListItemHTML_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodBuildListItemHTMLPrametersTypes = null;
            object[]  parametersOfBuildListItemHTML = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodBuildListItemHTML, methodBuildListItemHTMLPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <CommonActionsAjaxDataHost, string>(_commonActionsAjaxDataHostInstanceFixture, out exception1, parametersOfBuildListItemHTML);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <CommonActionsAjaxDataHost, string>(_commonActionsAjaxDataHostInstance, MethodBuildListItemHTML, parametersOfBuildListItemHTML, methodBuildListItemHTMLPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfBuildListItemHTML.ShouldBeNull();
            methodBuildListItemHTMLPrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_commonActionsAjaxDataHostInstanceFixture, parametersOfBuildListItemHTML));
        }
        public void AUT_ReportAuth_HasAdditionalUpdateAccess_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodHasAdditionalUpdateAccessPrametersTypes = null;
            object[]  parametersOfHasAdditionalUpdateAccess = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodHasAdditionalUpdateAccess, methodHasAdditionalUpdateAccessPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <ReportAuth, bool>(_reportAuthInstanceFixture, out exception1, parametersOfHasAdditionalUpdateAccess);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <ReportAuth, bool>(_reportAuthInstance, MethodHasAdditionalUpdateAccess, parametersOfHasAdditionalUpdateAccess, methodHasAdditionalUpdateAccessPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfHasAdditionalUpdateAccess.ShouldBeNull();
            methodHasAdditionalUpdateAccessPrametersTypes.ShouldBeNull();
        }
        public void AUT_BaseJob_CreateConnection_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodCreateConnectionPrametersTypes = null;
            object[]  parametersOfCreateConnection = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodCreateConnection, methodCreateConnectionPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <BaseJob, SqlConnection>(_baseJobInstanceFixture, out exception1, parametersOfCreateConnection);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <BaseJob, SqlConnection>(_baseJobInstance, MethodCreateConnection, parametersOfCreateConnection, methodCreateConnectionPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfCreateConnection.ShouldBeNull();
            methodCreateConnectionPrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_baseJobInstanceFixture, parametersOfCreateConnection));
        }
Beispiel #7
0
        public void AUT_ApplicationsLinkProvider_GetLinks_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodGetLinksPrametersTypes = null;
            object[]  parametersOfGetLinks = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetLinks, methodGetLinksPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <ApplicationsLinkProvider, IEnumerable <INavObject> >(_applicationsLinkProviderInstanceFixture, out exception1, parametersOfGetLinks);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <ApplicationsLinkProvider, IEnumerable <INavObject> >(_applicationsLinkProviderInstance, MethodGetLinks, parametersOfGetLinks, methodGetLinksPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetLinks.ShouldBeNull();
            methodGetLinksPrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_applicationsLinkProviderInstanceFixture, parametersOfGetLinks));
        }
        public void AUT_ViewPermissionSelectorMenu_ComeFromView_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodComeFromViewPrametersTypes = null;
            object[]  parametersOfComeFromView = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodComeFromView, methodComeFromViewPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <ViewPermissionSelectorMenu, bool>(_viewPermissionSelectorMenuInstanceFixture, out exception1, parametersOfComeFromView);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <ViewPermissionSelectorMenu, bool>(_viewPermissionSelectorMenuInstance, MethodComeFromView, parametersOfComeFromView, methodComeFromViewPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfComeFromView.ShouldBeNull();
            methodComeFromViewPrametersTypes.ShouldBeNull();
        }
        public void AUT_WorkspaceController_CreateWorkspace_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            Type []   methodCreateWorkspacePrametersTypes = null;
            object[]  parametersOfCreateWorkspace = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodCreateWorkspace, methodCreateWorkspacePrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <WorkspaceController, ICreatedWorkspaceInfo>(_workspaceControllerInstanceFixture, out exception1, parametersOfCreateWorkspace);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <WorkspaceController, ICreatedWorkspaceInfo>(_workspaceControllerInstance, MethodCreateWorkspace, parametersOfCreateWorkspace, methodCreateWorkspacePrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfCreateWorkspace.ShouldBeNull();
            methodCreateWorkspacePrametersTypes.ShouldBeNull();
            Should.Throw <Exception>(() => methodInfo.Invoke(_workspaceControllerInstanceFixture, parametersOfCreateWorkspace));
        }
Beispiel #10
0
        public void AUT_SSRSReportRedirect_SetupSSRS_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodSetupSSRSPrametersTypes = null;
            object[]  parametersOfSetupSSRS = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodSetupSSRS, methodSetupSSRSPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <SSRSReportRedirect, bool>(_sSRSReportRedirectInstanceFixture, out exception1, parametersOfSetupSSRS);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <SSRSReportRedirect, bool>(_sSRSReportRedirectInstance, MethodSetupSSRS, parametersOfSetupSSRS, methodSetupSSRSPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfSetupSSRS.ShouldBeNull();
            methodSetupSSRSPrametersTypes.ShouldBeNull();
        }
        public void AUT_Rpanalyzer_GetMaxPeriodLimit_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodGetMaxPeriodLimitPrametersTypes = null;
            object[]  parametersOfGetMaxPeriodLimit = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetMaxPeriodLimit, methodGetMaxPeriodLimitPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <rpanalyzer, Int32>(_rpanalyzerInstanceFixture, out exception1, parametersOfGetMaxPeriodLimit);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <rpanalyzer, Int32>(_rpanalyzerInstance, MethodGetMaxPeriodLimit, parametersOfGetMaxPeriodLimit, methodGetMaxPeriodLimitPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfGetMaxPeriodLimit.ShouldBeNull();
            methodGetMaxPeriodLimitPrametersTypes.ShouldBeNull();
        }
Beispiel #12
0
        public void AUT_CustomTopNav_IsInheritingFromParent_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodIsInheritingFromParentPrametersTypes = null;
            object[]  parametersOfIsInheritingFromParent = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodIsInheritingFromParent, methodIsInheritingFromParentPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <CustomTopNav, bool>(_customTopNavInstanceFixture, out exception1, parametersOfIsInheritingFromParent);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <CustomTopNav, bool>(_customTopNavInstance, MethodIsInheritingFromParent, parametersOfIsInheritingFromParent, methodIsInheritingFromParentPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfIsInheritingFromParent.ShouldBeNull();
            methodIsInheritingFromParentPrametersTypes.ShouldBeNull();
            Should.NotThrow(() => ReflectionAnalyzer.GetResultOfMethod <CustomTopNav, bool>(_customTopNavInstance, MethodIsInheritingFromParent, parametersOfIsInheritingFromParent, methodIsInheritingFromParentPrametersTypes));
        }
        public void AUT_AssemblyManager_GetTypes_Method_Call_With_Results_Should_Not_Be_Null_Test()
        {
            // Arrange
            Type []   methodGetTypesPrametersTypes = null;
            object[]  parametersOfGetTypes = null; // no parameter present
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetTypes, methodGetTypesPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <AssemblyManager, IEnumerable <Type> >(_assemblyManagerInstanceFixture, out exception1, parametersOfGetTypes);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <AssemblyManager, IEnumerable <Type> >(_assemblyManagerInstance, MethodGetTypes, parametersOfGetTypes, methodGetTypesPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldNotBeNull();
            result2.ShouldNotBeNull();
            result1.ShouldBe(result2);
            parametersOfGetTypes.ShouldBeNull();
            methodGetTypesPrametersTypes.ShouldBeNull();
            Should.NotThrow(() => ReflectionAnalyzer.GetResultOfMethod <AssemblyManager, IEnumerable <Type> >(_assemblyManagerInstance, MethodGetTypes, parametersOfGetTypes, methodGetTypesPrametersTypes));
        }
        public void AUT_Newproject_createProject_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var web = CreateType<SPWeb>();
            var methodcreateProjectPrametersTypes = new Type[] { typeof(SPWeb) };
            object[] parametersOfcreateProject = { web };
            Exception exception, exception1;
            var methodInfo = GetMethodInfo(MethodcreateProject, methodcreateProjectPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo<newproject, string>(_newprojectInstanceFixture, out exception1, parametersOfcreateProject);
            var result2 = ReflectionAnalyzer.GetResultOfMethod<newproject, string>(_newprojectInstance, MethodcreateProject, parametersOfcreateProject, methodcreateProjectPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfcreateProject.ShouldNotBeNull();
            parametersOfcreateProject.Length.ShouldBe(1);
            methodcreateProjectPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_SharepointService_GetOdcFileHtml_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var odcFile = CreateType <SPFile>();
            var methodGetOdcFileHtmlPrametersTypes = new Type[] { typeof(SPFile) };

            object[]  parametersOfGetOdcFileHtml = { odcFile };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetOdcFileHtml, methodGetOdcFileHtmlPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <SharepointService, string>(_sharepointServiceInstanceFixture, out exception1, parametersOfGetOdcFileHtml);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <SharepointService, string>(_sharepointServiceInstance, MethodGetOdcFileHtml, parametersOfGetOdcFileHtml, methodGetOdcFileHtmlPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetOdcFileHtml.ShouldNotBeNull();
            parametersOfGetOdcFileHtml.Length.ShouldBe(1);
            methodGetOdcFileHtmlPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_MultiAppCustomSiteMapProvider_GetUserGroups_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var user = CreateType <SPUser>();
            var methodGetUserGroupsPrametersTypes = new Type[] { typeof(SPUser) };

            object[]  parametersOfGetUserGroups = { user };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetUserGroups, methodGetUserGroupsPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <MultiAppCustomSiteMapProvider, List <string> >(_multiAppCustomSiteMapProviderInstanceFixture, out exception1, parametersOfGetUserGroups);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <MultiAppCustomSiteMapProvider, List <string> >(_multiAppCustomSiteMapProviderInstance, MethodGetUserGroups, parametersOfGetUserGroups, methodGetUserGroupsPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetUserGroups.ShouldNotBeNull();
            parametersOfGetUserGroups.Length.ShouldBe(1);
            methodGetUserGroupsPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #17
0
        public void AUT_PublishWorkPlannerWork_GetAdminInfos_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var Site = CreateType <SPSite>();
            var methodGetAdminInfosPrametersTypes = new Type[] { typeof(SPSite) };

            object[]  parametersOfGetAdminInfos = { Site };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetAdminInfos, methodGetAdminInfosPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <PublishWorkPlannerWork, PortfolioEngineCore.Admininfos>(_publishWorkPlannerWorkInstanceFixture, out exception1, parametersOfGetAdminInfos);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <PublishWorkPlannerWork, PortfolioEngineCore.Admininfos>(_publishWorkPlannerWorkInstance, MethodGetAdminInfos, parametersOfGetAdminInfos, methodGetAdminInfosPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetAdminInfos.ShouldNotBeNull();
            parametersOfGetAdminInfos.Length.ShouldBe(1);
            methodGetAdminInfosPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #18
0
        public void AUT_Viewrollup_getRealField_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var field = CreateType <SPField>();
            var methodgetRealFieldPrametersTypes = new Type[] { typeof(SPField) };

            object[]  parametersOfgetRealField = { field };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodgetRealField, methodgetRealFieldPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <viewrollup, SPField>(_viewrollupInstanceFixture, out exception1, parametersOfgetRealField);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <viewrollup, SPField>(_viewrollupInstance, MethodgetRealField, parametersOfgetRealField, methodgetRealFieldPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfgetRealField.ShouldNotBeNull();
            parametersOfgetRealField.Length.ShouldBe(1);
            methodgetRealFieldPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_PersonalItemManager_Synchronize_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var personalItems = CreateType <List <PersonalItem> >();
            var methodSynchronizePrametersTypes = new Type[] { typeof(List <PersonalItem>) };

            object[]  parametersOfSynchronize = { personalItems };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodSynchronize, methodSynchronizePrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <PersonalItemManager, List <PersonalItem> >(_personalItemManagerInstanceFixture, out exception1, parametersOfSynchronize);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <PersonalItemManager, List <PersonalItem> >(_personalItemManagerInstance, MethodSynchronize, parametersOfSynchronize, methodSynchronizePrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfSynchronize.ShouldNotBeNull();
            parametersOfSynchronize.Length.ShouldBe(1);
            methodSynchronizePrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_PersonalItemManager_GetExistingPersonalItems_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var spListItemCollection = CreateType <SPListItemCollection>();
            var methodGetExistingPersonalItemsPrametersTypes = new Type[] { typeof(SPListItemCollection) };

            object[]  parametersOfGetExistingPersonalItems = { spListItemCollection };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetExistingPersonalItems, methodGetExistingPersonalItemsPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <PersonalItemManager, List <PersonalItem> >(_personalItemManagerInstanceFixture, out exception1, parametersOfGetExistingPersonalItems);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <PersonalItemManager, List <PersonalItem> >(_personalItemManagerInstance, MethodGetExistingPersonalItems, parametersOfGetExistingPersonalItems, methodGetExistingPersonalItemsPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetExistingPersonalItems.ShouldNotBeNull();
            parametersOfGetExistingPersonalItems.Length.ShouldBe(1);
            methodGetExistingPersonalItemsPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_EnhancedLookupConfigValuesHelper_GetFieldData_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var fieldIntName = CreateType <string>();
            var methodGetFieldDataPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfGetFieldData = { fieldIntName };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetFieldData, methodGetFieldDataPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <EnhancedLookupConfigValuesHelper, LookupConfigData>(_enhancedLookupConfigValuesHelperInstanceFixture, out exception1, parametersOfGetFieldData);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <EnhancedLookupConfigValuesHelper, LookupConfigData>(_enhancedLookupConfigValuesHelperInstance, MethodGetFieldData, parametersOfGetFieldData, methodGetFieldDataPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetFieldData.ShouldNotBeNull();
            parametersOfGetFieldData.Length.ShouldBe(1);
            methodGetFieldDataPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_WEPickerDialog_getColumns_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var web = CreateType <SPWeb>();
            var methodgetColumnsPrametersTypes = new Type[] { typeof(SPWeb) };

            object[]  parametersOfgetColumns = { web };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodgetColumns, methodgetColumnsPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <WEPickerDialog, Dictionary <string, string> >(_wEPickerDialogInstanceFixture, out exception1, parametersOfgetColumns);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <WEPickerDialog, Dictionary <string, string> >(_wEPickerDialogInstance, MethodgetColumns, parametersOfgetColumns, methodgetColumnsPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfgetColumns.ShouldNotBeNull();
            parametersOfgetColumns.Length.ShouldBe(1);
            methodgetColumnsPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #23
0
        public void AUT_SSRSReportRedirect_getReportParameters_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var url = CreateType <string>();
            var methodgetReportParametersPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfgetReportParameters = { url };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodgetReportParameters, methodgetReportParametersPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <SSRSReportRedirect, string>(_sSRSReportRedirectInstanceFixture, out exception1, parametersOfgetReportParameters);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <SSRSReportRedirect, string>(_sSRSReportRedirectInstance, MethodgetReportParameters, parametersOfgetReportParameters, methodgetReportParametersPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfgetReportParameters.ShouldNotBeNull();
            parametersOfgetReportParameters.Length.ShouldBe(1);
            methodgetReportParametersPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_ResourcePlanNotifications_CreateTicket_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var sData = CreateType <string>();
            var methodCreateTicketPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfCreateTicket = { sData };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodCreateTicket, methodCreateTicketPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <ResourcePlanNotifications, string>(_resourcePlanNotificationsInstanceFixture, out exception1, parametersOfCreateTicket);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <ResourcePlanNotifications, string>(_resourcePlanNotificationsInstance, MethodCreateTicket, parametersOfCreateTicket, methodCreateTicketPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfCreateTicket.ShouldNotBeNull();
            parametersOfCreateTicket.Length.ShouldBe(1);
            methodCreateTicketPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #25
0
        public void AUT_TimeOffManager_GetTimeOff_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var userId = CreateType <int>();
            var methodGetTimeOffPrametersTypes = new Type[] { typeof(int) };

            object[]  parametersOfGetTimeOff = { userId };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetTimeOff, methodGetTimeOffPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <TimeOffManager, XElement>(_timeOffManagerInstanceFixture, out exception1, parametersOfGetTimeOff);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <TimeOffManager, XElement>(_timeOffManagerInstance, MethodGetTimeOff, parametersOfGetTimeOff, methodGetTimeOffPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetTimeOff.ShouldNotBeNull();
            parametersOfGetTimeOff.Length.ShouldBe(1);
            methodGetTimeOffPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #26
0
        public void AUT_ReportFilterUserSettingsRepository_GetUserSettings_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var searchCriteria = CreateType <ReportFilterSearchCriteria>();
            var methodGetUserSettingsPrametersTypes = new Type[] { typeof(ReportFilterSearchCriteria) };

            object[]  parametersOfGetUserSettings = { searchCriteria };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetUserSettings, methodGetUserSettingsPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <ReportFilterUserSettingsRepository, ReportFilterUserSettings>(_reportFilterUserSettingsRepositoryInstanceFixture, out exception1, parametersOfGetUserSettings);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <ReportFilterUserSettingsRepository, ReportFilterUserSettings>(_reportFilterUserSettingsRepositoryInstance, MethodGetUserSettings, parametersOfGetUserSettings, methodGetUserSettingsPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetUserSettings.ShouldNotBeNull();
            parametersOfGetUserSettings.Length.ShouldBe(1);
            methodGetUserSettingsPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #27
0
        public void AUT_AssignmentPlanner_GetFormattedDate_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var dateTime = CreateType <DateTime>();
            var methodGetFormattedDatePrametersTypes = new Type[] { typeof(DateTime) };

            object[]  parametersOfGetFormattedDate = { dateTime };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetFormattedDate, methodGetFormattedDatePrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <AssignmentPlanner, string>(_assignmentPlannerInstanceFixture, out exception1, parametersOfGetFormattedDate);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <AssignmentPlanner, string>(_assignmentPlannerInstance, MethodGetFormattedDate, parametersOfGetFormattedDate, methodGetFormattedDatePrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetFormattedDate.ShouldNotBeNull();
            parametersOfGetFormattedDate.Length.ShouldBe(1);
            methodGetFormattedDatePrametersTypes.Length.ShouldBe(1);
        }
Beispiel #28
0
        public void AUT_TagManager_RemoveTagOrder_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var data = CreateType <string>();
            var methodRemoveTagOrderPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfRemoveTagOrder = { data };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodRemoveTagOrder, methodRemoveTagOrderPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <TagManager, string>(_tagManagerInstanceFixture, out exception1, parametersOfRemoveTagOrder);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <TagManager, string>(_tagManagerInstance, MethodRemoveTagOrder, parametersOfRemoveTagOrder, methodRemoveTagOrderPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfRemoveTagOrder.ShouldNotBeNull();
            parametersOfRemoveTagOrder.Length.ShouldBe(1);
            methodRemoveTagOrderPrametersTypes.Length.ShouldBe(1);
        }
        public void AUT_XMLDataManager_GetPropVal_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var propName = CreateType <string>();
            var methodGetPropValPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfGetPropVal = { propName };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetPropVal, methodGetPropValPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <XMLDataManager, string>(_xMLDataManagerInstanceFixture, out exception1, parametersOfGetPropVal);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <XMLDataManager, string>(_xMLDataManagerInstance, MethodGetPropVal, parametersOfGetPropVal, methodGetPropValPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetPropVal.ShouldNotBeNull();
            parametersOfGetPropVal.Length.ShouldBe(1);
            methodGetPropValPrametersTypes.Length.ShouldBe(1);
        }
Beispiel #30
0
        public void AUT_AnalyzerDataCache_GetStashEntry_Method_Call_With_No_Parameters_Call_Results_ShouldBe_Null_If_Not_Premitive_Type_Test()
        {
            // Arrange
            var sKey = CreateType <string>();
            var methodGetStashEntryPrametersTypes = new Type[] { typeof(string) };

            object[]  parametersOfGetStashEntry = { sKey };
            Exception exception, exception1;
            var       methodInfo = GetMethodInfo(MethodGetStashEntry, methodGetStashEntryPrametersTypes, out exception);

            // Act
            var result1 = methodInfo.GetResultMethodInfo <AnalyzerDataCache, string>(_analyzerDataCacheInstanceFixture, out exception1, parametersOfGetStashEntry);
            var result2 = ReflectionAnalyzer.GetResultOfMethod <AnalyzerDataCache, string>(_analyzerDataCacheInstance, MethodGetStashEntry, parametersOfGetStashEntry, methodGetStashEntryPrametersTypes);

            // Assert
            methodInfo.ShouldNotBeNull();
            exception.ShouldBeNull();
            result1.ShouldBeNull();
            result2.ShouldBeNull();
            parametersOfGetStashEntry.ShouldNotBeNull();
            parametersOfGetStashEntry.Length.ShouldBe(1);
            methodGetStashEntryPrametersTypes.Length.ShouldBe(1);
        }