public void ObservableSelect_ChangeItemsTest()
{
var collection = new ObservableCollection<TestObject>();
var values = collection.ObservableSelect(item => item.Value);
var receivedEvents = new ObservableIndexer<NotifyCollectionChangedAction, int>(_ => 0);
var expectedValues = new[] { 2, 3, 4 };
var expectedEvents = new[] { KeyValuePair(NotifyCollectionChangedAction.Replace, 3) };
var testObject1 = new TestObject { Value = 1 };
var testObject2 = new TestObject { Value = 2 };
var testObject3 = new TestObject { Value = 3 };
NotifyCollectionChangedEventHandler collectionChangedEventHandler = (sender, e) =>
{
receivedEvents[e.Action] += 1;
};
collection.AddRange(testObject1, testObject2, testObject3);
values.CollectionChanged += collectionChangedEventHandler;
foreach (var item in collection)
{
item.Value += 1;
}
Assert.IsTrue(receivedEvents.SequenceEqual(expectedEvents));
Assert.IsTrue(values.SequenceEqual(expectedValues));
}
public void TestSetObjectPropsPrimitives()
{
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.Put("intValue", 1);
jobDataMap.Put("longValue", 2L);
jobDataMap.Put("floatValue", 3.0f);
jobDataMap.Put("doubleValue", 4.0);
jobDataMap.Put("booleanValue", true);
jobDataMap.Put("shortValue", 5);
jobDataMap.Put("charValue", 'a');
jobDataMap.Put("byteValue", 6);
jobDataMap.Put("stringValue", "S1");
Dictionary<string, string> map = new Dictionary<string, string>();
map.Add("A", "B");
jobDataMap.Put("mapValue", map);
TestObject myObject = new TestObject();
factory.SetObjectProperties(myObject, jobDataMap);
Assert.AreEqual(1, myObject.IntValue);
Assert.AreEqual(2, myObject.LongValue);
Assert.AreEqual(3.0f, myObject.FloatValue);
Assert.AreEqual(4.0, myObject.DoubleValue);
Assert.IsTrue(myObject.BooleanValue);
Assert.AreEqual(5, myObject.ShortValue);
Assert.AreEqual('a', myObject.CharValue);
Assert.AreEqual((byte) 6, myObject.ByteValue);
Assert.AreEqual("S1", myObject.StringValue);
Assert.IsTrue(myObject.MapValue.ContainsKey("A"));
}
public void Complex_Specification_Should_Eval_ToTrue()
{
var testObject = new TestObject { FirstName = "John", LastName = "Doe", Age = 20 };
var testSpec = new Specification<TestObject>(x => x.Age < 30) &
new Specification<TestObject>(x => x.FirstName.StartsWith("J"));
Assert.That(testSpec.IsSatisfiedBy(testObject));
}
public TestException(TestObject obj, string domain, string url, string message)
: base(message)
{
this._obj = obj;
this._url = url;
this._domain = domain;
}
public override void setUp()
{
base.setUp();
_toLoad = new List<TestObject>();
var br = new StreamReader("Resources/all_packed_objects.txt", Constants.CHARSET);
try
{
string line;
while ((line = br.ReadLine()) != null)
{
string[] parts = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var testObject = new TestObject
{
Id = ObjectId.FromString(parts[0]),
Type = parts[1],
RawSize = Convert.ToInt32(parts[2]),
Size = Convert.ToInt64(parts[3]),
Offset = Convert.ToInt64(parts[4])
};
_toLoad.Add(testObject);
}
}
finally
{
br.Close();
}
Assert.AreEqual(96, _toLoad.Count);
}
public bool ParseTestObject(string line, out object obj)
{
string[] s = line.Split(',');
if (s.Length != 2)
{
obj = null;
return false;
}
int x;
if (!int.TryParse(s[0], out x))
{
obj = null;
return false;
}
int y;
if (!int.TryParse(s[1], out y))
{
obj = null;
return false;
}
TestObject result = new TestObject();
result.x = x;
result.y = y;
obj = result;
return true;
}
public void TestObjectReferenceUpdate()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject { Name = "Test" };
var container = new ObjectContainer { Instance = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
var memberNode = containerNode.Children.First();
var instanceNode = memberNode.Content.Reference.AsObject.TargetNode;
// Update to a new instance
var newInstance = new TestObject { Name = "Test2" };
memberNode.Content.Update(newInstance);
Helper.TestMemberContentNode(containerNode, memberNode, container, newInstance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstance, false);
var newInstanceNode = nodeContainer.GetNode(newInstance);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstanceNode, newInstance);
Assert.AreNotEqual(instanceNode.Guid, newInstanceNode.Guid);
// Update to null
memberNode.Content.Update(null);
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
// Update back to the initial instance
memberNode.Content.Update(instance);
Helper.TestMemberContentNode(containerNode, memberNode, container, instance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instanceNode, instance);
}
public void SunnyDay()
{
TestObject dude = new TestObject("Rick Evans", 30);
IObjectFactory objectFactory = mocks.StrictMock<IObjectFactory>();
const string lookupObjectName = "rick";
Expect.Call(objectFactory.GetObject(lookupObjectName)).Return(dude).Repeat.Twice();
ObjectFactoryCreatingFactoryObject factory = new ObjectFactoryCreatingFactoryObject();
factory.ObjectFactory = objectFactory;
factory.TargetObjectName = lookupObjectName;
factory.AfterPropertiesSet();
mocks.ReplayAll();
IGenericObjectFactory gof = (IGenericObjectFactory) factory.GetObject();
IGenericObjectFactory gofOther = (IGenericObjectFactory) factory.GetObject();
Assert.IsTrue(Object.ReferenceEquals(gof, gofOther),
"Not returning a shared instance (Singleton = true).");
TestObject one = (TestObject) gof.GetObject();
Assert.IsNotNull(one, "Must never return null (IFactoryObject contract).");
TestObject two = (TestObject) gof.GetObject();
Assert.IsNotNull(two, "Must never return null (IFactoryObject contract).");
Assert.IsTrue(Object.ReferenceEquals(one, two),
"Not returning the same instance.");
mocks.VerifyAll();
}
public void PrototypeModeWithSingletonTarget()
{
TestObject dude = new TestObject("Rick Evans", 30);
IObjectFactory objectFactory = mocks.StrictMock<IObjectFactory>();
const string lookupObjectName = "rick";
Expect.Call(objectFactory.GetObject(lookupObjectName)).Return(dude).Repeat.Twice();
ObjectFactoryCreatingFactoryObject factory = new ObjectFactoryCreatingFactoryObject();
factory.ObjectFactory = objectFactory;
factory.TargetObjectName = lookupObjectName;
factory.IsSingleton = false;
factory.AfterPropertiesSet();
mocks.ReplayAll();
IGenericObjectFactory gofOne = (IGenericObjectFactory) factory.GetObject();
IGenericObjectFactory gofTwo = (IGenericObjectFactory) factory.GetObject();
Assert.IsFalse(Object.ReferenceEquals(gofOne, gofTwo),
"Not returning distinct instances (Prototype = true).");
TestObject one = (TestObject) gofOne.GetObject();
Assert.IsNotNull(one, "Must never return null (IFactoryObject contract).");
TestObject two = (TestObject) gofTwo.GetObject();
Assert.IsNotNull(two, "Must never return null (IFactoryObject contract).");
Assert.IsTrue(Object.ReferenceEquals(one, two),
"Not returning the same instance to singleton object.");
mocks.VerifyAll();
}
public void ThenDoublesCanBeResolvedCorrectly(double value, bool expected)
{
var input = new TestObject { Double = value };
var filter = TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.Equal, 5.5);
var query = new TableQuery<TestObject>().Where(filter);
Assert.That(query.Validate(input), Is.EqualTo(expected));
}
public void ObservePathChanged()
{
var obj = new ContainerObject();
string value = "error";
obj.ObserveProperty(x => x.Test.StringProperty).Subscribe(x => value = x);
Assert.IsNull(value);
var test = new TestObject();
obj.Test = test;
Assert.IsNull(value);
obj.Test.StringProperty = "foo";
Assert.AreEqual("foo", value);
value = "error";
obj.Test = null;
value = "pass";
test.StringProperty = "bar";
Assert.AreEqual("pass", value);
obj.Test = test;
Assert.AreEqual("bar", value);
}
public void CreateInstanceScopedKeyString()
{
TestObject testObject = new TestObject();
string typeScopedKey = UniqueKey.GetInstanceScopedString(testObject, "PartialKey");
string expectedKey = string.Format("{0}[{1}].{2}", typeof(TestObject).FullName, testObject.GetHashCode(), "PartialKey");
Assert.AreEqual(expectedKey, typeScopedKey);
}
public void ThenDateTimesCanBeResolvedCorrectly(string value, bool expected)
{
var input = new TestObject { DateTime = DateTimeOffset.Parse(value) };
var filter = TableQuery.GenerateFilterConditionForDate("DateTime", QueryComparisons.Equal, new DateTimeOffset(new DateTime(2015, 01, 03)));
var query = new TableQuery<TestObject>().Where(filter);
Assert.That(query.Validate(input), Is.EqualTo(expected));
}
public void ThenStringsCanBeResolvedCorrectly(string value, bool expected)
{
var input = new TestObject { String = value };
var filter = TableQuery.GenerateFilterCondition("String", QueryComparisons.Equal, "Test");
var query = new TableQuery<TestObject>().Where(filter);
Assert.That(query.Validate(input), Is.EqualTo(expected));
}
public void SetupEvaluator()
{
_conditionEvaluator = new ConditionEvaluatorIronPython();
_runtimeMock = new Mock<IWorkflowRuntime>();
var testObject1 = new TestObject
{
Bool = true,
Number = 1,
Str = "A"
};
var testObject2 = new TestObject
{
Bool = false,
Number = 2,
Str = "B"
};
_runtimeMock.Setup(m => m.Input).Returns(testObject1);
_runtimeMock.Setup(m => m.ProviderResults).Returns(new[]
{
new ProviderRuntimeResult
{
ProviderName = "Provider1",
Result = testObject2,
ProviderStatus = EWorkflowProviderRuntimeStatus.Success
}
});
}
public void ThenBooleansCanBeResolvedCorrectly(bool value, bool expected)
{
var input = new TestObject { Bool = value };
var filter = TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, true);
var query = new TableQuery<TestObject>().Where(filter);
Assert.That(query.Validate(input), Is.EqualTo(expected));
}
public ExtensibleObjectTestCommon()
{
_obj = new TestObject();
_dObj = _obj;
_dObj.Test1 = "TestValue";
_dObj.Test2 = null;
}
public void WhenDependencyPropertyChangesValueChangedIsRaised()
{
// Arrange.
const string OldValue = "Old Value";
const string NewValue = "New Value";
var source = new TestObject { Text = OldValue };
var callCount = 0;
DependencyPropertyValueChangedEventArgs args = null;
var listener = DependencyPropertyChangedListener.Create(source, "Text");
listener.ValueChanged += (sender, e) =>
{
++callCount;
args = e;
};
// Act.
source.Text = NewValue;
// Assert.
Assert.AreEqual(1, callCount);
Assert.IsNotNull(args);
Assert.AreEqual(OldValue, args.OldValue);
Assert.AreEqual(NewValue, args.NewValue);
// Argument validation.
TestsHelper.VerifyThrow<ArgumentNullException>(() => DependencyPropertyChangedListener.Create(null, "Text"));
TestsHelper.VerifyThrow<ArgumentException>(() => DependencyPropertyChangedListener.Create(source, string.Empty));
}
public void RegularChange()
{
TestObject[] obj = new TestObject[]
{
new TestObject { Foo = 42, Bar = "Hello" },
new TestObject { Foo = 10, Bar = "World" },
new TestObject { Foo = 0, Bar = "Not" }
};
ObjectPropertyChangedEventArgs args = new ObjectPropertyChangedEventArgs(
new ObjectSelection(obj.Take(2)),
new PropertyInfo[] { TestObject.FooProperty });
Assert.IsTrue(args.HasObject(obj[0]));
Assert.IsTrue(args.HasObject(obj[1]));
Assert.IsFalse(args.HasObject(obj[2]));
Assert.IsTrue(args.HasAnyObject(obj));
Assert.IsTrue(args.HasAnyObject(obj.Skip(1)));
Assert.IsFalse(args.HasAnyObject(obj.Skip(2)));
Assert.IsTrue(args.HasProperty(TestObject.FooProperty));
Assert.IsFalse(args.HasProperty(TestObject.BarProperty));
Assert.IsFalse(args.HasProperty(UnrelatedObject.NotProperty));
Assert.IsTrue(args.HasAnyProperty(TestObject.FooProperty));
Assert.IsTrue(args.HasAnyProperty(TestObject.FooProperty, TestObject.BarProperty));
Assert.IsFalse(args.HasAnyProperty(TestObject.BarProperty));
Assert.IsFalse(args.HasAnyProperty(UnrelatedObject.NotProperty));
Assert.IsFalse(args.CompleteChange);
}
public void ResolvesChildren()
{
var testObject = new TestObject() { Id = 1, Children = new List<TestObject>() };
var child = new TestObject();
var mChildState = new Mock<IObjectState>(MockBehavior.Strict);
var builder = new ObjectBuilder<TestObject>(testObject);
var t1 = builder
.Dependent(mChildState.Object)
.Build(state => new ObjectBuilder<TestObject>(child));
var t2 = t1.Resolve(
(resolver, target, dependent) => target.Add(dependent)
);
Assert.That(t1, Is.EqualTo(t2));
Assert.That(builder.DependentObjects.First(), Is.EqualTo(t2));
var context = (IBuilderContext) t2;
var resolved = context.Build(null);
Assert.That(resolved, Is.EqualTo(child));
var r = builder.Materialise();
Assert.That(r, Is.EqualTo(testObject));
Assert.That(r.Children, Is.Not.Null);
Assert.That(r.Children.First(), Is.EqualTo(child));
}
public void ToAndFromJsonZip()
{
var obj = new TestObject(true, "private") { StringProp = "hello", NumberField = 1234 };
var provider = new JsonZipStateProvider();
var state = provider.FromNative(obj);
var native = provider.ToNative<TestObject>(state);
Assert.True(native.StringProp == "hello" && native.NumberField == 1234 && native.IsPrivateDefaults());
}
public void GetReturnsWhatWasSet()
{
var obj = new TestObject();
Assert.IsNull(obj.StringProperty);
obj.StringProperty = "foo";
Assert.AreEqual("foo", obj.StringProperty);
}
public void Appending_an_object()
{
var value = new TestObject();
description.AppendValue(value);
Assert.AreEqual(value.ToString(), description.ToString());
}
public void ObjectWithCustomAspect_INPCDoesNotThrow()
{
var o = new TestObject( null );
o.DbName = "x";
string a = o.DbName;
o.DbName = null;
a = o.DbName;
}
public void CustomObjectReturnsCorrectString()
{
var value = new TestObject();
var result = value.SafeToString();
Assert.Equal(TestObject.ExpectedString, result);
}
public void SameObjectReferenceIsEqual(TestObject obj)
{
var objRefCopy = obj;
var equal = obj.EqualsFromComponents(objRefCopy);
equal.Should().BeTrue();
}
public void Serialize()
{
var Serializer = new JsonSerializer();
dynamic Object = new { A = 5, B = "ASDF" };
Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object));
Object = new TestObject { A = 5, B = "ASDF" };
Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object));
}
public void Should_convert_object_to_Json()
{
var testObject = new TestObject {Name = "Value"};
string jsonObject = testObject.ToJson();
Assert.IsNotNull(jsonObject);
Assert.AreEqual(TestObjectJson, jsonObject);
}
[Test] public void CloneComplexObject()
{
Random rnd = new Random();
TestObject data = new TestObject(rnd, 5);
TestObject dataResult = data.DeepClone();
Assert.IsTrue(data.Equals(dataResult));
Assert.IsFalse(data.AnyReferenceEquals(dataResult));
}
public static TestObject New()
{
TestObject t = new TestObject();
t.Id = 33;
t.Name = "SqMtx";
t.Results = new double[] { 101.3, 99.8, 99.6, 100.4 };
t.WhenRun = DateTime.Parse("Jan 1, 2015 8:00 GMT");
return t;
}
public void TestObjectList()
{
TestObject to = new TestObject();
to.Name = "Test Obejct 1";
to.Description = "First Test Object";
dao.Save(to);
Assert.IsNotNull(dao.TestObjectList);
Assert.Greater(dao.TestObjectList.Count, 0);
dao.DeleteItem(to);
Assert.IsNotNull(dao.TestObjectList);
Assert.IsFalse(dao.TestObjectList.Contains(to));
TestObject to2 = new TestObject();
to2.Name = "Test Obejct 2";
to2.Description = "Second Test Object";
dao.AddNew(to);
dao.Save(to2);
Assert.GreaterOrEqual(dao.TestObjectList.Count, 2);
to2.Description = "This is a New description";
dao.Save(to2);
Assert.IsTrue(dao.TestObjectList[dao.TestObjectList.IndexOf(to2)].Description.Equals("This is a New description"));
}
public void Collection_properties_shall_be_completely_reset_if_inputs_to_adapter_creation_expression_change()
{
TestObject TestObject = new TestObject();
TestObject Item1 = new TestObject(1);
TestObject Item2 = new TestObject(2);
TestObject Item3 = new TestObject(3);
TestObject.PropertyCollection.Add(Item1);
TestObject.PropertyCollection.Add(Item2);
TestObject.PropertyCollection.Add(Item3);
TestProxy6 TestProxy = new TestProxy6(TestObject);
//All objects must be re-created because of the dependency to 'property' in the adapter creation
TestObject.Property = 42;
TestProxy6[] Items = TestProxy.CollectionProperty.ToArray();
Assert.AreEqual(42, Items[0].DependentProperty);
Assert.AreEqual(42, Items[1].DependentProperty);
Assert.AreEqual(42, Items[2].DependentProperty);
}
public void find_record_by_key_test()
{
try
{
var services = GetServiceProvider();
services.GetService <TestContext>().Database.EnsureCreated();
var repository = services.GetService <Repository <TestObject, TestContext> >();
var testObject = new TestObject {
Id = 1, Name = "Test1"
};
repository.Create(testObject);
var foundObject = repository.FindByKey(1);
Assert.Equal(1, foundObject.Id);
}
finally
{
Connection.Close();
}
}
public void ProxyGenericInterface()
{
IProxyTypeBuilder builder = GetProxyBuilder();
builder.TargetType = typeof(ClassThatImplementsGenericInterface <TestObject>);
Type proxy = builder.BuildProxyType();
Assert.IsNotNull(proxy, "The proxy generated by a (valid) call to BuildProxy() was null.");
GenericInterface <TestObject> foo = Activator.CreateInstance(proxy) as GenericInterface <TestObject>;
Assert.IsNotNull(foo);
TestObject to1 = foo.Create();
Assert.IsNotNull(to1);
TestObject to2 = foo.Populate(new TestObject());
Assert.IsNotNull(to2);
Assert.AreEqual("Populated", to2.Name);
}
public void GetDictionaryWithValueRefAttributeShortcuts()
{
XmlObjectFactory xof = new XmlObjectFactory(
new ReadOnlyXmlTestResource("collections.xml", GetType()));
IDictionary map = (IDictionary)xof.GetObject("mapWithValueRefAttributeShortcuts");
Assert.AreEqual(2, map.Count);
foreach (string key in map.Keys)
{
object obj = map[key];
Assert.IsNotNull(obj);
Assert.AreEqual(typeof(TestObject), obj.GetType(), "Wrong value assigned to value of dictionary.");
TestObject tob = (TestObject)obj;
if (key == "rick")
{
Assert.AreEqual("Rick Evans", tob.Name, "Wrong object value assigned to the 'rick' key.");
}
else if (key == "uncleelvis")
{
Assert.AreEqual("Uncle Elvis", tob.Name, "Wrong object value assigned to the 'uncleelvis' key.");
}
}
}
public void IgnoresUnresolvableVariable()
{
StaticApplicationContext ac = new StaticApplicationContext();
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("name", "${name}");
pvs.Add("nickname", "${nickname}");
ac.RegisterSingleton("tb1", typeof(TestObject), pvs);
VariablePlaceholderConfigurer vpc = new VariablePlaceholderConfigurer();
vpc.IgnoreUnresolvablePlaceholders = true;
vpc.VariableSource = new DictionaryVariableSource(new string[] { "name", "Erich" });
ac.AddObjectFactoryPostProcessor(vpc);
ac.Refresh();
TestObject tb1 = (TestObject)ac.GetObject("tb1");
Assert.AreEqual("Erich", tb1.Name);
Assert.AreEqual("${nickname}", tb1.Nickname);
}
public void GivenGetFilesNamesIsCalled_WhenNoFilesWithTheRightExtensionExist_ThenNoFilesAreReturned()
{
// Arrange
TestObject testObject1 = new TestObject {
Property1 = "prop1", Property2 = "prop2"
};
TestObject testObject2 = new TestObject {
Property1 = "prop1", Property2 = "prop2"
};
string dir = this.GetFolderPathForTestExecution();
FileStorage <TestObject> fileStorage = new FileStorage <TestObject>(dir);
fileStorage.SaveToFile(testObject1, "savedTestObject1.json");
fileStorage.SaveToFile(testObject2, "savedTestObject2.json");
// Act
var filesPaths = fileStorage.GetFilesNames("txt");
// Assert
Assert.Empty(filesPaths);
Assert.DoesNotContain("savedTestObject1.json", filesPaths);
Assert.DoesNotContain("savedTestObject2.json", filesPaths);
}
public void GivenGetFilesPathsIsCalled_WhenFilesWithTheRightExtensionExist_ThenTheFilesAreReturned()
{
// Arrange
TestObject testObject1 = new TestObject {
Property1 = "prop1", Property2 = "prop2"
};
TestObject testObject2 = new TestObject {
Property1 = "prop1", Property2 = "prop2"
};
string dir = this.GetFolderPathForTestExecution();
FileStorage <TestObject> fileStorage = new FileStorage <TestObject>(dir);
fileStorage.SaveToFile(testObject1, "savedTestObject1.json");
fileStorage.SaveToFile(testObject2, "savedTestObject2.json");
// Act
var filesPaths = fileStorage.GetFilesPaths("json");
// Assert
Assert.Equal(2, filesPaths.Count());
Assert.Contains(Path.Combine(dir, "savedTestObject1.json"), filesPaths);
Assert.Contains(Path.Combine(dir, "savedTestObject2.json"), filesPaths);
}
public void GivenLoadByFileExtensionIsCalled_WhenFilesExist_ThenTheObjectsAreReturned()
{
// Arrange
TestObject testObject1 = new TestObject {
Property1 = "prop1", Property2 = "prop2"
};
TestObject testObject2 = new TestObject {
Property1 = "prop3", Property2 = "prop4"
};
string dir = this.GetFolderPathForTestExecution();
FileStorage <TestObject> fileStorage = new FileStorage <TestObject>(dir);
fileStorage.SaveToFile(testObject1, "savedTestObject1.json");
fileStorage.SaveToFile(testObject2, "savedTestObject2.json");
// Act
IEnumerable <TestObject> loadedObjects = fileStorage.LoadByFileExtension("json");
// Assert
Assert.Equal(2, loadedObjects.Count());
Assert.Contains(loadedObjects, o => o.Property1 == testObject1.Property1 && o.Property2 == testObject1.Property2);
Assert.Contains(loadedObjects, o => o.Property1 == testObject2.Property1 && o.Property2 == testObject2.Property2);
}
public void WithIgnoreUnresolvablePlaceholder()
{
const string defName = "foo";
const string placeholder = "${name}";
TestObject foo = new TestObject(placeholder, 30);
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("name", placeholder);
RootObjectDefinition def = new RootObjectDefinition(typeof(TestObject), pvs);
IConfigurableListableObjectFactory mock = A.Fake <IConfigurableListableObjectFactory>();
A.CallTo(() => mock.GetObjectDefinitionNames(false)).Returns(new string [] { defName });
A.CallTo(() => mock.GetObjectDefinition(defName, false)).Returns(def);
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreUnresolvablePlaceholders = true;
cfg.PostProcessObjectFactory(mock);
Assert.AreEqual(placeholder, foo.Name);
A.CallTo(() => mock.AddEmbeddedValueResolver(null)).WithAnyArguments().MustHaveHappened();
}
public void RegisterHandlerTest()
{
int actualInt = 0;
string actualValue = null;
TestObject obj = new TestObject {
SValue = "Test String", IValue = 10
};
PropertyObserver <TestObject> po = new PropertyObserver <TestObject>(obj);
po.RegisterHandler(o => o.SValue, (oo) => actualValue = oo.SValue);
po.RegisterHandler(o => o.IValue, (oo) => actualInt = oo.IValue);
obj.SValue = "1";
Assert.AreEqual("1", actualValue);
obj.IValue = 5;
Assert.AreEqual(5, actualInt);
po.UnregisterHandler(o => o.SValue);
obj.SValue = "2";
Assert.AreEqual("1", actualValue);
}
public void CanApplyConstructorArgsToAbstractType()
{
IResource resource = new ReadOnlyXmlTestResource("ctor-args.xml", GetType());
XmlObjectFactory xof = new XmlObjectFactory(resource);
TestObject rod = (TestObject)xof.GetObject("rod");
Assert.AreEqual(1, rod.Age);
RootObjectDefinition def = (RootObjectDefinition)xof.GetObjectDefinition("rod");
ConstructorResolver resolver = new ConstructorResolver(xof, xof, new SimpleInstantiationStrategy(),
new ObjectDefinitionValueResolver(xof));
ConstructorInstantiationInfo ci = resolver.GetConstructorInstantiationInfo("rod", def, null, null);
AbstractObjectDefinition objDef = (AbstractObjectDefinition)xof.GetObjectDefinition("foo");
objDef.IsAbstract = false;
TestObject foo = (TestObject)xof.GetObject("foo");
Assert.AreEqual(2, foo.Age);
}
public void WhitespaceHandling()
{
StaticApplicationContext ac = new StaticApplicationContext();
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("name", "${name}");
pvs.Add("nickname", "${nickname}");
ac.RegisterSingleton("tb1", typeof(TestObject), pvs);
IList variableSources = new ArrayList();
variableSources.Add(new DictionaryVariableSource(new string[] { "name", string.Empty, "nickname", null }));
pvs = new MutablePropertyValues();
pvs.Add("VariableSources", variableSources);
ac.RegisterSingleton("configurer", typeof(VariablePlaceholderConfigurer), pvs);
ac.Refresh();
TestObject tb1 = (TestObject)ac.GetObject("tb1");
Assert.AreEqual(string.Empty, tb1.Name);
Assert.AreEqual(null, tb1.Nickname);
}
public void TestCloneSerializer()
{
TestObject[] copies = new TestObject[3];
TestObject objB, objA = TestObject.Create();
using (ObjectCloner cloner = new SerializerClone())
{
objB = cloner.Clone(objA);
for (int i = 0; i < copies.Length; i++)
{
copies[i] = cloner.Clone(objB);
}
}
AssertDifferences(objA, objB);
//not using serialization yields new instance of singleton
Assert.IsTrue(Object.ReferenceEquals(objA.singletonData, objB.singletonData));
//not using serializaiton skips all custom routines
Assert.IsFalse(objA.customData.CustomData);
Assert.IsFalse(objA.customData.Deserialized);
Assert.IsTrue(objB.customData.CustomData);
Assert.IsTrue(objB.customData.Deserialized);
}
public void Finds_File_Info_Matching_Anything_Star_Extension_Specified()
{
Func <string, bool> actualPredicate = null;
var path = RandomGenerator.String();
Mock <IFileSystemOperations>().Setup(x => x.FindFileInfo(path, It.IsAny <Func <string, bool> >()))
.Returns(new Dictionary <string, FileInfo>())
.Callback <string, Func <string, bool> >((_, predicate) => actualPredicate = predicate);
TestObject.Clean(path, "*", DateTime.MaxValue, null);
Mock <IFileSystemOperations>().Verify(x => x.FindFileInfo(path, It.IsAny <Func <string, bool> >()));
Mock <IFileSystemOperations>().Verify(x => x.FindFileInfo(It.IsAny <string>(), It.IsAny <Func <string, bool> >()), Times.Once);
Assert.True(actualPredicate("a.txt"));
Assert.True(actualPredicate("a.log"));
Assert.True(actualPredicate("a"));
Assert.True(actualPredicate("a.110"));
Assert.False(actualPredicate(""));
Assert.False(actualPredicate("a\\b\\" + DirectoryCleaner.LastCleaningCheckFileName));
Assert.False(actualPredicate(DirectoryCleaner.LastCleaningCheckFileName.ToUpper()));
Assert.False(actualPredicate(null));
}
public void AddPropertyValue()
{
StaticApplicationContext ac = new StaticApplicationContext();
ac.RegisterSingleton("tb1", typeof(TestObject), new MutablePropertyValues());
ac.RegisterSingleton("tb2", typeof(TestObject), new MutablePropertyValues());
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("Properties", "<spring-config><add key=\"tb1.Age\" value=\"99\"/><add key=\"tb2.Name\" value=\"test\"/></spring-config>");
ac.RegisterSingleton("configurer1", typeof(PropertyOverrideConfigurer), pvs);
pvs = new MutablePropertyValues();
pvs.Add("Properties", "<spring-config><add key=\"tb2.Age\" value=\"99\"/><add key=\"tb2.Name\" value=\"test\"/></spring-config>");
pvs.Add("order", "0");
ac.RegisterSingleton("configurer2", typeof(PropertyOverrideConfigurer), pvs);
ac.Refresh();
TestObject tb1 = (TestObject)ac.GetObject("tb1");
TestObject tb2 = (TestObject)ac.GetObject("tb2");
Assert.AreEqual(99, tb1.Age);
Assert.AreEqual(99, tb2.Age);
Assert.AreEqual(null, tb1.Name);
Assert.AreEqual("test", tb2.Name);
}
public void GetThenGetOrAddThenGetWithSetUp_TestObject_ReturnsExpectedResults()
{
var cacheKey = "SomethingInTheCache";
var expectedResult = new TestObject();
var cacheMock = MockFactory.CreateCachingServiceMock();
cacheMock.SetUpCacheEntry(cacheKey, expectedResult);
var mockedCache = cacheMock.Object;
var actualResult1 = mockedCache.Get <TestObject>(cacheKey);
var actualResult2 = mockedCache.GetOrAdd(cacheKey, addItemFactory: () => expectedResult, expires: DateTimeOffset.Now.AddMinutes(30));
var actualResult3 = mockedCache.Get <TestObject>(cacheKey);
Assert.Multiple(() => {
Assert.AreSame(expectedResult, actualResult1);
Assert.AreSame(expectedResult, actualResult2);
Assert.AreSame(expectedResult, actualResult3);
cacheMock.Verify(m => m.GetOrAdd(It.IsAny <string>(), It.IsAny <Func <ICacheEntry, TestObject> >()), Times.Once);
cacheMock.Verify(m => m.Get <TestObject>(It.IsAny <string>()), Times.Exactly(2));
});
}
public void RequestResource_CustomPoolContainsMultipleObj_UsesFIFO()
{
int poolId = ObjectPool <TestObject> .CreateNewPool();
TestObject obj1 = new TestObject(1);
ObjectPool <TestObject> .ReleaseResource(poolId, obj1);
TestObject obj2 = new TestObject(2);
ObjectPool <TestObject> .ReleaseResource(poolId, obj2);
TestObject retrieved = ObjectPool <TestObject> .RequestResource(poolId, () => { return(new TestObject(42)); });
Assert.AreEqual(obj1, retrieved);
TestObject retrieved2 = ObjectPool <TestObject> .RequestResource(poolId, () => { return(new TestObject(42)); });
Assert.AreEqual(obj2, retrieved2);
// teardown
ObjectPool <TestObject> .RemovePool(poolId);
}
public void TestObjectReferenceUpdate()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject {
Name = "Test"
};
var container = new ObjectContainer {
Instance = instance
};
var containerNode = nodeContainer.GetOrCreateNode(container);
var memberNode = containerNode.Children.First();
var instanceNode = memberNode.Content.Reference.AsObject.TargetNode;
// Update to a new instance
var newInstance = new TestObject {
Name = "Test2"
};
memberNode.Content.Update(newInstance);
Helper.TestMemberContentNode(containerNode, memberNode, container, newInstance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstance);
var newInstanceNode = nodeContainer.GetNode(newInstance);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, newInstanceNode, newInstance);
Assert.AreNotEqual(instanceNode.Guid, newInstanceNode.Guid);
// Update to null
memberNode.Content.Update(null);
Helper.TestMemberContentNode(containerNode, memberNode, container, null, nameof(ObjectContainer.Instance), true);
Helper.TestNullObjectReference(memberNode.Content.Reference);
// Update back to the initial instance
memberNode.Content.Update(instance);
Helper.TestMemberContentNode(containerNode, memberNode, container, instance, nameof(ObjectContainer.Instance), true);
Helper.TestNonNullObjectReference(memberNode.Content.Reference, instanceNode, instance);
}
public void TestStartingCount()
{
ObjectPool <TestObject> pool = new ObjectPool <TestObject>(
createObject: () => new TestObject {
active = true, initialized = true
},
activateObject: obj => obj.active = true,
deactivateObject: obj => obj.active = false,
3
);
Assert.IsTrue(pool.InactiveCount == 3);
Assert.IsTrue(pool.ActiveCount == 0);
Assert.IsTrue(pool.TotalCount == 3);
TestObject obj1 = pool.Get();
Assert.IsNotNull(obj1);
TestObject obj2 = pool.Get();
Assert.IsNotNull(obj2);
TestObject obj3 = pool.Get();
Assert.IsNotNull(obj3);
Assert.IsTrue(pool.InactiveCount == 0);
Assert.IsTrue(pool.ActiveCount == 3);
Assert.IsTrue(pool.TotalCount == 3);
TestObject obj4 = pool.Get();
Assert.IsNotNull(obj4);
Assert.IsTrue(pool.InactiveCount == 0);
Assert.IsTrue(pool.ActiveCount == 4);
Assert.IsTrue(pool.TotalCount == 4);
}
static void Main(string[] args)
{
var logger = LogManager.GetLogger("demo");
MappedDiagnosticsLogicalContext.Set("FluentdHost", "127.0.0.1");
MappedDiagnosticsLogicalContext.Set("FluentdPort", "24224");
MappedDiagnosticsLogicalContext.Set("FluentdTag", "nlog.demo");
MappedDiagnosticsLogicalContext.Set("FluentdEnabled", "true");
while (true)
{
var i = 0;
var watch = System.Diagnostics.Stopwatch.StartNew();
while (i < 100)
{
var testObj = new TestObject
{
A = "A",
B = i,
D = DateTime.UtcNow,
I = new InternalTestObject
{
AA = "A",
BB = i,
DD = DateTime.UtcNow
}
};
var eventJson = JsonConvert.SerializeObject(testObj);
logger.Info(eventJson);
i++;
}
watch.Stop();
Console.Write("Elapsed time: {0}", watch.ElapsedMilliseconds);
Console.ReadLine();
}
}
private void InitDataGridView()
{
TestObject test1 = new TestObject()
{
OneValue = 2,
TwoValue = 3
};
TestObject test2 = new TestObject()
{
OneValue = 12,
TwoValue = 13
};
TestObject test3 = new TestObject()
{
OneValue = 32,
TwoValue = 17
};
List <TestObject> list = new List <TestObject>();
list.Add(test1);
list.Add(test2); // Not shown in code
list.Add(test3); // Not shown in code
dataGridView1.DataSource = list;
}
public void ProxyCanBeClassAndInterface()
{
TestObject target = new TestObject();
target.Age = 32;
mockTargetSource.SetTarget(target);
AdvisedSupport advised = new AdvisedSupport();
advised.TargetSource = mockTargetSource;
IAopProxy aop = CreateAopProxy(advised);
object proxy = aop.GetProxy();
Assert.IsTrue(AopUtils.IsDecoratorAopProxy(proxy), "Should be a decorator-based proxy");
Assert.IsTrue(proxy is ITestObject);
Assert.IsTrue(proxy is TestObject);
ITestObject itb = (ITestObject)proxy;
Assert.AreEqual(32, itb.Age, "Incorrect age");
TestObject tb = (TestObject)proxy;
Assert.AreEqual(32, tb.Age, "Incorrect age");
}
public void InterceptFinalMethodThatBelongsToAnInterface()
{
TestObject target = new TestObject();
target.Name = "Bruno";
mockTargetSource.SetTarget(target);
NopInterceptor ni = new NopInterceptor();
AdvisedSupport advised = new AdvisedSupport(mockTargetSource);
advised.AddAdvice(ni);
// Cast to the interface that method belongs to
ITestObject proxy = CreateProxy(advised) as ITestObject;
Assert.IsNotNull(proxy);
Assert.AreEqual(target.Name, proxy.Name, "Incorrect name");
proxy.Name = "Bruno Baia";
Assert.AreEqual("Bruno Baia", proxy.Name, "Incorrect name");
Assert.AreEqual(3, ni.Count);
}
private UnityELExpression <T> CreateExpression <T>(string expression)
{
evaluator = new UnityELEvaluator();
evaluator.Properties["a"] = 10;
dictionary = new Dictionary <string, int>();
dictionary["a"] = 10;
evaluator.Properties["dictionary"] = dictionary;
list = new List <int>();
list.Add(10);
evaluator.Properties["list"] = list;
array = new int[2];
array[0] = 10;
evaluator.Properties["array"] = array;
testObject = new TestObject();
testObject.Property = 10;
evaluator.Properties["testObject"] = testObject;
return(evaluator.Compile <T>(expression));
}
public void Init(TestObject module, int id)
{
ID = id;
m_module = module;
m_module.Button = this;
if (m_gaugeFill != null)
{
if (module is Rocket rocket)
{
m_gaugeFill.gameObject.SetActive(rocket.m_hasFuel);
m_gaugeOver.gameObject.SetActive(rocket.m_hasFuel);
m_rocket = rocket;
}
}
if (module is Magnet magnet)
{
m_magnet = magnet;
m_magnetLocked.SetActive(true);
m_on.SetActive(false);
m_off.SetActive(false);
}
GetComponent <Button>().onClick.AddListener(OnClick);
if (m_module.IsActive)
{
m_on.SetActive(true);
m_off.SetActive(false);
}
else
{
m_on.SetActive(false);
m_off.SetActive(true);
}
}
public void MixedFieldAndPropertyAccess_Test()
{
var testObject = new TestObject
{
AnotherObjectField = new TestObject
{
Property = "a"
},
AnotherObjectProperty = new TestObject
{
Field = "b"
}
};
var table = new Table <LinqDecoratedWithStringCkEntity>(GetSession((_, __) => {}));
var query = table.Where(t => t.pk == testObject.AnotherObjectField.Property && t.ck1 == testObject.AnotherObjectProperty.Field);
var pocoData = MappingConfiguration.Global.MapperFactory.GetPocoData <LinqDecoratedWithStringCkEntity>();
var visitor = new CqlExpressionVisitor(pocoData, "x_ts", null);
object[] parameters;
var queryCql = visitor.GetSelect(query.Expression, out parameters);
Assert.That(parameters, Is.EquivalentTo(new[] { "a", "b" }));
Assert.AreEqual(@"SELECT ""x_ck1"", ""x_f1"", ""x_pk"" FROM ""x_ts"" WHERE ""x_pk"" = ? AND ""x_ck1"" = ?", queryCql);
}
public void ValidStringsAreOk()
{
// allows null, empty string and whitespace string
// string needs to be more than 5 chars long after validator calling Trim()
TestObject to = new TestObject();
to.StringList.Add("ptv-vrk");
to.StringList.Add(" viisi");
to.StringList.Add(" viisi ");
to.StringList.Add(null);
to.StringList.Add(string.Empty);
to.StringList.Add(" ");
to.StringList.Add("viisi ");
to.StringList.Add("ptv 5");
to.StringList.Add("p t v");
ValidationContext ctx = new ValidationContext(to);
ctx.MemberName = "StringList";
List <ValidationResult> validationResults = new List <ValidationResult>();
Validator.TryValidateProperty(to.StringList, ctx, validationResults).Should().BeTrue();
}
public void First_attempt_to_call_the_cache_will_return_the_object_as_is_and_store_it_in_cache()
{
var cacheResolver = new Mock <ICache>();
const string key = "TestObject.Key";
var testObject = new TestObject
{
Age = 27,
Name = "Omar AL Zabir",
BirthDate = DateTime.Parse("9/5/1982")
};
cacheResolver.Setup(c => c.Get(It.Is <string>(cacheKey => cacheKey == key)))
.Returns(default(TestObject)).AtMostOnce().Verifiable();
cacheResolver.Setup(c => c.Add(
It.Is <string>(cacheKey => cacheKey == key),
It.Is <TestObject>(cacheObject => Equals(cacheObject, testObject))))
.AtMostOnce().Verifiable();
Let.Cache = () => cacheResolver.Object;
var result = Let.Us.Cache <TestObject>(key).Return(() => testObject);
cacheResolver.VerifyAll();
Assert.Same(testObject, result);
}
public void DeserializeByteArrayWithTypeNameHandling()
{
TestObject test = new TestObject("Test", new byte[] { 72, 63, 62, 71, 92, 55 });
string json = JsonConvert.SerializeObject(test, Formatting.Indented, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
});
JObject o = JObject.Parse(json);
JsonSerializer serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.All;
using (JsonReader nodeReader = o.CreateReader())
{
// Get exception here
TestObject newObject = (TestObject)serializer.Deserialize(nodeReader);
Assert.AreEqual("Test", newObject.Name);
CollectionAssert.AreEquivalent(new byte[] { 72, 63, 62, 71, 92, 55 }, newObject.Data);
}
}
