public void ToPrettyString_Works()
        {
            var metadata = new MetaData();
            metadata.BuildType = BuildType.Debug;
            metadata.ClrVersion = "3.0";
            metadata.FullName = "Assembly.dll";
            metadata.Platform = Platform.x64;
            metadata.References = new[] { "mscorlib.dll" };
            metadata.Type = AssemblyType.ConsoleApp;
            metadata.Version = "1.0";

            string expected =
            @"General:
            FullName = Assembly.dll
            Version = 1.0
            Platform = x64
            BuildType = Debug
            CLR Version = 3.0
            Type = ConsoleApp

            References:
            mscorlib.dll

            Attributes:
            ";

            Assert.AreEqual(expected, metadata.ToPrettyString());
        }

        public Flv(FileInfo file, bool generateMetadata)
        {
            _file = file;
            _generateMetadata = generateMetadata;
            int count = 0;

            if (!_generateMetadata)
            {
                try
                {
                    FlvReader reader = new FlvReader(_file);
                    ITag tag = null;
                    while (reader.HasMoreTags() && (++count < 5))
                    {
                        tag = reader.ReadTag();
                        if (tag.DataType == IOConstants.TYPE_METADATA)
                        {
                            if (_metaService == null) _metaService = new MetaService(_file);
                            _metaData = _metaService.ReadMetaData(tag.Body);
                        }
                    }
                    reader.Close();
                }
                catch (Exception ex)
                {
#if !SILVERLIGHT
                    log.Error("An error occured looking for metadata:", ex);
#endif
                }
            }
        }

        public Stream RenderHTML(ICollection<Result> results, MetaData metaData)
        {
            RenderMetaData(metaData);
            var body = BaseTemplate.DocumentNode.SelectSingleNode("//body");
            body.ChildNodes.Add(MetaDataTemplate.DocumentNode);

            int i = 0;
            foreach (var r in results)
            {
                var div = HtmlNode.CreateNode("<div></div>");
                div.CopyFrom(TableTemplate.DocumentNode.SelectSingleNode("//div"), false);
                div.InnerHtml = div.InnerHtml.Replace("{{CLASS_NAME}}", r.ClassName);
                foreach (var ri in r.Items)
                {
                    var beforeCol = ri.Before.Split(' ');
                    string before = beforeCol.Length > 1 ? String.Format("<span class=\"datatype\"> {0} </span>{1}", beforeCol[0], beforeCol[1]) : ri.Before;

                    var afterCol = ri.After.Split(' ');
                    string after = afterCol.Length > 1 ? String.Format("<span class=\"datatype\"> {0} </span>{1}", afterCol[0], afterCol[1]) : ri.After;

                    string type = String.Format("<span class=\"{0}\">{0}</span", ri.Type);
                    var node = HtmlNode.CreateNode(String.Format("<tr class=\"{0} child\"><td>{1}</td><td>{2}</td><td>{3}</td></tr>", i % 2 == 0 ? "even" : "odd", type, before, after));
                    div.SelectSingleNode("//table").ChildNodes.Add(node);
                    i++;
                }
                i = 0;
                body.ChildNodes.Add(div);
            }

            var stream = new MemoryStream();
            BaseTemplate.Save(stream);

            return stream;
        }

 public Command(string identifier, string value, StatementType statementType, MetaData<IMeta> metaData, bool rcon)
     : base(statementType, metaData)
 {
     Identifier = identifier;
     Value = value;
     RCON = rcon;
 }

    public static MetaData GetMetaData(string text)
    {
        Hashtable table = text.hashtableFromJson();
        MetaData meta = new MetaData((Hashtable)table["meta"]);

        return meta;
    }

 internal static void FillCommonData(ShellFolder shell, MetaData data)
 {
     if (shell.IsFileSystemObject)
     {
         data.Add(new MetaEntry { Name = FileMetaData.ModifiedDate.Name, Value = shell.Properties.GetProperty(SystemProperties.System.DateModified).ValueAsObject });
         data.Add(new MetaEntry { Name = FileMetaData.Type.Name, Value = shell.Properties.GetProperty(SystemProperties.System.ItemTypeText).ValueAsObject });
     }
 }

 protected MapObject(long id)
 {
     ID = id;
     Visgroups = new List<int>();
     AutoVisgroups = new List<int>();
     Children = new Dictionary<long, MapObject>();
     MetaData = new MetaData();
 }

 public ItemVM(IItemProvider provider, ContainerVM parent, string name, bool canRename)
 {
     Provider = provider;
     Parent = parent;
     _name = name;
     CanRename = canRename;
     MetaData = new MetaData();
 }

 private void TcpClient_onMessage(MetaData md, string msg)
 {
     switch(md.Action)
     {
         case MetaData.Actions.register:
             priority = Int32.Parse(msg);
             Console.WriteLine("Получен порядковый номер " + msg);
             break;
     }
 }

 public override void ReadBlock(FlvContext context)
 {
     base.ReadBlock(context);
     //var br = context.Reader;
     //var dat = br.ReadBytes((int)this.Header.DataLength);
     //data = new MetaData(dat);
     data = new MetaData(context, this.Header.DataLength);
     this.Size += this.Header.DataLength;
     context.CurrentPostion += this.Size;
 }

        public void Construct_MetaData_with_Field_array()
        {
            var fields = new []
                {
                    new Field("Test_Field_1", DataType.adInteger),
                    new Field("Test_Field_2", DataType.adVarChar)
                };
            var metaData = new MetaData(fields);

            Assert.That(metaData.Fields, Is.EqualTo(fields));
        }

        public void AddMetaData(MetaData metaData)
        {
            IEnumerable<Attribute> attributes = CreateTextFramesFromMetaData(metaData);

            foreach (var attribute in attributes)
            {
                //TODO: needs testing
                if (!String.IsNullOrEmpty(attribute.Value))
                {
                    _container.Add(attribute);
                }
            }
        }

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="writer">Symbol writer</param>
		/// <param name="pdbState">PDB state</param>
		/// <param name="metaData">Meta data</param>
		public PdbWriter(ISymbolWriter2 writer, PdbState pdbState, MetaData metaData) {
			if (writer == null)
				throw new ArgumentNullException("writer");
			if (pdbState == null)
				throw new ArgumentNullException("pdbState");
			if (metaData == null)
				throw new ArgumentNullException("metaData");
			this.writer = writer;
			this.pdbState = pdbState;
			this.metaData = metaData;
			this.module = metaData.Module;
			writer.Initialize(metaData);
		}

        public void SetUp()
        {
            _metaData = new MetaData(new[]
                {
                    new Field("First_Field", DataType.adInteger),
                    new Field("Second_Field", DataType.adVarChar, 2014)
                });

            _fakeData = new List<object[]>
                {
                    new object[] { 1, "First" },
                    new object[] { 2, "Second" }
                };
        }

 /// <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>
 public MetaData(MetaData metadata)
 {
     if (metadata != null)
     {
         this.AlbumArtist = metadata.AlbumArtist;
         this.Artist = metadata.Artist;
         this.Comment = metadata.Comment;
         this.Composer = metadata.Composer;
         this.Description = metadata.Description;
         this.Genre = metadata.Genre;
         this.LongDescription = metadata.LongDescription;
         this.Name = metadata.Name;
         this.ReleaseDate = metadata.ReleaseDate;
     }
 }

        public Question ReconstructQuestion(QB qb, MetaData meta)
        {
            Question question = new Question();

            question.QuestionID = qb.QuestionID;
            question.Category = CategoryRepository.Find(qb.CategoryID);
            question.Source = qb.Source;
            question.CreatedUserName = qb.CrUserName;
            question.CreatedTime = qb.CrTime;
            if (meta != null)
            {
                question.Meta = meta;
            }

            return question;
        }

        private static MetaData ParseThread(string path)
        {
            if (!Directory.Exists(path))
                throw new MetaParseException("Directory not found: {0}", path);

            MetaData meta = new MetaData();
            meta.Type = MetaType.Directory;
            meta.Path = path;
            //meta.Data = new Dictionary<MetaKey, object>();
            //meta.Data[MetaKey.FileName] = Path.GetFileName(path);
            //meta.Data[MetaKey.OriginalName] = meta.Data[MetaKey.FileName];
            //meta.Data[MetaKey.Size] = GetFileSize(path);
            //meta.Data[MetaKey.Date] = File.GetCreationTime(path);
            //meta.Data[MetaKey.Tags] = new string[0];
            return meta;
        }

        public Result CreateQuestion(string categoryIDString, string source , string userName,MetaData meta, out Question question)
        {
            var qd = QuestionRepository.QuestionFactory.CreateQuestion(categoryIDString, source, userName, meta);

            var res = QuestionRepository.Insert(qd);

            if (res.IsSuccess)
            {
                question = qd;
            }
            else
            {
                question = null;
            }

            return res;
        }

        public Question CreateQuestion(string categoryIDString, string source, string userName, MetaData meta)
        {
            long categoryID = Convert.ToInt64(categoryIDString);
            var category = CategoryRepository.Find(categoryID);

            Question question = new Question();
            question.QuestionID = IDProvider.GetNewId("QuestionID");
            question.CreatedTime = TimeProvider.Now;
            question.CreatedUserName = userName;
            question.Category = category;
            question.Source = source;

            meta.AlterWiki("Answer", userName, new KEYID("QuestionAnswer", question.QuestionID));

            question.Meta = meta;

            return question;
        }

        private static MetaData ParseThread(string filename, MetaType type)
        {
            if (!File.Exists(filename))
                throw new MetaParseException("File not found: {0}", filename);

            MetaData meta = new MetaData();
            meta.Type = type;
            meta.Path = filename;
            meta.Data = new Dictionary<MetaKey, object>();
            meta.Data[MetaKey.FileName] = Path.GetFileName(filename);
            meta.Data[MetaKey.OriginalName] = meta.Data[MetaKey.FileName];
            meta.Data[MetaKey.Size] = GetFileSize(filename);
            meta.Data[MetaKey.DateCreated] = File.GetCreationTime(filename);
            meta.Data[MetaKey.DateModified] = File.GetLastWriteTime(filename);
            meta.Data[MetaKey.Timestamp] = meta.Data[MetaKey.DateModified];
            meta.Data[MetaKey.Tags] = new string[0];
            return meta;
        }