public void ShouldParseSheetUsingClosedXML() { var serviceCollection = new ServiceCollection(); serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>()); var serviceProvider = serviceCollection.BuildServiceProvider(); var expectedItens = new List <FakeClass>(); for (var i = 0; i < 5; i++) { expectedItens.Add(FakeClass.CreateItem(i % 2 == 0, i % 5 == 0)); } var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >(); var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList(); using var worksheet = CreateStream(expectedItens, headers); var itens = parser.Parse(worksheet, worksheetName); expectedItens.ForEach(x => x.Bonus = x.Bonus * 0.1M); var validationResult = new ValidationResult <FakeClass>(); validationResult.AddItem(expectedItens); itens.Should().BeEquivalentTo(validationResult); }
public void ShouldReturnErrorsUsingClosedXMLAndCustomMessages() { var serviceCollection = new ServiceCollection(); serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>().WithMessages <CustomMessages>()); var serviceProvider = serviceCollection.BuildServiceProvider(); var expectedItens = new List <FakeClass> { FakeClass.CreateItem(), FakeClass.CreateItem(false, false, false), FakeClass.CreateItem(false, false, true) }; var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >(); expectedItens.ForEach(x => x.Bonus *= 0.1M); var validationResult = new ValidationResult <FakeClass>(); var error = new Error("Can't not be null field TX_NAME", 3, 2); validationResult.AddError(error); validationResult.AddItem(expectedItens.First()); validationResult.AddItem(expectedItens.Last()); var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList(); using var worksheet = CreateStream(expectedItens, headers); var itens = parser.Parse(worksheet, worksheetName); itens.Should().BeEquivalentTo(validationResult); }
public void Arrange() { // arrange FakeClass f = new FakeClass("sad"); b = new Bog(); }
public void Should_set_subobj_property_subobj_is_class_and_readwrite() { var fake = new FakeClass { Name = "Empty" }; var view = new ViewHasSubProps { FakeRef = fake }; var page = new ContentPage { Content = view }; var ctx = new XenMessageContext(); ctx.SetRequest <SetPropertyRequest>(r => { r.WidgetId = view.Id.ToString(); r.Path = new [] { "FakeRef", "Name" }; r.Value = "New Value"; }); Assert.AreEqual("Empty", fake.Name); XamarinFormsReaction.Register <SetPropertyRequest, SetPropertyReaction>(page); Reaction.Execute(ctx); Assert.AreEqual("New Value", fake.Name); }
public void BuildXsltExtensionTest() { var factory = new XsltExtensionFactory(); var toWrap = new FakeClass(); var wrapped = factory.BuildXsltExtension(toWrap); var wrappedType = wrapped.GetType(); { var mi = wrappedType.GetMethod("do-work", BindingFlags.Public | BindingFlags.Instance); var ret = mi?.Invoke(wrapped, new object[] { "Hi!" }); this.TestContext.WriteLine($"{"do-work"}: {ret}"); } { var mi = wrappedType.GetMethod("big-work", BindingFlags.Public | BindingFlags.Instance); var ret = mi?.Invoke(wrapped, new object[] { "Hi!", "2", "3", "4", "5", "6" }); this.TestContext.WriteLine($"{"big-work"}: {ret}"); } { var mi = wrappedType.GetMethod("more-work", BindingFlags.Public | BindingFlags.Instance); var ret = mi?.Invoke(wrapped, new object[] { "Hi!" }); this.TestContext.WriteLine($"{"more-work"}: {ret}"); } { var mi = wrappedType.GetMethod("other-work", BindingFlags.Public | BindingFlags.Instance); var ret = mi?.Invoke(wrapped, Array.Empty <object>()); this.TestContext.WriteLine($"{"other-work"}: {ret}"); } { var mi = wrappedType.GetMethod("and-work", BindingFlags.Public | BindingFlags.Instance); var ret = mi?.Invoke(wrapped, Array.Empty <object>()); this.TestContext.WriteLine($"{"and-work"}: {ret}"); } }
public void MapperToOtherType() { var source = new FakeClass(); source.Id = Guid.NewGuid(); source.InnerClasses = new List <FakeClass.InnerClass>(); for (int i = 0; i < 5; i++) { source.InnerClasses.Add(new FakeClass.InnerClass { InnerClassGuid = Guid.NewGuid() }); } var target = TinyMapper.Map <FakeClassDto>(source); Assert.AreNotSame(source, target); Assert.AreEqual(source.Id, target.Id); Assert.AreEqual(source.InnerClasses.Count, target.InnerClasses.Count); for (int i = 0; i < source.InnerClasses.Count; i++) { Assert.AreEqual(source.InnerClasses[i].InnerClassGuid, target.InnerClasses[i].InnerClassGuid); } }
static void Main(string[] args) { FakeClass.MyCostA = 123; var x = FakeClass.CompareCosts(FakeClass.MyCostA); Console.WriteLine(x); Console.ReadKey(); }
public void Set_set_correct_value(int value) { var source = new FakeClass(); var target = GetPropertyAccessorFor("Available2"); target.Set(source,value); source.Available2.Should().Be(value); }
public void Given_InvalidType_ValidateLoggerType_ShouldReturn_False() { var logger = new FakeClass(); var result = LoggerTypeValidator.ValidateLoggerType(logger); result.Should().BeFalse(); }
public void SaveDependant(string jsonEmp, string firstName, string lastName, string connId) { var emp = JsonConvert.DeserializeObject <Employee>(jsonEmp); FakeClass.AddDependant(emp, firstName, lastName); Clients.Client(connId).addOrUpdateEmployee(emp); Clients.All.updateAllEmployees(FakeClass.GetAllEmployees()); }
public void AddOrUpdateEmployee(string jsonEmp, string connId) { var emp = JsonConvert.DeserializeObject <Employee>(jsonEmp); emp = FakeClass.AddOrUpdateEmployee(emp); Clients.Client(connId).addOrUpdateEmployee(emp); Clients.All.updateAllEmployees(FakeClass.GetAllEmployees()); }
public void Add_ObjectWithKeyExistsButOverrideExistingValueIsTrue_ExceptionNotThrown() { //arrange var myObject = new FakeClass(); _collection.Add("MyKey", myObject, true); //act _collection.Add("MyKey", new FakeClass(), true); }
public void Add_ObjectWithKeyAlreadyAdded_ExceptionThrown() { //arrange var myObject = new FakeClass(); _collection.Add("MyKey", myObject); //act _collection.Add("MyKey", new FakeClass()); }
public void Get_returns_correct_result(int value) { var source = new FakeClass { Available2 = value }; var target = GetPropertyAccessorFor("Available2"); target.Get(source).Should().Be(value); }
public TArgument GenericMethodRef <TArgument>(ref TArgument value) where TArgument : FakeClass { var result = new FakeClass() { Value = value.Value }; value.Value++; return((TArgument)result); }
public ActionResult Edit(int id) { var model = FakeClass.GetEmployeeById(id); if (model == null) { RedirectToAction("Index"); return(null); } return(RedirectToAction("EditEmployee", model)); }
public void Get_ObjectWithKeyMyKeyAdded_ReturnValueIsObject() { //arrange var myObject = new FakeClass(); _collection.Add("MyKey", myObject); //act var returnValue = _collection.Get("MyKey"); //assert Assert.AreEqual(myObject, returnValue); }
public void Navigate_generic_context_uses_resolution_key_from_context_route_when_provided(string route, string routeWithoutKey, string resolutionKey) { var newViewModel = new FakeClass(); _ServiceLocator.GetInstance <FakeClass>(resolutionKey).Returns(newViewModel); _RouterSolver.SolveRoute(newViewModel).Returns(route); SetupRouteFromType(routeWithoutKey); _NavigationViewModel.Navigate(new NavigationContext <FakeClass> { ResolutionKey = resolutionKey }); _NavigationViewModel.Route.Should().Be(route); }
public void Get_ObjectWithKeyExistsButOverrideExistingValueIsTrue_NewestObjectReturned() { //arrange var myObject = new FakeClass(); var newObject = new FakeClass(); _collection.Add("MyKey", myObject, true); _collection.Add("MyKey", newObject, true); //act var returnValue = _collection.Get("MyKey"); //assert Assert.AreEqual(newObject, returnValue); }
public void FromClassInstanceToRavenDBAndBack() { IndexCreation.CreateIndexes(typeof(FakeClassIndex).Assembly, DependencyResolver.Current.GetService <IDocumentStore>()); var fakeClassInstance = new FakeClass { Age = 1, Date = new DateTime(2012, 12, 12, 12, 12, 12), Name = "Maxime Séguin" }; using (var reflectionContentManager = DependencyResolver.Current.GetService <IReflectionContentManager>()) { //TODO: Pas certain d'aimer que pour avoir un Content ça génère une query... var content = reflectionContentManager.GetNewOrUpdatedContent(fakeClassInstance).Item; reflectionContentManager.Store(content); reflectionContentManager.SaveChanges(); } RavenDBUtilities.WaitForStaleIndexes(DependencyResolver.Current.GetService <IDocumentStore>()); List <ContentTranslationVersion> contents; using (var session = DependencyResolver.Current.GetService <IDocumentSession>()) { contents = session.Query <Content, FakeClassIndex>() .AsProjection <ContentTranslationVersion>() .ToList(); } Assert.That(contents.Count, Is.EqualTo(1)); List <FakeClass> fakeClasses; using (var session = DependencyResolver.Current.GetService <IDocumentSession>()) { fakeClasses = session.Query <Content, FakeClassIndex>() .AsProjection <FakeClass>() .ToList(); } Assert.That(fakeClasses.Count, Is.EqualTo(1)); var savedFakeClassInstance = fakeClasses.ElementAt(0); Assert.That(savedFakeClassInstance.Age, Is.EqualTo(fakeClassInstance.Age)); Assert.That(savedFakeClassInstance.Date, Is.EqualTo(fakeClassInstance.Date)); Assert.That(savedFakeClassInstance.Name, Is.EqualTo(fakeClassInstance.Name)); }
public void TestProcessOrder() { var fakeClass = new FakeClass(); fakeClass.SetProductionInfo(new ProductInfo { ProductId = 1, Price = 123 }, new ProductInfo { ProductId = 2, Price = 634 }, new ProductInfo { ProductId = 3, Price = 200 }, new ProductInfo { ProductId = 4, Price = 150 }); var processOrder = fakeClass.ProcessOrder(new PaymentInfo { UserId = 123, Detail = new List <PaymentDetail> { new PaymentDetail { ProdId = 1, Count = 2 }, new PaymentDetail { ProdId = 2, Count = 3 }, new PaymentDetail { ProdId = 4, Count = 1 } } }); new { UserId = 123, OrderAmount = 2298M }.ToExpectedObject().ShouldMatch(processOrder.order); new[] { new { ProductId = 1, Amount = 246M }, new { ProductId = 2, Amount = 1902M }, new { ProductId = 4, Amount = 150M }, }.ToExpectedObject().ShouldMatch(processOrder.orderDetailList); }
public NavigationViewModelTests() { _ExpectedNewViewModel = new FakeClass(); _ExpectedRedirectViewModel = new SecondFakeClass(); _ServiceLocator = Substitute.For <IServiceLocator>(); _ServiceLocator.GetInstance(_FakeType).Returns(_ExpectedNewViewModel); _ServiceLocator.GetInstance <FakeClass>().Returns(_ExpectedNewViewModel); _ServiceLocator.GetInstance(_FakeTypeRedirect).Returns(_ExpectedRedirectViewModel); _ServiceLocator.GetInstance(null).Throws(new ArgumentNullException("serviceType")); _RouterSolver = Substitute.For <IRouterSolver>(); _RouterSolver.SolveType(null).Throws <Exception>(); _RouterSolver.SolveRoute(Arg.Any <object>()).Returns(default(string)); _NavigationViewModel = new NavigationViewModel(new Lazy <IServiceLocator>(() => _ServiceLocator), _RouterSolver, _OriginalRoute); }
public void HasFieldsWithSameValueShouldProcessNullFields() { var instance1 = new FakeClass() { Items = new List <string>() }; var instance2 = new FakeClass(); Check.ThatCode(() => { Check.That(instance2).HasFieldsWithSameValues(instance1); // throws NullReferenceException Check.That(instance1).HasFieldsWithSameValues(instance2); // throws FluentCheckException throw new Exception("Checks should fail."); }).IsAFaillingCheck(); }
public void CreateProperty_MultipleProperties_AreReturned() { // arrange var settings = GetSettings("property1, property2"); var testObj = new FakeClass { Property1 = "prop1", Property2 = "prop2" }; // act var result = JsonConvert.SerializeObject(testObj, Formatting.None, settings); var reversed = JsonConvert.DeserializeObject <FakeClass>(result); // assert Assert.NotNull(reversed.Property1); Assert.NotNull(reversed.Property2); }
public void CreateProperty_SingleProperty_IsReturned() { // arrange var settings = GetSettings("property1"); var testObj = new FakeClass { Property1 = "prop1", Property2 = "prop2" }; // act var result = JsonConvert.SerializeObject(testObj, Formatting.None, settings); var reversed = JsonConvert.DeserializeObject <FakeClass>(result); // assert Assert.NotNull(reversed.Property1); Assert.Null(reversed.Property2); // should be null since it wasn't included in the original serialization }
public void WithConcreteObjectMapping_GivenTypeAndConcreteObjectMapping_ShouldAddMappingToContainer() { //---------------Set up test pack------------------- var fakeClass = new FakeClass(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var bootstrapper = StructuremapThuriaBootstrapper.Create() .WithConcreteObjectMapping(typeof(IFakeInterface), fakeClass) .Build(); //---------------Test Result ----------------------- var foundClass = bootstrapper.IocContainer.GetInstance <IFakeInterface>(); foundClass.Should().NotBeNull(); foundClass.Should().BeAssignableTo <IFakeInterface>(); foundClass.Should().BeAssignableTo <FakeClass>(); }
public void DeleteElement_With_ValidFakeClassValue_Returns_NewMinValue() { //Arrange var heap = new BinaryHeap <FakeClass>(fakeElements); var valueForChanged = fakeElements[0]; var newValue = new FakeClass() { Value = int.MinValue }; //Act heap.DecreaseKey(valueForChanged, newValue); var newMin = heap.GetMin; //Assert Assert.AreEqual(newValue, newMin); }
public void TestUpdateShouldSerializeMaybeField() { MaybeContractResolverWrapper testWrapper = new MaybeContractResolverWrapper(); JsonProperty property = new JsonProperty { PropertyType = typeof(Maybe <string>), PropertyName = nameof(FakeClass.Name) }; FakeClass fc = new FakeClass { Name = "test" }; Assert.IsNotNull(testWrapper.TestUpdateShouldSerialize(property)); Assert.IsTrue(property.ShouldSerialize(fc)); }
public void TestUpdateShouldSerializeMaybeProtectedField() { MaybeContractResolverWrapper testWrapper = new MaybeContractResolverWrapper(); JsonProperty property = new JsonProperty { PropertyType = typeof(Maybe <float>), PropertyName = "Price" }; FakeClass fc = new FakeClass { Name = "test" }; Assert.IsNotNull(testWrapper.TestUpdateShouldSerialize(property)); Assert.IsFalse(property.ShouldSerialize(fc)); }
public void InitializeShouldRegisterCustomFactories() { FakeClass fakeInstance = new FakeClass(); ITypeFactory factory = Substitute.For <ITypeFactory>(); factory.CanCreate(typeof(IFakeInterface)) .Returns(true); factory.Create(typeof(IFakeInterface), Arg.Any <IServiceProvider>()) .Returns(fakeInstance); this.bootstrapper.DiscoveryService.GetCustomFactories() .Returns(new[] { factory }); this.bootstrapper.Initialize(); object instance = this.bootstrapper.OriginalProvider.GetService(typeof(IFakeInterface)); Assert.That(instance, Is.SameAs(fakeInstance)); }
public void ShouldConstructTheObjectWithTheFactoryDelegate() { bool delegateCalled = false; FakeClass.ClearConstructorCount(); RouteMethod result = this.adapter.CreateMethod( () => { delegateCalled = true; return(new FakeClass()); }, typeof(FakeClass).GetMethod(nameof(FakeClass.MyMethod))); Assert.That(delegateCalled, Is.False); Assert.That(FakeClass.ConstructorCount.Value, Is.EqualTo(0)); result(null); Assert.That(delegateCalled, Is.True); Assert.That(FakeClass.ConstructorCount.Value, Is.EqualTo(1)); }
public void Get_Performance_Test_Stress() { var @object = new FakeClass(); var stopWatch = new Stopwatch(); stopWatch.Start(); var operations = 100000000; var propertyInfo = typeof(FakeClass).GetProperty("Available2", BindingFlags.Public | BindingFlags.Instance); var description = new PropertyInfoDescription(propertyInfo); var myTypeInstrospector = new PropertyAccessor(typeof(FakeClass), description, 0); for (var i = 0; i < operations; i++) { var res = myTypeInstrospector.Get(@object); } stopWatch.Stop(); var ts = stopWatch.ElapsedMilliseconds; _Output.WriteLine($"Perf: {operations* 1000/ts} operations per sec"); }
public void ShouldParseItens() { var itens = new List <FakeClass> { FakeClass.CreateItem(), FakeClass.CreateItem(true), FakeClass.CreateItem(), FakeClass.CreateItem(true, true), FakeClass.CreateItem(), FakeClass.CreateItem(false, true), }; var worksheet = new MyWorksheet(itens); var parser = new WorksheetInterpreter <FakeClass>(new ValueSetter(new Converter()), new MyWorksheetMap(), new MessageErrors()); var rowsFake = parser.Parse(worksheet); itens.ForEach(i => i.Bonus = i.Bonus * 0.1M); var validationResult = new ValidationResult <FakeClass>(); validationResult.AddItem(itens); rowsFake.Should().BeEquivalentTo(validationResult); }
public void ShouldCreateNewColumnsWithErrors() { var serviceCollection = new ServiceCollection(); serviceCollection.AddWorksheetParser <FakeClass>(x => x.WithParser <ClosedXmlParser <FakeClass> >().WithMap <MyWorksheetMap>()); var serviceProvider = serviceCollection.BuildServiceProvider(); var expectedItens = new List <FakeClass> { FakeClass.CreateItem(), FakeClass.CreateItem(false, false, false), FakeClass.CreateItem(false, false, true) }; var parser = serviceProvider.GetService <WorksheetParser <FakeClass> >(); expectedItens.ForEach(x => x.Bonus *= 0.1M); var validationResult = new ValidationResult <FakeClass>(); var error = new Error("Field TX_NAME can´t not be null", 3, 2); validationResult.AddError(error); validationResult.AddItem(expectedItens.First()); validationResult.AddItem(expectedItens.Last()); var headers = new MyWorksheetMap().GetFields().Select(s => s.Name).ToList(); using var worksheet = CreateStream(expectedItens, headers); var itens = parser.Parse(worksheet, worksheetName); using var streamWithErros = parser.WriteErrorsWithSummary(worksheet, worksheetName, itens.Errors); using var workbookWithErrors = new XLWorkbook(streamWithErros); var reader = new ClosedXmlReader(workbookWithErrors, worksheetName); reader.CountColumns().Should().Be(headers.Count() + 1); }
public void DomainEntityComparer_ComparedOnClassNotHandledByEqualsMethod_ThrowsException() { var fakeClassForTesting = new FakeClass(); var sut = new DomainEntityComparer(); sut.Equals(fakeClassForTesting, fakeClassForTesting); }