public void CheckOnlineService() { var settings = new MockSettings(); var service = new OnlineService(); object result = null; var connection = new OnlineServiceConnection(settings, () => { throw new ConnectionTimedOut(); }); connection.Connected += () => connection.Send(new LoginRequest(LoadApiKeyFromRegistry(), "LogoApp")); connection.DataReceived += message => result = message; service.Connect("CurrentUser", connection); Thread.Sleep(500); Console.WriteLine("User Name: " + service.UserName); CheckService(service, "LogoApp", result); Assert.IsFalse(service.IsDeveloper); bool hasProjectChanged = false; service.ProjectChanged += () => hasProjectChanged = true; service.ChangeProject("Asteroids"); Thread.Sleep(500); Assert.IsTrue(hasProjectChanged); CheckService(service, "Asteroids", result); Assert.IsFalse(service.IsDeveloper); }
public async Task <IActionResult> Put([FromBody] MockSettings mockSettings) { try { if (mockSettings == null) { mockSettings = new MockSettings(); } var gen = new ListGenerator(); var steps = gen.GetSeps(mockSettings); var mockLength = mockSettings.MinValue; for (int i = 0; i < steps.Length - 1; i++) { int[] arr = gen.ListOfIntegers(mockLength); await dataManager.GenerateMocks(string.Join(',', arr), mockLength); mockLength += (int)steps[i]; } if (true) { return(Ok()); } } catch (Exception ex) { return(BadRequest(ex)); } }
public void SettingsChangeBeforeClose() { MockSettings settings = new MockSettings(); settings.Change(); settings.Dispose(); }
public void VerifyPackageReferenceParserTest() { string projectPackageReferenceFile = Path.Combine(TestRootPath, "foo.proj"); string projectAssetsJsonFile = Path.Combine(TestRootPath, "project.assets.json"); PackageRestoreData packageRestoreData = LoadPackageRestoreObject(projectPackageReferenceFile, GetTempFileName(), _packageReferenceRestoreFlagContents.Replace("#RestoreOutputPath#", TestRootPath.Replace(@"\", @"\\"))); CreateProjectAssetsJsonFile(projectAssetsJsonFile, (new List <Tuple <string, string> > { new Tuple <string, string>("Newtonsoft.Json", "6.0.3") })); string packagePath = CreatePackagesFolder(new List <Tuple <string, string> > { new Tuple <string, string>("Newtonsoft.Json", "6.0.3") }, @"\"); MockSettings settings = new MockSettings { { "config", new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { { "globalPackagesFolder", packagePath }, } } }; bool result = new NuGetPackageReferenceProjectParser(settings, _log).TryGetPackages(packagePath, packageRestoreData, out IEnumerable <PackageIdentityWithPath> packages); result.ShouldBeTrue(); IList <PackageIdentityWithPath> packageIdentityWithPaths = packages as IList <PackageIdentityWithPath> ?? packages.ToList(); packageIdentityWithPaths.Count.ShouldBe(1); packageIdentityWithPaths.First().Id.ShouldBe("Newtonsoft.Json"); packageIdentityWithPaths.First().Version.ToString().ShouldBe("6.0.3"); }
private static TestCase[] CreateTestCases() { using var settings = MockSettings.Create(); var metres = settings.Metres; var kilograms = settings.Kilograms; var seconds = settings.Seconds; return(new[] { new TestCase("m^2", "m²", UnitAndPower.Create(metres, 2)), new TestCase("m²", "m²", UnitAndPower.Create(metres, 2)), new TestCase("m³", "m³", UnitAndPower.Create(metres, 3)), new TestCase("kg⋅m/s²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)), new TestCase("kg⋅m⋅s⁻²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)), new TestCase("kg*m/s²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)), new TestCase("m/s¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)), new TestCase("m⋅s⁻¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)), new TestCase("m¹⋅s^-1", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)), new TestCase("m^1⋅s^-1", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)), new TestCase("m¹⋅s⁻¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)), new TestCase("1/s", "s⁻¹", UnitAndPower.Create(seconds, -1)), new TestCase("s^-1", "s⁻¹", UnitAndPower.Create(seconds, -1)), ////new Data("J/s",UnitAndPower.Create(Joules, 1),UnitAndPower.Create(Seconds, -1)), }); }
public Request(Type type, bool forceMockCreation, MockSettings settings, IDictionary<Type, object> instances) { Type = type; ForceMockCreation = forceMockCreation; Settings = settings; Instances = instances; }
public void GetPackagesPath_WhenPathOrOverrideSpecified_PathIsCorrect(string packagesPathOverride, string packagesPath, string globalPackagesFolder, string expected) { using (var testDirectory = TestDirectory.Create()) { var project = new MockMSBuildProject(testDirectory, properties: new Dictionary <string, string> { ["RestorePackagesPath"] = packagesPath }, globalProperties: new Dictionary <string, string> { ["RestorePackagesPath"] = packagesPathOverride, }); var settings = new MockSettings { Sections = new[] { new MockSettingSection(ConfigurationConstants.Config, new AddItem(ConfigurationConstants.GlobalPackagesFolder, Path.Combine(testDirectory, globalPackagesFolder))) } }; var actual = MSBuildStaticGraphRestore.GetPackagesPath(project, settings); actual.Should().Be(Path.Combine(testDirectory, expected)); } }
public void GetRepositoryPath_WhenPathSolutionOrOverrideSpecified_CorrectPathDetected(string repositoryPathOverride, string restoreRepositoryPath, string solutionPath, string repositoryPath, string expected) { using (var testDirectory = TestDirectory.Create()) { var project = new MockMSBuildProject(testDirectory, new Dictionary <string, string> { ["RestoreRepositoryPath"] = restoreRepositoryPath, ["RestoreRepositoryPathOverride"] = repositoryPathOverride, ["SolutionPath"] = solutionPath == null || solutionPath == "*Undefined*" ? solutionPath : UriUtility.GetAbsolutePath(testDirectory, solutionPath) }); var settings = new MockSettings { Sections = new List <SettingSection> { new MockSettingSection( ConfigurationConstants.Config, repositoryPath == null ? new SettingItem[0] : new SettingItem[] { new AddItem(ConfigurationConstants.RepositoryPath, UriUtility.GetAbsolutePath(testDirectory, repositoryPath)) }) } }; var actual = MSBuildStaticGraphRestore.GetRepositoryPath(project, settings); expected = UriUtility.GetAbsolutePath(testDirectory, expected); actual.Should().Be(expected); } }
public void GetSources_WhenRestoreSourcesSpecified_CorrectSourcesDetected() { var project = new MockMSBuildProject(new Dictionary <string, string> { ["RestoreSources"] = "https://source1;https://source2" }); var settings = new MockSettings { Sections = new List <SettingSection> { new MockSettingSection(ConfigurationConstants.PackageSources, new ClearItem(), new AddItem("source3", "https://source3")) } }; var actual = MSBuildStaticGraphRestore.GetSources(project, new[] { project }, settings); actual.ShouldBeEquivalentTo(new[] { new PackageSource("https://source1"), new PackageSource("https://source2"), }); }
public static void SetUnitToKilograms() { using var settings = MockSettings.Create(); using var vm = new PartConversionsVm(); vm.SetUnit(settings.Kilograms); CollectionAssert.IsEmpty(vm.Conversions); }
public UnitPartsConverterSource() { var settings = MockSettings.Create(); this.Metres = settings.Metres; this.Kilograms = settings.Kilograms; this.Seconds = settings.Seconds; this._datas = new List <Data> { new Data("m^2", "m²", UnitAndPower.Create(this.Metres, 2)), new Data("m²", "m²", UnitAndPower.Create(this.Metres, 2)), new Data("m³", "m³", UnitAndPower.Create(this.Metres, 3)), new Data("kg⋅m/s²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)), new Data("kg⋅m⋅s⁻²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)), new Data("kg*m/s²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)), new Data("m/s¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)), new Data("m⋅s⁻¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)), new Data("m¹⋅s^-1", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)), new Data("m^1⋅s^-1", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)), new Data("m¹⋅s⁻¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)), new Data("1/s", "s⁻¹", UnitAndPower.Create(this.Seconds, -1)), new Data("s^-1", "s⁻¹", UnitAndPower.Create(this.Seconds, -1)) //new Data("J/s",UnitAndPower.Create(Joules, 1),UnitAndPower.Create(Seconds, -1)), }; }
public object CreateMock(Type serviceType, MockSettings settings) { var mock = (Mock) _reflectionHelper.InvokeGenericMethod (s_createMethod, new[] { serviceType }, _repository, new object[] { settings.Behavior }); mock.DefaultValue = settings.DefaultValue; mock.CallBase = settings.CallBase; return mock.Object; }
public void SaveWatchedFileToSettingsOnDispose() { var settings = new MockSettings(); var fileWatcher = new MockFileWatcher(); fileWatcher.SetFile(FilePath); fileWatcher.Dispose(); Assert.AreEqual(FilePath, settings.GetValue(FileWatcher.SettingsKey, "")); }
public void LoadWatchedFileFromSettingsOnInitialization() { var settings = new MockSettings(); string fullFilePath = Path.GetFullPath(FilePath); settings.SetValue(FileWatcher.SettingsKey, fullFilePath); var fileWatcher = new MockFileWatcher(); Assert.AreEqual(fullFilePath, fileWatcher.GetCurrentPath()); }
public MockService(string userName, string projectName) { UserName = userName; ProjectName = projectName; IsDeveloper = true; EditorSettings = new MockSettings(); availableContentWithCodeProjects = new Dictionary <string, string>(); }
public MockService(string userName, string projectName) { UserName = userName; ProjectName = projectName; IsDeveloper = true; EditorSettings = new MockSettings(); availableContentWithCodeProjects = new Dictionary<string, string>(); }
public void Should_Get_Setting() { var expected = "1"; var setting = MockSettings.CreateSaveSetting(db, "PostContributionPledgeFunds", "1"); var actual = db.GetSetting("PostContributionPledgeFunds", ""); actual.ShouldBe(expected); }
public static void MetresToUnitString(int power, string expected) { using var settings = MockSettings.Create(); var parts = new[] { UnitAndPower.Create(settings.Metres, power) }; var actual = parts.AsSymbol(); Assert.AreEqual(expected, actual); }
public void SetUnitToMetresPerSecond() { Assert.Inconclusive(); var settings = MockSettings.Create(); var vm = new PartConversionsVm(settings); vm.SetUnit(settings.MetresPerSecond); CollectionAssert.AreEqual(new PartConversionsVm[0], vm.Conversions); }
public static void SetUnitToMetresPerSecond() { Assert.Inconclusive(); //// ReSharper disable once HeuristicUnreachableCode using var settings = MockSettings.Create(); using var vm = new PartConversionsVm(); vm.SetUnit(settings.MetresPerSecond); CollectionAssert.IsEmpty(vm.Conversions); }
public void Defaults() { // Arrange var settings = new MockSettings(); // Assert settings.Behavior.Should().Be(MockBehavior.Loose); settings.Verification.Should().Be(MockVerification.All); }
public void SetUp() { this.settings = MockSettings.Create(); this.length = this.settings.Length; this.speed = this.settings.Speed; this.time = this.settings.Time; this.area = this.settings.Area; this.volume = this.settings.Volume; }
public void IdentityConversion() { var settings = MockSettings.Create(); var conversion = new PartConversion.IdentityConversion(settings.Metres); Assert.AreEqual("metres", conversion.ToSi); Assert.AreEqual("metres", conversion.FromSi); Assert.AreEqual("1 m = 1 m", conversion.SymbolConversion); Assert.AreEqual(true, conversion.CanRoundtrip); }
public void FactorConversion() { var settings = MockSettings.Create(); var conversion = new FactorConversion("Inches", "in", 0.0254); settings.Metres.FactorConversions.Add(conversion); Assert.AreEqual("0.0254*inches", conversion.ToSi); Assert.AreEqual("metres/0.0254", conversion.FromSi); Assert.AreEqual("1 in = 0.0254 m", conversion.SymbolConversion); Assert.AreEqual(true, conversion.CanRoundtrip); }
public void CustomConversionWithIllegal() { var settings = MockSettings.Create(); var conversion = new CustomConversion("Fahrenheit", "°F", "??", null); settings.Kelvins.CustomConversions.Add(conversion); Assert.AreEqual("??", conversion.ToSi); Assert.AreEqual(null, conversion.FromSi); Assert.AreEqual("Invalid", conversion.SymbolConversion); Assert.AreEqual(false, conversion.CanRoundtrip); }
public void NestedFactorConversion() { var settings = MockSettings.Create(); var conversion = PrefixConversion.Create(settings.Grams, settings.Milli); settings.Grams.PrefixConversions.Add(conversion); Assert.AreEqual("milligrams/1000000", conversion.ToSi); Assert.AreEqual("1000000*kilograms", conversion.FromSi); Assert.AreEqual("1 mg = 1E-06 kg", conversion.SymbolConversion); Assert.AreEqual(true, conversion.CanRoundtrip); }
public static void Should_Get_Setting() { using (var db = CMSDataContext.Create(DatabaseFixture.Host)) { var expected = "1"; var setting = MockSettings.CreateSaveSetting(db, "PostContributionPledgeFunds", "1"); var actual = db.GetSetting("PostContributionPledgeFunds", ""); actual.ShouldBe(expected); } }
protected void Run(string test) { var src = Load(this.rule.Name, test); ISettings settings = new MockSettings(); Compilation compilation = Compilation.Create("test", syntaxTrees: new[] { src }); var target = RuleRewriterFactory.Create(this.rule, settings, () => compilation.GetSemanticModel(src)); var result = target.Visit(src.GetRoot()); var formattedResult = SyntaxTree.Create((CompilationUnitSyntax)result.Format(FormattingOptions.GetDefaultOptions()).GetFormattedRoot(), src.FilePath); Compare(formattedResult, this.rule.Name, test); }
public async Task IdentityConversion() { var settings = MockSettings.Create(); var conversion = new PartConversion.IdentityConversion(settings.Metres); Assert.AreEqual("metres", conversion.ToSi); Assert.AreEqual("metres", conversion.FromSi); Assert.AreEqual("1 m = 1 m", conversion.SymbolConversion); Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false)); }
public void ReturnsAppIDValueIfInSettings() { // Arrange const string expected = "123456"; var settings = new MockSettings(); settings.Values[FacebookAuthenticator.AppIdKey] = expected; // Act/Assert Assert.Equal(expected, new FacebookAuthenticator().GetAppId(settings)); }
public void ThrowsIfWrongParameter() { var settings = MockSettings.Create(); var conversion = new CustomConversion("Fahrenheit", "°F", "(fahrenheit + 459.67)/1.8", "1.8*kelvin - 459.67"); settings.Kelvins.CustomConversions.Add(conversion); var exception = Assert.Throws <ArgumentException>(() => conversion.FromSi = "metres + 45"); Assert.AreEqual("(2,8): error CS0103: The name 'metres' does not exist in the current context", exception.Message); }
public static void CreateMilligrams() { using var settings = MockSettings.Create(); var conversion = PrefixConversion.Create(settings.Grams, settings.Milli); settings.Grams.PrefixConversions.Add(conversion); Assert.AreEqual("Milligrams", conversion.Name); Assert.AreEqual("mg", conversion.Symbol); Assert.AreEqual(1E-6, conversion.Factor); }
public static void CreateMilliAmperes() { using var settings = MockSettings.Create(); var conversion = PrefixConversion.Create(settings.Amperes, settings.Milli); settings.Amperes.PrefixConversions.Add(conversion); Assert.AreEqual("Milliamperes", conversion.Name); Assert.AreEqual("mA", conversion.Symbol); Assert.AreEqual(0.001, conversion.Factor); }
public void PrefixMicroConversion() { var settings = MockSettings.Create(); var conversion = PrefixConversion.Create(settings.Metres, settings.Micro); settings.Metres.PrefixConversions.Add(conversion); Assert.AreEqual("micrometres/1000000", conversion.ToSi); Assert.AreEqual("1000000*metres", conversion.FromSi); Assert.AreEqual("1 µm = 1E-06 m", conversion.SymbolConversion); Assert.AreEqual(true, conversion.CanRoundtrip); }
public static ITestCommand CreateCommand(IMethodInfo methodInfo, ConstructorInfo constructor, MockSettings settings, MockSettings constructorSettings) { var requestProvider = new RequestProvider(); var reflectionHelper = new ReflectionHelper(); var mockRepository = new MoqMockRepository (reflectionHelper); var constructorChooser = new CompositeConstructorChooser (s_constructorChoosers); var resolver = new Resolver (mockRepository, constructorChooser, reflectionHelper); var moqResolver = new MoqResolver (resolver); return new NukitoFactCommand (methodInfo, constructor, requestProvider, moqResolver, reflectionHelper, mockRepository, settings, constructorSettings); }
public void GramsPerCubicMetre() { var settings = MockSettings.Create(); var gramPart = PartConversion.CreatePart(1, settings.Grams); var volumePart = PartConversion.CreatePart(-1, settings.CubicMetres); var conversion = PartConversion.Create(settings.KilogramsPerCubicMetre, gramPart, volumePart); Assert.AreEqual("g/m³", conversion.Symbol); Assert.AreEqual("GramsPerCubicMetre", conversion.Name); Assert.AreEqual(1E-3, conversion.Factor); }
public void CustomConversion() { var settings = MockSettings.Create(); var conversion = new CustomConversion("Fahrenheit", "°F", "(fahrenheit + 459.67)/1.8", "1.8*kelvin - 459.67"); settings.Kelvins.CustomConversions.Add(conversion); Assert.AreEqual("(fahrenheit + 459.67)/1.8", conversion.ToSi); Assert.AreEqual("1.8*kelvin - 459.67", conversion.FromSi); Assert.AreEqual("1 °F = 255.927777777778 K", conversion.SymbolConversion); Assert.Inconclusive("Does not roundtrip cleanly"); //Assert.AreEqual(true, conversion.CanRoundtrip); }
public void TestExceptions() { var settings = new MockSettings { UpdatesPerSecond = 0 }; Assert.Throws<EntitiesRunner.InvalidUpdatePerSecondSettings>( () => new EntitiesRunner(new MockBehaviorResolver(), settings)); Assert.Throws<EntitiesRunner.InvalidUpdatePerSecondSettings>( () => EntitiesRunner.Current.ChangeUpdateTimeStep(0)); Assert.Throws<EntitiesRunner.YouAreNotAllowedToDrawOutsideOfTheDrawLoop>( () => EntitiesRunner.Current.CheckIfInDrawState()); Assert.Throws<EntitiesRunner.UnableToResolveBehavior>( () => EntitiesRunner.Current.GetDrawBehavior<DrawBehavior>()); }
public void Merge() { // Arrange var classSettings = new MockSettings {Behavior = MockBehavior.Strict, Verification = MockVerification.None}; var methodSettings = new MockSettings {Behavior = MockBehavior.Loose}; // Act var merged = MockSettings.Merge(classSettings, methodSettings); // Assert merged.Behavior.Should().Be(MockBehavior.Loose); merged.Verification.Should().Be(MockVerification.None); }
private static Settings GetMockSettingsWithAlreadyBuiltApps() { var settings = new MockSettings(); var storageData = new XmlData("BuiltApps"); storageData.AddAttribute("StoragePath", storageData.Name); settings.SetValue(storageData.Name, storageData); var appsStorage = new AppsStorage(settings); appsStorage.AddApp(new WindowsAppInfo("Rebuildable app", Guid.NewGuid(), DateTime.Now) { SolutionFilePath = "A.sln" }); appsStorage.AddApp(new WindowsAppInfo("Non-Rebuildable app ", Guid.NewGuid(), DateTime.Now)); return settings; }
public NukitoFactCommandTest(Mock<IMethodInfo> method, Mock<IRequestProvider> requestProvider, Mock<IResolver> resolver, Mock<IReflectionHelper> reflectionHelper, Mock<IMockRepository> repository) { _method = method; _requestProvider = requestProvider; _fakeConstructor = typeof (string).GetConstructor (new[] { typeof (char[]) }); _ctorArgType = _fakeConstructor.GetParameters().Single().ParameterType; _resolver = resolver; _reflectionHelper = reflectionHelper; _repository = repository; _settings = new MockSettings(); _ctorSettings = new MockSettings(); _command = new NukitoFactCommand (method.Object, _fakeConstructor, requestProvider.Object, resolver.Object, reflectionHelper.Object, repository.Object, _settings, _ctorSettings); }
public void AbsoluteSolutionFilePathDependsOnTheSelectedContentProject() { var settings = new MockSettings(); var service = new OnlineService(); var connection = new OnlineServiceConnection(settings, () => { throw new ConnectionTimedOut(); }); service.Connect("CurrentUser", connection); Assert.AreEqual("", service.CurrentContentProjectSolutionFilePath); service.ChangeProject("LogoApp"); Thread.Sleep(1000); AssertSolutionFilePath(GetSamplesSlnPath(), service); service.ChangeProject("DeltaEngine.Tutorials"); Thread.Sleep(1000); AssertSolutionFilePath(GetTutorialsSlnPath(), service); }
public void GetRetrievesConfigFromInnerValue(MoqResolver moqResolver, Mock<IResolver> innerResolver, MockSettings settings) { // Arrange var instances = new Dictionary<Type, object>(); var fakeInnerValue = new Mock<IMocked>(); innerResolver .Setup (x => x.Get (It.Is ((Request r) => r.Type == typeof (string) && r.ForceMockCreation && r.Settings == settings && r.Instances == instances))) .Returns (fakeInnerValue.Object); // Act var result = moqResolver.Get (new Request (typeof (Mock<string>), false, settings, instances)); // Assert result.Should ().BeSameAs (fakeInnerValue); }
public void InitializesValues() { // Arrange var data = new MockDataRepository(); var tokens = new TokenService(); var settings = new MockSettings(); // Act AuthenticationService auth = new AuthenticationService(data, tokens, settings); // Assert Assert.Same(data, auth.Data); Assert.Same(tokens, auth.Tokens); Assert.Same(settings, auth.Settings); Assert.Equal(TimeSpan.FromMinutes(30), auth.Timeout); }
public NukitoFactCommand( IMethodInfo method, ConstructorInfo constructor, IRequestProvider requestProvider, IResolver resolver, IReflectionHelper reflectionHelper, IMockRepository mockRepository, MockSettings settings, MockSettings constructorSettings) : base(method) { _constructor = constructor; _requestProvider = requestProvider; _resolver = resolver; _reflectionHelper = reflectionHelper; _mockRepository = mockRepository; _settings = settings; _constructorSettings = constructorSettings; }
public void CreateMock() { // Arrange var settings = new MockSettings { Behavior = MockBehavior.Loose, DefaultValue = DefaultValue.Empty, CallBase = true }; // Act var result = _repository.CreateMock (typeof (IA), settings); // Assert result.Should().BeAssignableTo<IA>(); result.Should().BeAssignableTo<IMocked<IA>> (); var configuration = ((IMocked<IA>) result).Mock; configuration.Behavior.Should ().Be (settings.Behavior); configuration.DefaultValue.Should ().Be (settings.DefaultValue); configuration.CallBase.Should ().Be (settings.CallBase); }
public void CreateAppsListViewModel() { editorSettings = new MockSettings(); appListViewModel = new BuiltAppsListViewModel(editorSettings); }
public void SetRenderSize() { var loadedMaterial = ContentLoader.Load<Material>("DefaultMaterial"); var resolution = new MockSettings().Resolution; loadedMaterial.RenderSizeMode = RenderSizeMode.PixelBased; var pixelBasedSize = ScreenSpace.Current.ToPixelSpace(loadedMaterial.MaterialRenderSize); Assert.AreEqual(new Size(128), pixelBasedSize); SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor800X480, 800); SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1024X768, 1024); SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1280X720, 1280); SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1920X1080, 1920); SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeForSettingsResolution, resolution.Width); }
private object[] CreateArguments(MethodBase methodBase, MockSettings settings) { return methodBase.GetParameters() .Select (p => _resolver.Get (_requestProvider.GetRequest (GetContextName (p), p.ParameterType, settings))) .ToArray(); }
public Request GetRequest(string contextName, Type parameterType, MockSettings settings) { var instances = GetOrCreateContext (contextName); return new Request (parameterType, false, settings, instances); }
public void InitializesValues() { // Arrange var data = new MockDataRepository(); var auths = new List<Authenticator>() { new FacebookAuthenticator() }; var settings = new MockSettings(); // Act AuthenticationService auth = new AuthenticationService(auths, settings, data); // Assert Assert.Same(data, auth.Data); Assert.Equal(1, auth.Authenticators.Count); Assert.Same(auths[0], auth.Authenticators["fb"]); Assert.Same(settings, auth.Settings); }
public TestableAuthenticationService() { Data = MockData = new MockDataRepository(); Tokens = MockTokens = new MockTokenService(); Settings = MockSettings = new MockSettings(); TokenExchanges = new Dictionary<string, HttpResponseMessage>(); }
public MockSettingsAttribute() { Settings = new MockSettings(); }
private Action GetTest(Action<Mock<IB>> method, MockSettings settings = null) { return TestUtility.GetTest(method, settings: settings); }
public void CreateEmptySettings() { settings = new MockSettings(); }
public TestableAuthenticationService() { Authenticators = new Dictionary<string, Authenticator>() { {"fb", new FacebookAuthenticator()} }; Data = MockData = new MockDataRepository(); Settings = MockSettings = new MockSettings(); TokenExchanges = new Dictionary<string, UserInfo>(); }