Esempio n. 1
0
        public void RecursiveItemsAreOnlyRecursiveItemsTest()
        {
            var first = new ExtendedClassWithRecursion();

            first.Name = "first";
            var second = new ExtendedClassWithRecursion();

            second.Name = "second";
            var third = new ClassWithRecursion();

            third.Name = "third";

            first.Subclass        = second;
            second.Subclass       = first;
            first.AnotherSubclass = third;
            third.Subclass        = second;

            var sourceTree = new ObjectTreeItem(first);

            sourceTree.CreateTree();

            foreach (var recursiveSourceTreeItem in sourceTree.RecursionObjectTreeItems)
            {
                //if (!ReferenceEquals(recursiveSourceTreeItem.Parent.Item, first))
                if (recursiveSourceTreeItem.Item != first)
                {
                    // Tree contains errors, if recursive tree items does not contain root as any of their child
                    Trace.TraceInformation(sourceTree.ToFormattedString());
                    throw new Exception("<<<< BUG IN OBJECT TREE>>>>>\n" +
                                        "In: \"" + recursiveSourceTreeItem.Item + "\"\n" +
                                        "Expected Item: \"" + first + "\"\n" +
                                        "Actual Items: \"" + recursiveSourceTreeItem.ToFormattedString());
                }
            }
        }
Esempio n. 2
0
        public void CreateTreeProperly()
        {
            var first = new ClassWithRecursion();

            first.Name = "First";
            var second = new ClassWithRecursion();

            second.Name = "Second";

            first.Subclass = second;

            var sourceTree = new ObjectTreeItem(first);

            sourceTree.CreateTree();
            Trace.WriteLine(sourceTree.ToFormattedString());
            Assert.IsNull(sourceTree.Parent);
            Assert.IsNotNull(sourceTree.Childs);

            Assert.IsTrue(IEnumerableExtensions.Any(sourceTree.Childs));
            Assert.AreEqual(2, sourceTree.Childs.Count);

            Assert.AreEqual(first, sourceTree.Item);
            Assert.IsTrue(sourceTree.Childs.Any(item => item.Item == second));

            foreach (var objectTreeItem in sourceTree.Childs)
            {
                Assert.AreEqual(sourceTree, objectTreeItem.Parent);
            }
        }
Esempio n. 3
0
        //  [ExpectedException(typeof(AssertFailedException))]
        public void TreeContainsCorrectRecuriveTreeItems()
        {
            var first = new ExtendedClassWithRecursion();

            first.Name = "first";
            var second = new ExtendedClassWithRecursion();

            second.Name = "second";
            var third = new ClassWithRecursion();

            third.Name = "third";


            first.Subclass        = second;
            second.Subclass       = first;
            first.AnotherSubclass = third;
            third.Subclass        = second;

            var sourceTree = new ObjectTreeItem(first);

            sourceTree.CreateTree();
            Trace.WriteLine(string.Join("\n", sourceTree.RecursionObjectTreeItems.Select(item => item.Parent.Item)));

            Assert.AreEqual(2, sourceTree.RecursionObjectTreeItems.Count);
            Assert.IsTrue(sourceTree.RecursionObjectTreeItems.Any(item => item.Parent.Item == second));
            Assert.IsFalse(sourceTree.RecursionObjectTreeItems.Any(item => item.Parent.Item == first));
            Assert.IsFalse(sourceTree.RecursionObjectTreeItems.Any(item => item.Parent.Item == third));
        }
