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 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 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 ExtensibleObjectTestCommon()
 {
     _obj = new TestObject();
     _dObj = _obj;
     _dObj.Test1 = "TestValue";
     _dObj.Test2 = null;
 }

 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 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 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 TestException(TestObject obj, string domain, string url, string message)
     : base(message)
 {
     this._obj = obj;
     this._url = url;
     this._domain = domain;
 }

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