public static string Translate(this string translate, string defaultValue = "*NO TRANSLATION*") { var bundleClass = new DummyClass ().Class; var languageBundle = NSBundle.FromClass (bundleClass); var translatedString = languageBundle.LocalizedString(translate, defaultValue, "GMImagePicker"); return translatedString; }
public void SetUp() { _dummyClass = new DummyClass(); _dummyClass.PrivateField = _fooValue; _eventSink = new EventSink(); _invoker = new NuGenInvoker(_dummyClass); }
public void EndMemberAssignsInstanceToParentProperty() { var state = new StackingLinkedList<Level>(); var dummyClass = new DummyClass(); var xamlType = WiringContext.TypeContext.GetXamlType(dummyClass.GetType()); state.Push( new Level { Instance = dummyClass, XamlMember = xamlType.GetMember("Child"), }); var childClass = new ChildClass(); state.Push( new Level { XamlType = xamlType, Instance = childClass, }); var sut = new ObjectAssembler(state, WiringContext, new TopDownValueContext()); sut.Process(X.EndObject()); Assert.AreEqual(1, state.Count); var expectedInstance = state.CurrentValue.Instance; Assert.AreSame(expectedInstance, dummyClass); Assert.AreSame(((DummyClass)expectedInstance).Child, childClass); }
public void HasNotFieldsWithSameValuesWorks() { var x = new DummyClass(); Check.That(x).HasNotFieldsWithSameValues(new DummyClass(1, 2)); // check with missing fields Check.That(new DummyClass()).HasNotFieldsWithSameValues(new DummyHeritance(1,2)); }
public void HasFieldsNotEqualToThoseIsObsoleteButWorks() { var x = new DummyClass(); Check.That(x).HasFieldsNotEqualToThose(new DummyClass(1, 2)); // check with missing fields Check.That(new DummyClass()).HasFieldsNotEqualToThose(new DummyHeritance(1,2)); }
public IActionResult FormValueModelBinding_Enabled(DummyClass dc) { if (!ModelState.IsValid) { return BadRequest(ModelState); } return Ok("Data:" + dc?.SampleInt); }
public override void Setup() { base.Setup(); dummyClass = new DummyClass { Value = 1, Reference = "2" }; dummyStruct = new DummyStruct { Value = 3, Reference = "4" }; classValueWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyClass).GetField("Value")); classReferenceWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyClass).GetField("Reference")); structValueWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyStruct).GetField("Value")); structReferenceWrapper = ReflectionUtility.CreateFieldWrapper(typeof(DummyStruct).GetField("Reference")); }
public void IsEqualFailsIfFieldsDifferent() { var x = new DummyClass(); Check.ThatCode(() => { Check.That(x).HasFieldsWithSameValues(new DummyClass(1, 2)); }) .Throws<FluentCheckException>() .WithMessage(Environment.NewLine+ "The checked value's field 'x' does not have the expected value." + Environment.NewLine + "The checked value:" + Environment.NewLine + "\t[2]" + Environment.NewLine + "The expected value:" + Environment.NewLine + "\t[1]"); }
public void XmlSerializer_CachesSerializerForType() { // Arrange var input = new DummyClass { SampleInt = 10 }; var formatter = new TestXmlSerializerOutputFormatter(); var context = GetOutputFormatterContext(input, typeof(DummyClass)); // Act formatter.CanWriteResult(context, MediaTypeHeaderValue.Parse("application/xml")); formatter.CanWriteResult(context, MediaTypeHeaderValue.Parse("application/xml")); // Assert Assert.Equal(1, formatter.createSerializerCalledCount); }
public void LoadWithRootInstance() { var dummy = new DummyClass { AnotherProperty = "Other value", SampleProperty = "Will be overwritten" }; var loader = new XamlXmlLoader(new ObjectAssembler(WiringContext, new ObjectAssemblerSettings { RootInstance = dummy }), WiringContext); var actual = loader.Load("<DummyClass xmlns=\"root\" SampleProperty=\"Value\" />"); Assert.IsInstanceOfType(actual, dummy.GetType()); Assert.AreEqual(((DummyClass)actual).SampleProperty, "Value"); Assert.AreEqual(((DummyClass)actual).AnotherProperty, "Other value"); }
public void LoadWithRootInstance() { var dummy = new DummyClass { AnotherProperty = "Other value", SampleProperty = "Will be overwritten" }; var loader = new XamlLoader(new DummyXamlParserFactory(WiringContext)); var actual = loader.Load("<DummyClass xmlns=\"root\" SampleProperty=\"Value\" />", dummy); Assert.IsInstanceOfType(actual, dummy.GetType()); Assert.AreEqual("Value", ((DummyClass)actual).SampleProperty); Assert.AreEqual("Other value", ((DummyClass)actual).AnotherProperty); }
public void LoadWithRootInstance() { var dummy = new DummyClass { AnotherProperty = "Other value", SampleProperty = "Will be overwritten" }; var loader = new XmlLoader(new DummyParserFactory(RuntimeTypeSource)); var actual = loader.FromString("<DummyClass xmlns=\"root\" SampleProperty=\"Value\" />", dummy); Assert.IsType(dummy.GetType(), actual); Assert.Equal("Value", ((DummyClass)actual).SampleProperty); Assert.Equal("Other value", ((DummyClass)actual).AnotherProperty); }
public void GetAllPropertiesTest() { DummyClass dummyClass = new DummyClass(); PropertyInfo[] properties = EntitiyUtilities.GetAllProperties(dummyClass); Assert.AreEqual(3, properties.Count(), "The number of properties did not equal the expected amount."); bool isIntPropertyThere = properties.Any(i => i.Name == "SomeNumber"); Assert.IsTrue(isIntPropertyThere, "The value property (int) was not handled correctly."); bool isStringPropertyThere = properties.Any(i => i.Name == "SomeString"); Assert.IsTrue(isStringPropertyThere, "The reference property (string) was not handled correctly."); bool isComplexPropertyThere = properties.Any(i => i.Name == "SomeComplex"); Assert.IsTrue(isComplexPropertyThere, "The complex property (List<int>) was not handled correctly."); }
public static void SetValue() { try { // BOOl s_StaticBoolUser.value = false; s_StaticBoolProject.value = false; Assert.IsFalse((bool)s_StaticBoolUser); Assert.IsFalse((bool)s_StaticBoolProject); // STRING s_StaticStringUser.value = "Some more text"; s_StaticStringProject.value = "Some text here"; Assert.AreEqual("Some more text", (string)s_StaticStringUser); Assert.AreEqual("Some text here", (string)s_StaticStringProject); // STRUCT var userStruct = new DummyStruct("Changed text", 23); var projectStruct = new DummyStruct("Slightly different text", -9825); s_StaticStructUser.SetValue(userStruct); s_StaticStructProject.SetValue(projectStruct); Assert.AreEqual(userStruct, (DummyStruct)s_StaticStructUser); Assert.AreEqual(projectStruct, (DummyStruct)s_StaticStructProject); // CLASS var userClass = new DummyClass("Changed text", 23); var projectClass = new DummyClass("Slightly different text", -9825); s_StaticClassUser.SetValue(userClass); s_StaticClassProject.SetValue(projectClass); Assert.AreEqual(userClass, (DummyClass)s_StaticClassUser); Assert.AreEqual(projectClass, (DummyClass)s_StaticClassProject); } catch (Exception e) { Debug.LogError(e.ToString()); } }
public void XmlDataContractSerializer_CachesSerializerForType() { // Arrange var input = new DummyClass { SampleInt = 10 }; var formatter = new TestXmlDataContractSerializerOutputFormatter(); var context = GetOutputFormatterContext(input, typeof(DummyClass)); context.ContentType = new StringSegment("application/xml"); // Act formatter.CanWriteResult(context); formatter.CanWriteResult(context); // Assert Assert.Equal(1, formatter.createSerializerCalledCount); }
public void MPBase_ParsePath_ShouldReplaceParamInUrlWithValues() { MercadoPagoSDK.CleanConfiguration(); MercadoPagoSDK.AccessToken = "as987ge9ev6s5df4g32z1xv54654"; DummyClass dummy = new DummyClass { Id = 111, Email = "*****@*****.**", Address = "Evergreen123", MaritalStatus = "divorced", HasCreditCard = true }; try { string processedPath = ParsePath("https://api.mercadopago.com/v1/getpath/slug/:id/pUnexist/:unexist", null, dummy); } catch (Exception exception) { Assert.AreEqual("No argument supplied/found for method path", exception.Message); } string processedPath0 = ParsePath("/v1/getpath/slug", null, dummy); Assert.AreEqual("https://api.mercadopago.com/v1/getpath/slug?access_token=as987ge9ev6s5df4g32z1xv54654", processedPath0); string processedPath1 = ParsePath("/v1/putpath/slug/:id/pEmail/:email", null, dummy); Assert.AreEqual("https://api.mercadopago.com/v1/putpath/slug/111/pEmail/[email protected]?access_token=as987ge9ev6s5df4g32z1xv54654", processedPath1); string processedPath2 = ParsePath("/v1/putpath/slug/:id/pHasCreditCard/:hasCreditCard", null, dummy); Assert.AreEqual("https://api.mercadopago.com/v1/putpath/slug/111/pHasCreditCard/True?access_token=as987ge9ev6s5df4g32z1xv54654", processedPath2); string processedPath3 = ParsePath("/v1/putpath/slug/:id/pEmail/:email/pAddress/:address", null, dummy); Assert.AreEqual("https://api.mercadopago.com/v1/putpath/slug/111/pEmail/[email protected]/pAddress/Evergreen123?access_token=as987ge9ev6s5df4g32z1xv54654", processedPath3); string processedPath4 = ParsePath("/v1/putpath/slug/:id/pEmail/:email/pAddress/:address/pMaritalstatus/:maritalStatus/pHasCreditCard/:hasCreditCard", null, dummy); Assert.AreEqual("https://api.mercadopago.com/v1/putpath/slug/111/pEmail/[email protected]/pAddress/Evergreen123/pMaritalstatus/divorced/pHasCreditCard/True?access_token=as987ge9ev6s5df4g32z1xv54654", processedPath4); }
public void SingleOr_ItemNotFound_ReturnFallbackValue() { //Arrange var source = new[] { new DummyClass(1, "1"), new DummyClass(2, "2-1"), new DummyClass(2, "2-2"), new DummyClass(3, "3") }; var fallbackValue = new DummyClass(-1, "Fallback"); //Act var result = source.SingleOr(d => d.Id == -2, fallbackValue); //Assert result.Id.Should().Be(fallbackValue.Id); result.Name.Should().Be(fallbackValue.Name); }
public async Task WriteAsync_WritesWhenConfiguredWithRootName() { // Arrange var sampleInt = 10; var SubstituteRootName = "SomeOtherClass"; var SubstituteRootNamespace = "http://tempuri.org"; var InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance"; var expectedOutput = string.Format( "<{0} xmlns:i=\"{2}\" xmlns=\"{1}\"><SampleInt xmlns=\"\">{3}</SampleInt></{0}>", SubstituteRootName, SubstituteRootNamespace, InstanceNamespace, sampleInt); var sampleInput = new DummyClass { SampleInt = sampleInt }; var dictionary = new XmlDictionary(); var settings = new DataContractSerializerSettings { RootName = dictionary.Add(SubstituteRootName), RootNamespace = dictionary.Add(SubstituteRootNamespace) }; var formatter = new XmlDataContractSerializerOutputFormatter { SerializerSettings = settings }; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
public object ActionHandlesError([FromBody] DummyClass dummy) { if (!ActionContext.ModelState.IsValid) { var parameterBindingErrors = ActionContext.ModelState["dummy"].Errors; if (parameterBindingErrors.Count != 0) { return(new ErrorInfo { ActionName = "ActionHandlesError", ParameterName = "dummy", Errors = parameterBindingErrors.Select(x => x.ErrorMessage).ToList(), Source = "action" }); } } return(dummy); }
public void ShouldEvaluateArgs() { var dummyObject = new DummyClass { Hello = "World" }; var helloCommand = new Mock <IReplCommand>(); helloCommand.SetupGet(x => x.CommandName).Returns("hello"); var mocks = new Mocks { ReplCommands = new[] { helloCommand } }; mocks.ScriptEngine.Setup(x => x.Execute( "myObj", It.IsAny <string[]>(), It.IsAny <AssemblyReferences>(), It.IsAny <IEnumerable <string> >(), It.IsAny <ScriptPackSession>())) .Returns(new ScriptResult(returnValue: dummyObject)); mocks.ScriptEngine.Setup(x => x.Execute( "100", It.IsAny <string[]>(), It.IsAny <AssemblyReferences>(), It.IsAny <IEnumerable <string> >(), It.IsAny <ScriptPackSession>())) .Returns(new ScriptResult(returnValue: 100)); _repl = GetRepl(mocks); _repl.Execute(":hello 100 myObj", null); helloCommand.Verify( x => x.Execute( _repl, It.Is <object[]>(i => i[0].GetType() == typeof(int) && (int)i[0] == 100 && i[1].Equals(dummyObject))), Times.Once); }
public object ActionHandlesError([FromBody] DummyClass dummy) { if (!ModelState.IsValid) { // Body model binder normally reports errors for parameters using the empty name. var parameterBindingErrors = ModelState["dummy"]?.Errors ?? ModelState[string.Empty]?.Errors; if (parameterBindingErrors != null && parameterBindingErrors.Count != 0) { return(new ErrorInfo { ActionName = "ActionHandlesError", ParameterName = "dummy", Errors = parameterBindingErrors.Select(x => x.ErrorMessage).ToList(), Source = "action" }); } } return(dummy); }
public void SerializeExpressionTest() { var dummy = new DummyClass { Bar = "honk!", Baz = Color.Black, Foo = 5 }; var mapping = new YamlMappingNode(); var serializer = YamlObjectSerializer.NewWriter(mapping); serializer.DataField(dummy, d => d.Foo, "foo", 1); serializer.DataField(dummy, d => d.Bar, "bar", "*silence*"); serializer.DataField(dummy, d => d.Baz, "baz", Color.Black); Assert.That(mapping, Is.EquivalentTo(new YamlMappingNode { { "bar", "honk!" }, { "foo", "5" } })); }
public void GivenConfiguredInstance_StartMemberSetsTheMember() { var state = new StackingLinkedList<Level>(); var dummyClass = new DummyClass(); state.Push( new Level { Instance = dummyClass, }); var xamlMember = WiringContext.TypeContext.GetXamlType(dummyClass.GetType()).GetMember("Items"); var sut = new ObjectAssembler(state, WiringContext, new TopDownValueContext()); sut.Process(X.StartMember<DummyClass>(d => d.Items)); Assert.AreEqual(1, state.Count); Assert.AreEqual(state.CurrentValue.XamlMember, xamlMember); }
public void ItParsesMemberAccess() { Assert.AreEqual( "null", parser.Parse(() => JsonValue.Null).ToAql() ); var dummy = new DummyClass { foo = 42 }; Assert.AreEqual( "42", parser.Parse(() => dummy.foo).ToAql() ); Assert.AreEqual( "42", parser.Parse(() => dummy.Foo).ToAql() ); }
public async Task WriteAsync_WritesSimpleTypes() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlDataContractSerializerOutputFormatter(); var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert Assert.NotNull(outputFormatterContext.ActionContext.HttpContext.Response.Body); outputFormatterContext.ActionContext.HttpContext.Response.Body.Position = 0; XmlAssert.Equal("<DummyClass xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">" + "<SampleInt>10</SampleInt></DummyClass>", new StreamReader(outputFormatterContext.ActionContext.HttpContext.Response.Body, Encoding.UTF8) .ReadToEnd()); }
public static List<DummyClass> GenerateExpectedDummyObject(int rows) { var rtnVal = new List<DummyClass>(); for (var i = 1; i < rows + 1; i++) { var row = new DummyClass { PropertyInt = i, PropertyBool = (i % 2) == 1, PropertyLong = i, PropertyString = i.ToString(CultureInfo.InvariantCulture), PropertyFloat = i + 0.01F, PropertyDouble = i + 0.01D }; rtnVal.Add(row); } return rtnVal; }
public void TestObject_not_null() { var sw = new MemoryStream(); var writer = new BinaryWriter(sw); DummyClass a = new DummyClass() { v = 12 }; writer.WriteObject(a); var sr = new MemoryStream(sw.ToArray()); var reader = new BinaryReader(sr); DummyClass b = null; reader.ReadObject(out b); Assert.Equal(a, b, new DummyClass.Comparer()); }
public async Task TaskFactory_Should_Return_TaskFactory_Compatible_With_Proxy_Thread_SynchronizationContextFactory_Context() { //arrange var UIMessageLoop = new WPFThreadingHelper(); UIMessageLoop.Start().Wait(); var scf = UIMessageLoop.Dispatcher.Invoke(() => new SynchronizationContextFactory()); _Proxified = new DummyClass(); _Interface = scf.Build <IDummyInterface2>(_Proxified); //act var res = _ActorContext.GetTaskFactory(_Proxified); Thread tfthread = await res.StartNew(() => Thread.CurrentThread); //assert tfthread.Should().Be(UIMessageLoop.UIThread); UIMessageLoop.Stop(); }
public void HandlePropertyChangedEvents() { bool valueChanged = false; bool textChanged = false; DummyClass source = new DummyClass(); PropertyObserver <DummyClass> observer = new PropertyObserver <DummyClass>(source); observer.RegisterHandler("Value", src => valueChanged = true); observer.RegisterHandler(src => src.Text, src => textChanged = true); Assert.IsFalse(valueChanged); Assert.IsFalse(textChanged); source.Value = 10; Assert.IsTrue(valueChanged); Assert.IsFalse(textChanged); valueChanged = false; source.Text = "abc"; Assert.IsFalse(valueChanged); Assert.IsTrue(textChanged); textChanged = false; source.RaisePropertyChanged(); Assert.IsTrue(valueChanged); Assert.IsTrue(textChanged); valueChanged = false; textChanged = false; observer.UnregisterHandler("Value"); source.RaisePropertyChanged(); Assert.IsFalse(valueChanged); Assert.IsTrue(textChanged); textChanged = false; observer.UnregisterHandler(src => src.Text); source.RaisePropertyChanged(); Assert.IsFalse(valueChanged); Assert.IsFalse(textChanged); }
public void HandlePropertyChangedEvents() { bool valueChanged = false; bool textChanged = false; DummyClass source = new DummyClass(); PropertyObserver<DummyClass> observer = new PropertyObserver<DummyClass>(source); observer.RegisterHandler("Value", src => valueChanged = true); observer.RegisterHandler(src => src.Text, src => textChanged = true); Assert.IsFalse(valueChanged); Assert.IsFalse(textChanged); source.Value = 10; Assert.IsTrue(valueChanged); Assert.IsFalse(textChanged); valueChanged = false; source.Text = "abc"; Assert.IsFalse(valueChanged); Assert.IsTrue(textChanged); textChanged = false; source.RaisePropertyChanged(); Assert.IsTrue(valueChanged); Assert.IsTrue(textChanged); valueChanged = false; textChanged = false; observer.UnregisterHandler("Value"); source.RaisePropertyChanged(); Assert.IsFalse(valueChanged); Assert.IsTrue(textChanged); textChanged = false; observer.UnregisterHandler(src => src.Text); source.RaisePropertyChanged(); Assert.IsFalse(valueChanged); Assert.IsFalse(textChanged); }
public async Task XmlSerializer_CanModifyNamespacesInGeneratedXml() { // Arrange var input = new DummyClass { SampleInt = 10 }; var formatter = new IgnoreAmbientNamespacesXmlSerializerOutputFormatter(); var outputFormatterContext = GetOutputFormatterContext(input, input.GetType()); var expectedOutput = "<DummyClass><SampleInt>10</SampleInt></DummyClass>"; // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); Assert.Equal(expectedOutput, content); }
public void LineReaderNext() { var list = DummyClass.CreateListOfStrings(); var reader = list.ToLineReader(); Assert.AreEqual("Anders", reader.Current.Text); Assert.IsTrue(reader.HasMore); Assert.IsTrue(reader.Next()); Assert.AreEqual("Anders", reader.Current.Text); Assert.IsTrue(reader.HasMore); Assert.IsTrue(reader.Next()); Assert.AreEqual("Andres", reader.Current.Text); // ! not Anders, but Andres Assert.IsTrue(reader.HasMore); for (int i = 0; i < 5; i++) { reader.Next(); // Skip 5 elements } Assert.AreEqual("Bent Fabric", reader.Current.Text); }
public async Task UpsertReadAsyncDelete_AreThreadSafe() { // Arrange var dummyOptions = new MixedStorageKVStoreOptions() { LogDirectory = _fixture.TempDirectory, LogFileNamePrefix = nameof(UpsertReadAsyncDelete_AreThreadSafe), PageSizeBits = 12, MemorySizeBits = 13 // Limit to 8KB so we're testing both in-memory and disk-based operations }; DummyClass dummyClassInstance = CreatePopulatedDummyClassInstance(); int numRecords = 10000; //using var testSubject = new ObjLogMixedStorageKVStore<int, DummyClass>(dummyOptions); //using var testSubject = new MemoryMixedStorageKVStore<int, DummyClass>(dummyOptions); using var testSubject = new MixedStorageKVStore <int, DummyClass>(dummyOptions); // Act and assert // Insert Parallel.For(0, numRecords, key => testSubject.Upsert(key, dummyClassInstance)); // Read await ReadAndVerifyValuesAsync(numRecords, testSubject, Status.OK, dummyClassInstance).ConfigureAwait(false); // Update dummyClassInstance.DummyInt = 20; dummyClassInstance.DummyString = "anotherDummyString"; Parallel.For(0, numRecords, key => testSubject.Upsert(key, dummyClassInstance)); // Verify updates await ReadAndVerifyValuesAsync(numRecords, testSubject, Status.OK, dummyClassInstance).ConfigureAwait(false); // Delete Parallel.For(0, numRecords, key => testSubject.Delete(key)); // Verify deletes await ReadAndVerifyValuesAsync(numRecords, testSubject, Status.NOTFOUND, null).ConfigureAwait(false); }
public async Task XmlSerializerOutputFormatterWritesSimpleTypes() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlSerializerOutputFormatter( XmlOutputFormatter.GetDefaultXmlWriterSettings()); var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert Assert.NotNull(outputFormatterContext.ActionContext.HttpContext.Response.Body); outputFormatterContext.ActionContext.HttpContext.Response.Body.Position = 0; Assert.Equal("<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SampleInt>10</SampleInt></DummyClass>", new StreamReader(outputFormatterContext.ActionContext.HttpContext.Response.Body, Encoding.UTF8) .ReadToEnd()); Assert.True(outputFormatterContext.ActionContext.HttpContext.Response.Body.CanRead); }
public void Test_ObjectDebugString() { Trace.WriteLine(Configuration.GetGenericHeader()); DummyDataManager dtm = new DummyDataManager(Configuration.DummyDataXmlPath); DummyUser user = dtm.GetDummy(); Trace.WriteLine(DebugUtility.GetObjectString(user)); DummyClass c = new DummyClass() { Names = new List <string>() { "Huey", "Dewey", "Louie" }, Name = "Duckburg" }; Trace.WriteLine(DebugUtility.GetObjectString(c)); Trace.WriteLine(Configuration.GetGenericFooter()); }
public void DefaultJsPropertyConverterSimpleConversion() { var dummy = new DummyClass { Field = "IsField", IAmAProperty = "IsProp" }; var propInfo = typeof(DummyClass).GetProperty(nameof(DummyClass.IAmAProperty)); var orgValue = propInfo.GetValue(dummy); var expectedPropName = "iAmAProperty"; var expectedValue = $"\"{dummy.IAmAProperty}\""; var converter = new JsPropertyConverter(propInfo, orgValue, new List <string>(), new List <string>()); var jsProp = converter.Convert(); Assert.Same(orgValue, jsProp.OriginalValue); Assert.Same(propInfo, jsProp.PropertyInfo); Assert.Equal(expectedPropName, jsProp.Name); Assert.Equal(JsPropertyType.Plain, jsProp.PropertyType); Assert.Equal(expectedValue, jsProp.Value); }
public static void Main() { IList <Type> loadableTypes; // instance the dummy class used to find the current assembly DummyClass dc = new DummyClass(); loadableTypes = GetClassesImplementingAnInterface(dc.GetType().Assembly, typeof(IMsgXX)).Item2; foreach (var item in loadableTypes) { Console.WriteLine("1: " + item); } // print // 1: Start2.MessageHandlerXY loadableTypes = GetClassesImplementingAnInterface(dc.GetType().Assembly, typeof(IHandleMessageG <>)).Item2; foreach (var item in loadableTypes) { Console.WriteLine("2: " + item); } // print // 2: Start2.MessageHandlerXY // 2: Start2.MessageHandlerZZ }
public void SourceIsWeakReference() { bool valueChanged = false; bool textChanged = false; DummyClass source = new DummyClass(); PropertyObserver <DummyClass> observer = new PropertyObserver <DummyClass>(source); observer.RegisterHandler("Value", src => valueChanged = true); observer.RegisterHandler(src => src.Text, src => textChanged = true); source.RaisePropertyChanged(); Assert.IsTrue(valueChanged); Assert.IsTrue(textChanged); Assert.IsFalse(_dummyClassFinalized); source = null; GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Assert.IsTrue(_dummyClassFinalized); observer.UnregisterHandler("Value"); observer.UnregisterHandler(src => src.Text); }
public void GivenConfiguredInstance_StartMemberSetsTheMember() { var state = new StackingLinkedList <Level>(); var dummyClass = new DummyClass(); var xamlType = WiringContext.TypeContext.GetXamlType(dummyClass.GetType()); state.Push( new Level { Instance = dummyClass, XamlType = xamlType, }); var xamlMember = xamlType.GetMember("Items"); var sut = new ObjectAssembler(state, WiringContext, new TopDownValueContext()); sut.Process(X.StartMember <DummyClass>(d => d.Items)); Assert.AreEqual(1, state.Count); Assert.AreEqual(state.CurrentValue.XamlMember, xamlMember); }
public void GivenConfiguredInstance_StartMemberSetsTheMember() { var state = new StackingLinkedList<Level>(); var dummyClass = new DummyClass(); var xamlType = TypeRuntimeTypeSource.GetByType(dummyClass.GetType()); state.Push( new Level { Instance = dummyClass, XamlType = xamlType, }); var xamlMember = xamlType.GetMember("Items"); var sut = new ObjectAssembler(state, TypeRuntimeTypeSource, new TopDownValueContext(), new NullLifecycleListener()); sut.Process(X.StartMember<DummyClass>(d => d.Items)); Assert.AreEqual(1, state.Count); Assert.AreEqual(state.CurrentValue.Member, xamlMember); }
public void ThrowArgumentExceptionWithParamNameWhenClassValueNotGreaterOrEqualThanExpected() { DummyClass value1a = new DummyClass() { Id = 1 }; DummyClass value1b = new DummyClass() { Id = 1 }; DummyClass value2 = new DummyClass() { Id = 2 }; Action action = () => Check.GreaterOrEqualThan(value1a, value1b, "arg"); action.Should().NotThrow <ArgumentException>(); action = () => Check.GreaterOrEqualThan(value1a, value2, "arg"); action.Should().Throw <ArgumentException>() .And.ParamName.Should().Be("arg"); }
public void DummyClassMethod_Update_CheckUri() { ResetConfiguration(); DummyClass resource = new DummyClass { Address = "Evergreen 123", Email = "*****@*****.**" }; DummyClass result; try { result = resource.Update(); } catch (Exception) { Assert.Fail(); return; } Assert.AreEqual("PUT", result.GetLastApiResponse().HttpMethod); Assert.AreEqual($"https://httpbin.org/post?access_token={Environment.GetEnvironmentVariable("ACCESS_TOKEN")}", result.GetLastApiResponse().Url); }
public void DummyClassMethod_SeveralRequestsMustBeCached() { ResetConfiguration(); Random random = new Random(); string id1 = (random.Next(0, int.MaxValue) - 5).ToString(); string id2 = (random.Next(0, int.MaxValue) - 88).ToString(); string id3 = (random.Next(0, int.MaxValue) - 9).ToString(); DummyClass firstResult = FindById(id1, true); DummyClass secondResult = DummyClass.FindById(id2, true); DummyClass thirdResult = DummyClass.FindById(id3, true); Thread.Sleep(1000); DummyClass firstCachedResult = DummyClass.FindById(id1, true); DummyClass secondCachedResult = DummyClass.FindById(id2, true); DummyClass thirdCachedResult = DummyClass.FindById(id3, true); Assert.IsTrue(firstCachedResult.GetLastApiResponse().IsFromCache); Assert.IsTrue(secondCachedResult.GetLastApiResponse().IsFromCache); Assert.IsTrue(thirdCachedResult.GetLastApiResponse().IsFromCache); }
public void LineReaderPeakAndFlush() { var list = DummyClass.CreateListOfStrings(); var reader = list.ToLineReader(); Assert.AreEqual("Anders", reader.Current.Text); Assert.IsTrue(reader.HasMore); Assert.IsTrue(reader.Next()); Assert.IsTrue(reader.Next()); Assert.AreEqual("Andres", reader.Current.Text); var peaker = reader.Peak(); Assert.AreEqual("Andres", reader.Current.Text); // Still at the same element. var nollerik = peaker.FirstOrDefault(e => e.Text.Equals("Bent Nollerik")); Assert.AreEqual("Bent Nollerik", nollerik.Text); reader.Flush(nollerik); Assert.AreEqual("Bent Nollerik", reader.Current.Text); // New current element. }
public async Task LogCompaction_SkippedIfSafeReadOnlyRegionIsLessThanThreshold() { // Arrange var resultStringBuilder = new StringBuilder(); ILogger <MixedStorageKVStore <int, DummyClass> > dummyLogger = CreateLogger <int, DummyClass>(resultStringBuilder, LogLevel.Trace); var logSettings = new LogSettings { LogDevice = Devices.CreateLogDevice(Path.Combine(_fixture.TempDirectory, $"{nameof(LogCompaction_SkippedIfSafeReadOnlyRegionIsLessThanThreshold)}.log"), deleteOnClose: true), PageSizeBits = 12, MemorySizeBits = 13 }; DummyClass dummyClassInstance = CreatePopulatedDummyClassInstance(); int dummyThreshold = 100_000; var dummyOptions = new MixedStorageKVStoreOptions() { TimeBetweenLogCompactionsMS = 1, InitialLogCompactionThresholdBytes = 100_000 }; int expectedResultMinLength = string.Format(Strings.LogTrace_SkippingLogCompaction, 0, dummyThreshold).Length; // Act using (var testSubject = new MixedStorageKVStore <int, DummyClass>(dummyOptions, dummyLogger)) // Start log compaction { while (resultStringBuilder.Length <= expectedResultMinLength) { await Task.Delay(10).ConfigureAwait(false); } } // Assert string result = resultStringBuilder.ToString(); int numLines = result.Split("\n", StringSplitOptions.RemoveEmptyEntries).Length; string regexPattern = string.Format(Strings.LogTrace_SkippingLogCompaction, "0", dummyThreshold); // MixedStorageKVStore is empty Assert.Equal(numLines, Regex.Matches(result, regexPattern).Count); }
private void Initialize() { tbsm = new TaskBasedStateMachine <MyParam>(); tbsm.OnErrorOccurs += Tbsm_OnErrorOccurs; tbsm.OnTaskCourseAborted += Tbsm_OnTaskCourseAborted; // Initialize classes DummyClass A = new DummyClass(this, "A", 0); DummyClass B = new DummyClass(this, "B", 0); DummyClass C = new DummyClass(this, "C", 5); DummyClass D = new DummyClass(this, "D", 0); DummyClass E = new DummyClass(this, "E", 4); DummyClass F = new DummyClass(this, "F", 0); DummyClass G = new DummyClass(this, "G", 0); DummyClass H = new DummyClass(this, "H", 0); DummyClass I = new DummyClass(this, "I", 0); DummyClass J = new DummyClass(this, "J", 0); DummyClass K = new DummyClass(this, "K", 0); DummyClass L = new DummyClass(this, "L", 0); // Setup tasks tbsm.SetupTasks(new List <(string, Func <MyParam, MyParam>)> { (nameof(A), A.Dummy), (nameof(B), B.Dummy), (nameof(C), C.DummyWithConditions), (nameof(D), D.Dummy), (nameof(E), E.DummyWithConditions), (nameof(F), F.DummyWithUnhandledException), (nameof(G), G.Dummy), (nameof(H), H.Dummy), (nameof(I), I.Dummy), (nameof(J), J.Dummy), (nameof(K), K.DummyWithHandledException), (nameof(L), K.DummyWithAnotherHandledException), (nameof(HandledExceptionTask), HandledExceptionTask), (nameof(AnotherHandledExceptionTask), AnotherHandledExceptionTask) });
public async Task XmlSerializerOutputFormatterWritesUTF16Output() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType(), "application/xml; charset=utf-16"); var formatter = new XmlSerializerOutputFormatter(); formatter.WriterSettings.OmitXmlDeclaration = false; // Act await formatter.WriteAsync(outputFormatterContext); // Assert Assert.NotNull(outputFormatterContext.ActionContext.HttpContext.Response.Body); outputFormatterContext.ActionContext.HttpContext.Response.Body.Position = 0; Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + "<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SampleInt>10</SampleInt></DummyClass>", new StreamReader(outputFormatterContext.ActionContext.HttpContext.Response.Body, Encodings.UTF16EncodingLittleEndian).ReadToEnd()); }
public async Task WriteAsync_WritesIndentedOutput() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlDataContractSerializerOutputFormatter(); formatter.WriterSettings.Indent = true; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert Assert.NotNull(outputFormatterContext.ActionContext.HttpContext.Response.Body); outputFormatterContext.ActionContext.HttpContext.Response.Body.Position = 0; var outputString = new StreamReader(outputFormatterContext.ActionContext.HttpContext.Response.Body, Encoding.UTF8).ReadToEnd(); XmlAssert.Equal("<DummyClass xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">" + "\r\n <SampleInt>10</SampleInt>\r\n</DummyClass>", outputString); }
public async Task WriteAsync_WritesSimpleTypes() { // Arrange var expectedOutput = "<DummyClass xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">" + "<SampleInt>10</SampleInt></DummyClass>"; var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlDataContractSerializerOutputFormatter(); var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
public void ShouldPrintTheReturnToConsoleIfCommandHasReturnValue() { object returnValue = new DummyClass { Hello = "World" }; var helloCommand = new Mock<IReplCommand>(); helloCommand.SetupGet(x => x.CommandName).Returns("hello"); helloCommand.Setup(x => x.Execute(It.IsAny<IRepl>(), It.IsAny<object[]>())) .Returns(returnValue); var mocks = new Mocks { ReplCommands = new[] { helloCommand } }; mocks.ObjectSerializer.Setup(x => x.Serialize(returnValue)).Returns("hello world"); _repl = GetRepl(mocks); _repl.Execute(":hello", null); mocks.ObjectSerializer.Verify(x => x.Serialize(returnValue), Times.Once); mocks.Console.Verify(x => x.WriteLine("hello world"), Times.Once); }
public void ShouldEvaluateArgs() { var dummyObject = new DummyClass { Hello = "World" }; var helloCommand = new Mock<IReplCommand>(); helloCommand.SetupGet(x => x.CommandName).Returns("hello"); var mocks = new Mocks { ReplCommands = new[] { helloCommand } }; mocks.ScriptEngine.Setup(x => x.Execute( "myObj", It.IsAny<string[]>(), It.IsAny<AssemblyReferences>(), It.IsAny<IEnumerable<string>>(), It.IsAny<ScriptPackSession>())) .Returns(new ScriptResult(returnValue: dummyObject)); mocks.ScriptEngine.Setup(x => x.Execute( "100", It.IsAny<string[]>(), It.IsAny<AssemblyReferences>(), It.IsAny<IEnumerable<string>>(), It.IsAny<ScriptPackSession>())) .Returns(new ScriptResult(returnValue: 100)); _repl = GetRepl(mocks); _repl.Execute(":hello 100 myObj", null); helloCommand.Verify( x => x.Execute( _repl, It.Is<object[]>(i => i[0].GetType() == typeof(int) && (int)i[0] == 100 && i[1].Equals(dummyObject))), Times.Once); }
public async Task XmlSerializerOutputFormatterDoesntFlushOutputStream() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlSerializerOutputFormatter(); var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); var response = outputFormatterContext.HttpContext.Response; response.Body = FlushReportingStream.GetThrowingStream(); // Act & Assert await formatter.WriteAsync(outputFormatterContext); }
/// <summary> /// Example of a method. /// </summary> /// <param name="param">The parameter.</param> /// <returns> Returns an oject of <see cref="System.ComponentModel.AttributeCollection"/></returns> public System.ComponentModel.AttributeCollection Example(DummyClass param) { return null; }
public async Task XmlSerializerOutputFormatterWritesIndentedOutput() { // Arrange var expectedOutput = "<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\r\n <SampleInt>10</SampleInt>\r\n</DummyClass>"; var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlSerializerOutputFormatter(); formatter.WriterSettings.Indent = true; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
public async Task VerifyBodyIsNotClosedAfterOutputIsWritten() { // Arrange var sampleInput = new DummyClass { SampleInt = 10 }; var formatter = new XmlSerializerOutputFormatter(); var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); // Act await formatter.WriteAsync(outputFormatterContext); // Assert Assert.NotNull(outputFormatterContext.HttpContext.Response.Body); Assert.True(outputFormatterContext.HttpContext.Response.Body.CanRead); }
public async Task XmlSerializerOutputFormatterWritesUTF16Output() { // Arrange var expectedOutput = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + "<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SampleInt>10</SampleInt></DummyClass>"; var sampleInput = new DummyClass { SampleInt = 10 }; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType(), "application/xml; charset=utf-16"); var formatter = new XmlSerializerOutputFormatter(); formatter.WriterSettings.OmitXmlDeclaration = false; // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader( body, new UnicodeEncoding(bigEndian: false, byteOrderMark: false, throwOnInvalidBytes: true)).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
public async Task XmlSerializerOutputFormatterWritesOnModifiedWriterSettings() { // Arrange var expectedOutput = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SampleInt>10</SampleInt></DummyClass>"; var sampleInput = new DummyClass { SampleInt = 10 }; var outputFormatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); var formatter = new XmlSerializerOutputFormatter( new System.Xml.XmlWriterSettings { OmitXmlDeclaration = false, CloseOutput = false }); // Act await formatter.WriteAsync(outputFormatterContext); // Assert var body = outputFormatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
public async Task SuppliedWriterSettings_TakeAffect() { // Arrange var writerSettings = FormattingUtilities.GetDefaultXmlWriterSettings(); writerSettings.OmitXmlDeclaration = false; var sampleInput = new DummyClass { SampleInt = 10 }; var formatterContext = GetOutputFormatterContext(sampleInput, sampleInput.GetType()); var formatter = new XmlSerializerOutputFormatter(writerSettings); var expectedOutput = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<DummyClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SampleInt>10</SampleInt></DummyClass>"; // Act await formatter.WriteAsync(formatterContext); // Assert var body = formatterContext.HttpContext.Response.Body; body.Position = 0; var content = new StreamReader(body).ReadToEnd(); XmlAssert.Equal(expectedOutput, content); }
double memAccess(int numRuns, int size, int testType) { char[] charArray = new char[size]; DummyClass dummyO = new DummyClass(); //dummy_object startTime(); switch (testType) { case ARRAY: for (int i = 0; i < numRuns; ++i) { for (int k = 0; k < size - 1; ++k) { charArray[k] = charArray[k + 1]; } } break; case VECTOR_ADD: for(int i = 0; i < numRuns; ++i) { mIntVec.Clear(); for(int k = 0; k < size; ++k) { mIntVec.Add(k); } } break; case VECTOR_ACCESS: for (int i = 0; i < numRuns; ++i) { for (int k = 0; k < size-1; ++k) //-1 otherwise oob { mIntVec[k] = mIntVec[k + 1]; } } break; case DUMMY_ACCESS: for (int i = 0; i < numRuns; ++i) { for (int k = 0; k < size; ++k) { dummyO.a = k; dummyO.b = dummyO.c; dummyO.c = i; } } break; } return elapsedTime(); }