Esempio n. 4
0
        private void BuildListTree <T>(params T[] arrayElements)
        {
            var instance = new ClassWithMembers <List <T> >(arrayElements.ToList(), arrayElements.ToList());
            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 5
0
        public void TreeCanHandleGuid()
        {
            var instance = new ClassWithMembers <Guid>(new Guid(), new Guid());

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 6
0
        private void TestObjectTreeCreation <T>(T property, T field)
        {
            var instance = new ClassWithMembers <T>(field, property);

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 7
0
        public void TreeCanHandleIpAddress()
        {
            var instance = new ClassWithMembers <IPAddress>(new IPAddress(19216811), new IPAddress(19216811));

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 8
0
 public static DifferenceItem FromBranchRemoved(ObjectTreeItem source)
 {
     if (source is INodeObjectTreeItem node)
     {
         var children = node.Children.Select(n => FromBranchRemoved(n)).ToArray();
         return(new DifferenceItemContainer(children, source, null, DiffType.Removed));
     }
     else
     {
         return(new DifferenceItem(source, null, DiffType.Removed));
     }
 }
Esempio n. 9
0
        public void TreeCanHandleEnumberable()
        {
            var action = new Func <IEnumerable <string> >(CreateString);

            var instance = new ClassWithMembers <IEnumerable <string> >(action.Invoke(), new List <string>());

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 10
0
 public static DifferenceItem FromBranchModified(ObjectTreeItem current, ObjectTreeItem next)
 {
     if (next is INodeObjectTreeItem node)
     {
         var children = node.Children.Select(n => FromBranchAdded(n)).ToArray();
         return(new DifferenceItemContainer(children, current, next, DiffType.None));
     }
     else
     {
         return(new DifferenceItem(current, next, DiffType.None));
     }
 }
Esempio n. 11
0
        public void TreeCanHandleDelegates()
        {
            Del del = delegate(string name)
            { Console.WriteLine("Notification received for: {0}", name); };
            var instance = new ClassWithMembers <Delegate>(del);

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 12
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="current"></param>
 /// <param name="next"></param>
 /// <returns></returns>
 /// <remarks>
 /// Root has to be the same type, no property.
 /// Also it can't be a primitive
 /// </remarks>
 public static DifferenceItem CreateDifferenceTree(ObjectTreeItem current, ObjectTreeItem next)
 {
     if (ReferenceEquals(current, null))
     {
         if (!ReferenceEquals(next, null))
         {
             return(FromBranchAdded(next));
         }
         else
         {
             // when both are null
             return(null);
         }
     }
     if (!ReferenceEquals(current, null))
     {
         if (ReferenceEquals(next, null))
         {
             return(new DifferenceItem(current, null, DiffType.Removed));
         }
     }
     if (ReferenceEquals(current.Source, next.Source))
     {
         return(null);
     }
     if (current.GetType() != next.GetType())
     {
         var removed = FromBranchRemoved(current);
         var added   = FromBranchAdded(next);
         return(new DifferenceItemContainer(new[] { removed, added }, current, next, DiffType.Modified));
     }
     // from this point both states are same type
     else if (current is StateObjectTreeItem currentState)
     {
         var nextState = (StateObjectTreeItem)next;
         return(FromNamedProperties(currentState, nextState));
     }
     else if (current is DictionaryObjectTreeItem currentDictionary)
     {
         var nextDictionary = (DictionaryObjectTreeItem)next;
         return(FromNamedProperties(currentDictionary, nextDictionary));
     }
     else if (current is ListObjectTreeItem)
     {
         return(FromList((ListObjectTreeItem)current, (ListObjectTreeItem)next));
     }
     else if (current is PrimitiveObjectTreeItem)
     {
         return(FromPrimitive((PrimitiveObjectTreeItem)current, (PrimitiveObjectTreeItem)next));
     }
     throw new Exception($"Unknown source type {current.GetType().Name}");
 }
Esempio n. 13
0
        public void TreeCanHandleOwnGenericList()
        {
            var instance = new ClassWithMembers <OwnGenericListClass <string> >(new OwnGenericListClass <string>()
            {
                "test1", "test2"
            }, new OwnGenericListClass <string>());

            var treeItem = new ObjectTreeItem(instance);

            treeItem.CreateTree();

            Trace.WriteLine(treeItem.ToFormattedString());
        }
Esempio n. 14
0
 public Step(int key, ReduxAction action, object state, ObjectData actionData, ObjectTreeItem actionTreeItem, ObjectData stateData, ObjectTreeItem stateTreeItem,
             DifferenceItem differenceItem, bool differenceCalculated)
 {
     Key                  = key;
     Action               = action;
     State                = state;
     ActionData           = actionData;
     ActionTreeItem       = actionTreeItem;
     StateData            = stateData;
     StateTreeItem        = stateTreeItem;
     DifferenceItem       = differenceItem;
     DifferenceCalculated = differenceCalculated;
 }
Esempio n. 15
0
        //  [ExpectedException(typeof(AssertFailedException))]
        public void SelfReferencingObjectIsProperlyCreated()
        {
            var first = new ClassWithRecursion();

            first.Name = "first";

            first.Subclass = first;

            var sourceTree = new ObjectTreeItem(first);

            sourceTree.CreateTree();
            Trace.WriteLine(sourceTree.ToFormattedString());

            Assert.AreEqual(1, sourceTree.RecursionObjectTreeItems.Count);
            Assert.IsTrue(sourceTree.RecursionObjectTreeItems.Any(item => item.Parent.Item == first));
            Assert.AreSame(sourceTree.Item, sourceTree.Childs.First(item => item.Item == sourceTree.Item).Item);
        }
Esempio n. 16
0
        public void TreeCanHandleFunctions()
        {
            var instance1 = new ClassWithMembers <Func <string, int> >(s => 5);
            var instance2 = new ClassWithMembers <Func <string> >(() => "test", () => "test");
            var instance3 = new ClassWithMembers <Func <string> >(() => "test", () => "test");

            var treeItem1 = new ObjectTreeItem(instance1);
            var treeItem2 = new ObjectTreeItem(instance2);
            var treeItem3 = new ObjectTreeItem(instance3);

            treeItem1.CreateTree();
            treeItem2.CreateTree();
            treeItem3.CreateTree();

            Trace.WriteLine(treeItem1.ToFormattedString());
            Trace.WriteLine(treeItem2.ToFormattedString());
            Trace.WriteLine(treeItem3.ToFormattedString());
        }
Esempio n. 17
0
        public static bool AreKeysEqual(ObjectTreeItem left, ObjectTreeItem right)
        {
            var leftObjectSource  = left.Source;
            var rightObjectSource = right.Source;

            if (leftObjectSource is null || rightObjectSource is null || leftObjectSource.GetType() != rightObjectSource.GetType())
            {
                return(false);
            }
            // state objects might implement keys
            var leftStateObject  = left as StateObjectTreeItem;
            var rightStateObject = right as StateObjectTreeItem;

            if (!(leftStateObject is null) && !(rightStateObject is null))
            {
                return(Equals(leftStateObject.Key, rightStateObject.Key));
            }
            // just check for equality
            return(Equals(left, right));
        }
Esempio n. 18
0
        //  [ExpectedException(typeof(AssertFailedException))]
        public void ToFormattedStringTest()
        {
            var first = new ExtendedClassWithRecursion();

            first.Name = "first";
            var second = new ExtendedClassWithRecursion();

            second.Name = "second";
            var third = new ClassWithRecursion();

            third.Name = "third";


            first.Subclass        = second;
            second.Subclass       = first;
            first.AnotherSubclass = third;
            third.Subclass        = second;

            var sourceTree = new ObjectTreeItem(first);

            sourceTree.CreateTree();
            Trace.WriteLine(sourceTree.ToFormattedString());
        }
Esempio n. 19
0
        public static ObjectTreeItem ToTreeHierarchy(ObjectTreeItem parent, ObjectData source, int depth, string propertyName)
        {
            if (depth > MaxDepth)
            {
                throw new Exception("Object graph is too deep");
            }
            switch (source)
            {
            case StateObjectData state:
                return(FormatState(parent, depth, propertyName, state));

            case ListData list:
                return(FormatList(parent, depth, propertyName, list));

            case DictionaryData dictionary:
                return(FormatDictionary(parent, depth, propertyName, dictionary));

            case PrimitiveData primitive:
                return(FormatPrimitive(parent, depth, propertyName, primitive));

            default:
                throw new Exception($"Unknown ObjectData {source.GetType()}");
            }
        }
Esempio n. 20
0
        public async Task <RootState> ReduceAsync(RootState state, ReduxAction action, CancellationToken ct)
        {
            RootState result;

            switch (action)
            {
            case InsertNewAction insertNew:
                int key            = state.Steps.Length;
                var actionDataTask = Task.Run(() => PropertiesCollector.Collect(insertNew.Action), ct);
                var stateDataTask  = Task.Run(() => PropertiesCollector.Collect(insertNew.State), ct);
                await actionDataTask.ConfigureAwait(false);

                var actionTreeItem = await Task.Run(() => {
                    string actionName = StateFormatter.GetActionName(insertNew.Action);
                    return(StateFormatter.ToTreeHierarchy(actionDataTask.Result, actionName));
                }).ConfigureAwait(false);

                await stateDataTask.ConfigureAwait(false);

                result = state.Clone(steps: state.Steps.Spread(
                                         new Step(key, insertNew.Action, insertNew.State, actionData: actionDataTask.Result,
                                                  actionTreeItem: actionTreeItem,
                                                  stateData: stateDataTask.Result, stateTreeItem: null, differenceItem: null, differenceCalculated: false)));
                break;

            case GenerateTreeHierarchyAction generateTreeHierarchy:
            {
                Step selectedStep = state.SelectedStep;
                result = state;
                if (selectedStep != null)
                {
                    if (selectedStep.StateTreeItem is null)
                    {
                        var  hierarchy = StateFormatter.ToTreeHierarchy(selectedStep.StateData);
                        Step updated   = selectedStep.Clone(stateTreeItem: hierarchy);
                        result       = result.Clone(steps: state.Steps.Replace(selectedStep, updated), selectedStep: updated);
                        selectedStep = updated;
                    }
                    if (!selectedStep.DifferenceCalculated)
                    {
                        // first check if previous step has StateTree
                        var            selectedStepIndex = Array.IndexOf(result.Steps, selectedStep);
                        var            previousStep      = selectedStepIndex > 0 ? result.Steps[selectedStepIndex - 1] : null;
                        ObjectTreeItem previousHierarchy = null;
                        if (previousStep != null)
                        {
                            if (previousStep.StateTreeItem == null)
                            {
                                previousHierarchy = StateFormatter.ToTreeHierarchy(previousStep.StateData);
                                Step previousUpdated = previousStep.Clone(stateTreeItem: previousHierarchy);
                                result = result.Clone(steps: result.Steps.Replace(previousStep, previousUpdated));
                            }
                            else
                            {
                                previousHierarchy = previousStep.StateTreeItem;
                            }
                        }
                        var  difference = TreeComparer.CreateDifferenceTree(previousHierarchy, selectedStep.StateTreeItem);
                        Step updated    = selectedStep.Clone(differenceItem: difference, differenceCalculated: true);
                        result = result.Clone(steps: result.Steps.Replace(selectedStep, updated), selectedStep: updated);
                    }
                }
            }
            break;

            case SelectedStepChangedAction selectedStepChanged:
            {
                var selectedStep = selectedStepChanged.Key.HasValue ? state.Steps.Single(s => s.Key == selectedStepChanged.Key) : null;
                result = state.Clone(selectedStep: selectedStep);
            }
            break;

            default:
                result = state;
                break;
            }
            return(result);
        }
Esempio n. 21
0
 private static IEnumerable <ObjectTreeItem> GetChildren(IEnumerable <ObjectTreeItem> forestElements, ObjectTreeItem parent)
 {
     return(forestElements.Where(i => i.ParentId == parent.Id));
 }
Esempio n. 22
0
        private static void AddChildrenToTreeElements(List <ObjectTreeItem> treeElements, IEnumerable <ObjectTreeItem> forestElements, ObjectTreeItem parent)
        {
            var children     = GetChildren(forestElements, parent);
            var goodChildren = children.Where(c => !AreAlreadyInGraph(treeElements, GetChildren(forestElements, c)));

            treeElements.AddRange(goodChildren);
            foreach (var goodChild in goodChildren)
            {
                AddChildrenToTreeElements(treeElements, forestElements, goodChild);
            }
        }
Esempio n. 23
0
 public static PrimitiveObjectTreeItem FormatPrimitive(ObjectTreeItem parent, int depth, string propertyName, PrimitiveData source)
 {
     return(new PrimitiveObjectTreeItem(source.Value, parent, propertyName, source));
 }
Esempio n. 24
0
 public static ListObjectTreeItem FormatList(ObjectTreeItem parent, int depth, string propertyName, ListData source)
 {
     return(new ListObjectTreeItem(parent, propertyName, source, depth));
 }
Esempio n. 25
0
 public static DictionaryObjectTreeItem FormatDictionary(ObjectTreeItem parent, int depth, string propertyName, DictionaryData source)
 {
     return(new DictionaryObjectTreeItem(parent, propertyName, source, depth));
 }
Esempio n. 26
0
 /// <summary>
 /// Creates <see cref=" StateObjectTreeItem"/>. Besides properties it could implement either a <see cref="IDictionary"/> or <see cref="IEnumerable"/>
 /// but not both.
 /// </summary>
 /// <param name="depth"></param>
 /// <param name="propertyName"></param>
 /// <param name="source"></param>
 /// <returns></returns>
 public static StateObjectTreeItem FormatState(ObjectTreeItem parent, int depth, string propertyName, StateObjectData source)
 {
     return(new StateObjectTreeItem(parent, propertyName, source, depth));
 }