public void ParsesCruiseControlServerCorrectly()
        {
            var kernel = new StandardKernel();

            var parser = kernel.Get<CruiseControlConfigParser>();

            kernel.Bind<ITimer>().ToConstant(new Mock<ITimer>().Object);
            kernel.Bind<IParser>().ToConstant(new Mock<IParser>().Object).Named("CruiseControl");

            var config = new YamlMappingNode
                             {
                                 {"url", "http://goserver.localdomain:8153/go/cctray.xml"},
                                 {"username", "ci"},
                                 {"password", "secret"}
                             };
            var pipeline1 = new YamlMappingNode {{"name", "Cosby-Kid"}};
            var pipeline2 = new YamlMappingNode { { "name", "Family-Tieman" } };
            var pipelines = new YamlSequenceNode {pipeline1, pipeline2};
            config.Add("pipelines",pipelines);

            var cruiseControlServer = parser.Parse(config) as CruiseControlServer;
            Assert.IsNotNull(cruiseControlServer);
            Assert.IsNotNull(cruiseControlServer.Config);
            var cruiseControlServerconfig = cruiseControlServer.Config;
            Assert.AreEqual("http://goserver.localdomain:8153/go/cctray.xml", cruiseControlServerconfig.URL);
            Assert.AreEqual("ci", cruiseControlServerconfig.Username);
            Assert.AreEqual("secret", cruiseControlServerconfig.Password);
            Assert.IsNotNull(cruiseControlServerconfig.Pipelines);
            Assert.AreEqual(2, cruiseControlServerconfig.Pipelines.Count());
        }

        private static Tuple<string, YamlNode> GetUpdateAttribute(JProperty prop)
        {
            var propValueType = prop.Value.Type;
            var value = string.Empty;

            if (propValueType == JTokenType.Object || propValueType == JTokenType.Array)
            {
                if (propValueType == JTokenType.Array)
                {
                    var nodes = new YamlSequenceNode();
                    foreach(var item in prop.Value as JArray)
                    {
                        var asset = new Asset(item as dynamic);
                        var yamlNode = GetNodes(asset);
                        nodes.Add(yamlNode);
                    }
                    return new Tuple<string, YamlNode>(prop.Name, nodes);
                }

                return new Tuple<string, YamlNode>(prop.Name, new YamlScalarNode(string.Empty));
            }
            else
            {
                value = (prop.Value as JValue).Value.ToString();
                return new Tuple<string, YamlNode>(prop.Name, new YamlScalarNode(value));
            }
        }

        public void ParsesTeamCityServerCorrectly()
        {
            var kernel = new StandardKernel();

            var parser = kernel.Get<TeamCityConfigParser>();

            kernel.Bind<ITimer>().ToConstant(new Mock<ITimer>().Object);
            kernel.Bind<IParser>().ToConstant(new Mock<IParser>().Object).Named("TeamCity");

            var config = new YamlMappingNode
                             {
                                 {"url", "http://localhost"},
                                 {"username", "ci"},
                                 {"password", "secret"}
                             };
            var pipeline1 = new YamlMappingNode {{"name", "bt1"}};
            var pipeline2 = new YamlMappingNode { { "name", "bt2" } };
            var pipelines = new YamlSequenceNode {pipeline1, pipeline2};
            config.Add("pipelines",pipelines);

            var teamCityServer = parser.Parse(config) as TeamCityServer;
            Assert.IsNotNull(teamCityServer);
            Assert.IsNotNull(teamCityServer.Config);
            var teamCityServerConfig = teamCityServer.Config;
            Assert.AreEqual("http://localhost", teamCityServerConfig.URL);
            Assert.AreEqual("ci", teamCityServerConfig.Username);
            Assert.AreEqual("secret", teamCityServerConfig.Password);
            Assert.IsNotNull(teamCityServerConfig.Pipelines);
            Assert.AreEqual(2, teamCityServerConfig.Pipelines.Count());
        }

 public YamlSequenceNodeValueConverter(YamlSequenceNode parent, Type globalType, string label, MemberInfo memberInfo)
 {
     this.parentNode = parent;
     this.globalType = globalType;
     this.label = label;
     this.memberInfo = memberInfo;
 }

        private YamlNode FindSequence(YamlSequenceNode node, string key, object value)
        {
            if (this.IsError) return null;

            foreach (var child in node.Children)
            {
                var mapping = (YamlMappingNode) child;
                foreach (var mappingChild in mapping.Children)
                {
                    if (mappingChild.Key.ToString() == key)
                    {
                        // Found key, check value, otherwise skip this mappingChild
                        if (mappingChild.Value.ToString() == value.ToString())
                        {
                            // Value matches, return mapping
                            return mapping;
                        }
                        else
                        {
                            // Value does not match, skip this child
                            break;
                        }
                    }
                }
            }
            return null;
        }

 private void VisitYamlSequenceNode(YamlSequenceNode yamlNode)
 {
     foreach (var entry in yamlNode.Children)
     {
         if (entry is YamlMappingNode)
             VisitYamlMappingNode((YamlMappingNode)entry);
     }
 }

 static IEnumerable<KeyShortcut> GetKeyShortcuts(YamlSequenceNode groupShortcuts)
 {
     return from entry in groupShortcuts.Children.OfType<YamlMappingNode>()
            from keys in entry.Children.Where(n => n.Key.ToString() == "keys").Take(1).Select(x=>x.Value).OfType<YamlSequenceNode>()
            let name = GetValueByKey(entry, "name")
            from definitions in keys.Children.Select(KeyPressDefinitions).Where(definitions => definitions.Count > 0)
            select new KeyShortcut(name, definitions.ToArray());
 }

        protected override void Visit(YamlSequenceNode sequence)
        {
            var nestedVisitor = new ContextAwareSequenceVisitor(context);
            sequence.Accept(nestedVisitor);

            foreach (var item in nestedVisitor.Items)
            {
                this.items.Add(new KeyValuePair<string, string>(item.Key, item.Value));
            }
        }

 public void Load(YamlSequenceNode CountriesNode)
 {
   foreach( YamlNode childSeq in CountriesNode.Children )
   {
     if( childSeq is YamlMappingNode )
     {
       CountryList.Add( new Country( (YamlMappingNode)childSeq ) );
     }
   }
 }

        protected YamlQuery(YamlQuery parent, bool error, YamlSequenceNode root, string key, object value)
        {
            _path = parent == null ? "" : parent.QueryPath;
            _path += string.Format("{0}:{{{1}}}", key, value);

            // Find sequencing node with matching value
            this.IsError = error;
            if (!error)
            {
                // Find next mapping node
                this.Node = FindSequence(root, key, value);
            }
        }

        protected override void VisitChildren(YamlSequenceNode sequence)
        {
            foreach (var node in sequence.Children)
            {
                this.EnterContext(index.ToString());

                var visitor = new ContextAwareVisitor(context);
                node.Accept(visitor);
                this.items.AddRange(visitor.Items);

                this.ExitContext();
                index++;
            }
        }

        public static FilterCollection parseList(YamlSequenceNode list, Dictionary<string, Filter> filterMap)
        {
            FilterCollection collection = new FilterCollection();

            if (list != null)
            {
                foreach (YamlNode node in list.Children)
                {
                    parseFilterNode(collection, filterMap, node);
                }
            }

            return collection;
        }

        public static ValidationCollection parseList(YamlSequenceNode list, Dictionary<string, Validator> validatorMap)
        {
            ValidationCollection collection = new ValidationCollection();

            if (list != null)
            {
                foreach (YamlNode node in list.Children)
                {
                    parseFilterNode(collection, validatorMap, node);
                }
            }

            return collection;
        }

		public void Reload(YamlNode node)
		{
			yamlNode = node;
			mappingNode = yamlNode as YamlMappingNode;
			sequenceNode = yamlNode as YamlSequenceNode;
			scalarNode = yamlNode as YamlScalarNode;
			children = null;
		}

            protected override void UpgradeAsset(AssetMigrationContext context, int currentVersion, int targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
            {
                var entities = asset.Hierarchy.Entities;
                var designEntities = new YamlSequenceNode();
                asset.Hierarchy.Entities = designEntities;

                foreach (var entity in entities)
                {
                    var designEntity = new YamlMappingNode();
                    dynamic dynamicDesignEntity = new DynamicYamlMapping(designEntity);
                    dynamicDesignEntity.Entity = entity;
                    designEntities.Add(designEntity);
                }
            }

 public DynamicYamlArray(YamlSequenceNode node)
 {
     this.node = node;
 }

		protected override void Visit(YamlSequenceNode sequence)
		{
			WriteIndent();
			Console.WriteLine("Visit(YamlSequenceNode, {0}, {1})", sequence.Anchor, sequence.Tag);
			indent++;
		}

		protected override void Visited(YamlSequenceNode sequence)
		{
			indent--;
			WriteIndent();
			Console.WriteLine("Visited(YamlSequenceNode)");
		}

        private YamlNode Build()
        {
            var root = new YamlMappingNode();

            root.Add("from", _assetType);

            if (SelectFields.Count > 0)
            {
                var select = new YamlSequenceNode();

                var attributes = SelectFields.Where(s => s is string);
                foreach(var attr in attributes)
                {
                    var val = attr as string;
                    select.Add(val);
                }

                var nestedBuilders = SelectFields.Where(s => s is QueryApiQueryBuilder);
                foreach (var item in nestedBuilders)
                {
                    var nestedBuilder = item as QueryApiQueryBuilder;
                    select.Add(nestedBuilder.Build());
                }

                root.Add("select", select);
            }

            if (WhereCriteria.Count > 0)
            {
                var whereNodes = new YamlMappingNode();

                foreach (var criterion in WhereCriteria)
                {
                    whereNodes.Add(criterion.AttributeName, criterion.MatchValue.ToString());
                }

                root.Add("where", whereNodes);
            }

            if (FilterCriteria.Count > 0)
            {
                var filterNodes = new YamlSequenceNode();

                foreach (var criterion in FilterCriteria)
                {
                    filterNodes.Add($"{criterion.AttributeName}{criterion.Operator.Token}\"{criterion.MatchValue.ToString()}\"");
                }

                root.Add("filter", filterNodes);
            }

            return root;
        }

 /// <summary>
 /// Called when this object is visiting a <see cref="YamlSequenceNode"/>.
 /// </summary>
 /// <param name="sequence">
 /// The <see cref="YamlSequenceNode"/> that is being visited.
 /// </param>
 public virtual void Visit(YamlSequenceNode sequence)
 {
     VisitChildren(sequence);
 }