void UpdateData(Dictionary <IMRObject, ChildMatchInfo> childrenExpectedMatchInfo)
        {
            var childrenList = new List <IMRObject>(childrenExpectedMatchInfo.Keys);

            foreach (var child in childrenList)
            {
                var matchInfo  = childrenExpectedMatchInfo[child];
                var dataID     = matchInfo.dataID;
                var updateInfo = new ChildMatchInfo
                {
                    dataID            = dataID,
                    semanticTagTraits = new Dictionary <string, bool>(matchInfo.semanticTagTraits)
                };

                // Shifting all trait values by the same amount will update the data
                // while maintaining the validity of this data for our test relations.
                foreach (var floatKVP in matchInfo.floatTraits)
                {
                    var name  = floatKVP.Key;
                    var value = floatKVP.Value + 1f;
                    updateInfo.floatTraits[name] = value;
                    m_FloatTraitProvider.AddOrUpdateTrait(dataID, name, value);
                }
                foreach (var vector2KVP in matchInfo.vector2Traits)
                {
                    var name  = vector2KVP.Key;
                    var value = vector2KVP.Value + Vector2.right;
                    updateInfo.vector2Traits[name] = value;
                    m_Vector2TraitProvider.AddOrUpdateTrait(dataID, name, value);
                }

                childrenExpectedMatchInfo[child] = updateInfo;
            }
        }
        void InvalidateSet(ChildMatchInfo matchInfo)
        {
            // Just one trait not matching should cause a loss.
            var firstFloatTrait = matchInfo.floatTraits.First();

            m_FloatTraitProvider.RemoveTrait(matchInfo.dataID, firstFloatTrait.Key);
        }
        static Relations MakeBaseSet(out SetQueryResult result, Dictionary <IMRObject, ChildMatchInfo> childrenExpectedMatchInfo)
        {
            var gameObject = new GameObject("Set");

            gameObject.AddComponent <ProxyGroup>();
            k_ToDestroy.Add(gameObject);

            // Make child MR objects and give them ordinary relations
            var children = new Dictionary <IMRObject, SetChildArgs>();

            for (var i = 0; i < k_RelationCount + 1; ++i)
            {
                var childGameObject = new GameObject("Child" + i);
                k_ToDestroy.Add(childGameObject);
                childGameObject.transform.SetParent(gameObject.transform);
                var conditionsRoot    = childGameObject.AddComponent <TestMRObject>();
                var expectedMatchInfo = new ChildMatchInfo();
                childrenExpectedMatchInfo[conditionsRoot] = expectedMatchInfo;

                var hasTraitCondition = childGameObject.AddComponent <SemanticTagCondition>();
                hasTraitCondition.SetTraitName(k_CommonTrait);
                expectedMatchInfo.semanticTagTraits.Add(k_CommonTrait, true);

                var conditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
                var childArgs  = new SetChildArgs(conditions);
                children[conditionsRoot] = childArgs;
            }

            // Make relations and store the expected trait values that will match them
            var childrenList = new List <IMRObject>(children.Keys);

            for (var i = 0; i < k_RelationCount; ++i)
            {
                var child1 = childrenList[i];
                var child2 = childrenList[i + 1];

                var floatRelation = gameObject.AddComponent <FloatRelation>();
                floatRelation.Initialize(child1, child2, k_FloatTrait1, k_FloatTrait2);
                childrenExpectedMatchInfo[child1].floatTraits[floatRelation.child1TraitName] = i;
                childrenExpectedMatchInfo[child2].floatTraits[floatRelation.child2TraitName] = i + 1f;

                var vector2Relation = gameObject.AddComponent <Vector2Relation>();
                vector2Relation.Initialize(child1, child2, k_Vector2Trait1, k_Vector2Trait2);
                childrenExpectedMatchInfo[child1].vector2Traits[vector2Relation.child1TraitName] = new Vector2(i, 0f);
                childrenExpectedMatchInfo[child2].vector2Traits[vector2Relation.child2TraitName] = new Vector2(i + 1f, 0f);
            }

            result = new SetQueryResult(QueryMatchID.Generate(), childrenList);

            var relations = new Relations(gameObject, children);

            s_SetArgs = new SetQueryArgs {
                relations = relations
            };
            return(relations);
        }