internal AutoAssign(XmlData dat)
     : base("autoId")
 {
     this.dat = dat;
     nextSignedId = GetValue<ushort>("nextSigned", "24576"); //0x6000
     nextFullId = GetValue<ushort>("nextFull", "32768");     //0x8000
 }

		public static void CreateImageAndContentMetaData(string filePath, Size pixelSize,
			XmlData image)
		{
			CreateImage(filePath, pixelSize);
			image.AddAttribute("FileSize", new FileInfo(filePath).Length);
			image.AddAttribute("PixelSize", pixelSize.ToString());
		}

 private static Guid GetAppGuid(XmlData appInfoData)
 {
     string appGuidString = appInfoData.GetAttributeValue(XmlAttributeNameOfAppGuid);
     if (String.IsNullOrEmpty(appGuidString))
         throw new AppInfoDataMissing(XmlAttributeNameOfAppGuid);
     return new Guid(appGuidString);
 }

		private static Stream CreateMockCreepProperties()
		{
			var xmlData = new XmlData("CreepProperties");
			xmlData.AddChild(CreateTestCottonCreep());
			xmlData.AddChild(CreateTestGlassCreep());
			return new XmlFile(xmlData).ToMemoryStream();
		}

		private string GetAppPackageFilePath(XmlData appInfoData)
		{
			string fileName = appInfoData.GetAttributeValue(XmlAttributeNameOfFileName);
			if (String.IsNullOrEmpty(fileName))
				throw new AppInfoDataMissing(XmlAttributeNameOfFileName); // ncrunch: no coverage
			return Path.Combine(StorageDirectory, fileName);
		}

 private static void AssertBasicContentMetaData(XmlData xmlMetaData, ContentMetaData metaData)
 {
     AssertMinimumContentMetaData(xmlMetaData, metaData.Name, metaData.Type.ToString(),
         metaData.LastTimeUpdated);
     Assert.AreEqual(metaData.LocalFilePath, xmlMetaData.GetAttributeValue("LocalFilePath"));
     Assert.AreEqual(metaData.FileSize.ToString(), xmlMetaData.GetAttributeValue("FileSize"));
 }

		private static Dictionary<TowerType, float> ParseTypeDamageModifier(XmlData boss)
		{
			return
				boss.GetChild("Modifiers").Attributes.ToDictionary(
					attribute => (TowerType)Enum.Parse(typeof(TowerType), attribute.Name),
					attribute => attribute.Value.Convert<float>());
		}

		public FontDescription(XmlData data)
		{
			this.data = data;
			GlyphDictionary = new Dictionary<char, Glyph>();
			LoadFromXmlData();
			converter = new TextConverter(GlyphDictionary, PixelLineHeight);
		}

 public void AddAttributeObject()
 {
     var root = new XmlData("root");
     root.AddAttribute("attribute", DayOfWeek.Friday);
     Assert.AreEqual(1, root.Attributes.Count);
     Assert.AreEqual(new XmlAttribute("attribute", "Friday"), root.Attributes[0]);
 }

 public void AddAttribute()
 {
     var root = new XmlData("root");
     root.AddAttribute("attribute", "value");
     Assert.AreEqual(1, root.Attributes.Count);
     Assert.AreEqual(new XmlAttribute("attribute", "value"), root.Attributes[0]);
 }

		private void TryLoadAppFromStorageData(XmlData appInfoData)
		{
			AppInfo app = AppInfoExtensions.CreateAppInfo(GetAppPackageFilePath(appInfoData),
				GetAppPlatform(appInfoData), GetAppGuid(appInfoData), GetAppBuildData(appInfoData));
			app.SolutionFilePath = GetAppSolutionFilePath(appInfoData);
			availableApps.Add(app);
		}

		private static Stream CreateMockGroupProperties()
		{
			var xmlData = new XmlData("Groups");
			xmlData.AddChild(CreateTestGroup("Paper2", "Paper, Paper"));
			xmlData.AddChild(CreateTestGroup("Cloth3", "Cloth, Cloth, Cloth"));
			return new XmlFile(xmlData).ToMemoryStream();
		}

        public Chars GetChars(string guid, string password, XmlData data)
        {
            using (var db = new Database())
            {
                Account a = db.Verify(guid, password, data);
                if (a != null)
                {
                    if (a.Banned)
                        return null;
                }

                Chars chrs = new Chars
                {
                    Characters = new List<Char>(),
                    NextCharId = 2,
                    MaxNumChars = 1,
                    Account = a,
                };
                db.GetCharData(chrs.Account, chrs);
                db.LoadCharacters(chrs.Account, chrs);
                chrs.News = db.GetNews(Program.GameData, chrs.Account);
                chrs.OwnedSkins = Utils.GetCommaSepString(chrs.Account.OwnedSkins.ToArray());
                return chrs;
            }
        }

        public static byte[] Convert(XmlData data, string json)
        {
            var obj = JsonConvert.DeserializeObject<json_dat>(json);
            byte[] dat = ZlibStream.UncompressBuffer(obj.data);

            var tileDict = new Dictionary<short, TerrainTile>();
            for (int i = 0; i < obj.dict.Length; i++)
            {
                loc o = obj.dict[i];
                tileDict[(short) i] = new TerrainTile
                {
                    TileId = o.ground == null ? (ushort) 0xff : data.IdToTileType[o.ground],
                    TileObj = o.objs == null ? null : o.objs[0].id,
                    Name = o.objs == null ? "" : o.objs[0].name ?? "",
                    Terrain = TerrainType.None,
                    Region =
                        o.regions == null
                            ? TileRegion.None
                            : (TileRegion) Enum.Parse(typeof (TileRegion), o.regions[0].id.Replace(' ', '_'))
                };
            }

            var tiles = new TerrainTile[obj.width, obj.height];
            using (var rdr = new NReader(new MemoryStream(dat)))
                for (int y = 0; y < obj.height; y++)
                    for (int x = 0; x < obj.width; x++)
                    {
                        tiles[x, y] = tileDict[rdr.ReadInt16()];
                    }
            return WorldMapExporter.Export(tiles);
        }

		protected override Stream GetDevicesXmlStream()
		{
			var devicesXmlData = new XmlData("Devices");
			devicesXmlData.AddChild(EmulatorTestExtensions.CreateDefaultDeviceData());
			devicesXmlData.AddChild(EmulatorTestExtensions.CreateWindows8DeviceData());
			return new XmlFile(devicesXmlData).ToMemoryStream();
		}

 public void GetChild()
 {
     var root = new XmlData("root");
     new XmlData("child1", root);
     var child2 = new XmlData("child2", root);
     Assert.AreEqual(child2, root.GetChild("child2"));
 }

		protected override AgentData ParseData(XmlData boss)
		{
			return new BossData((BossType)Enum.Parse(typeof(BossType), boss.GetAttributeValue("Type")),
				boss.GetAttributeValue("Name"), boss.GetAttributeValue("MaxHp", 0.0f),
				boss.GetAttributeValue("Speed", 0.0f), boss.GetAttributeValue("Resistance", 0.0f),
				boss.GetAttributeValue("Gold", 0), ParseTypeDamageModifier(boss));
		}

		private static void AddChild1(XmlData root)
		{
			var child1 = new XmlData("Child1");
			child1.AddAttribute("Attr1", "Value with space");
			child1.AddAttribute("Attr2", "Value2");
			root.AddChild(child1);
		}

		public void Constructor()
		{
			var root = new XmlData("name");
			Assert.AreEqual("name", root.Name);
			Assert.AreEqual(0, root.Children.Count);
			Assert.AreEqual(0, root.Attributes.Count);
		}

		private static XmlData CreateTestXmlData()
		{
			var root = new XmlData("Root");
			AddChild1(root);
			AddChild2(root);
			return root;
		}