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);
}
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);
}
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();
}
