public void DontSimplifySegmentStruct()
		{
			StructureType s = new StructureType(null, 0) { Fields = { { 0, PrimitiveType.Int32 } } };
			s.IsSegment = true;
			DataType dt = s.Simplify();
			Assert.AreEqual("(segment (0 int32 dw0000))", dt.ToString());
		}

		public void UnifyStructsSameSize()
		{
			StructureType s1 = new StructureType(null, 20);
			StructureType s2 = new StructureType(null, 20);
			StructureType m = (StructureType) un.Unify(s1, s2);
			Assert.AreEqual(20, m.Size);
		}

 public void StrFldMerger_SingleMember()
 {
     StructureType str = new StructureType("foo", 0);
     str.Fields.Add(4, PrimitiveType.Word16);
     DataType dt = sfm.Merge(str);
     Assert.AreEqual("(struct \"foo\" (4 word16 w0004))", dt.ToString());
 }

 public override DataType VisitStructure(StructureType str)
 {
     if (visitedTypes.Contains(str))
         return str;
     visitedTypes.Add(str);
     return base.VisitStructure(str);
 }

 public AddStructure(Position position, StructureType structureType, Facing frontFace)
     : this()
 {
     Position = position;
     StructureType = structureType;
     FrontFace = frontFace;
 }

 public DataType CreateDataType()
 {
     var str = new StructureType("foo", 0);
     str.Fields.Add(0, PrimitiveType.Int32);
     str.Fields.Add(4, new Pointer(str, 4));
     return str;
 }

		public void Setup()
		{
            var image = new LoadedImage(Address.Ptr32(0x00100000), new byte[1024]);
            var arch = new FakeArchitecture();
            var program = new Program
            {
                Image = image,
                Architecture = arch,
                ImageMap = image.CreateImageMap(),
                Platform = new DefaultPlatform(null, arch),
            };
            store = program.TypeStore;
            factory = program.TypeFactory;
            globals = program.Globals;
			store.EnsureExpressionTypeVariable(factory, globals);

			StructureType s = new StructureType(null, 0);
			s.Fields.Add(0x00100000, PrimitiveType.Word32, null);

			TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals);
			EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals);
			eqGlobals.DataType = s;
			globals.TypeVariable.DataType = new Pointer(eqGlobals, 4);
			globals.DataType = globals.TypeVariable.DataType;

            tcr = new TypedConstantRewriter(program);
		}

		public void Setup()
		{
            mem = new MemoryArea(Address.Ptr32(0x00100000), new byte[1024]);
            var arch = new FakeArchitecture();
            this.program = new Program
            {
                Architecture = arch,
                SegmentMap = new SegmentMap(
                    mem.BaseAddress,  
                    new ImageSegment(".text", mem, AccessMode.ReadWriteExecute)),
                Platform = new DefaultPlatform(null, arch),
            };
            store = program.TypeStore;
            factory = program.TypeFactory;
            globals = program.Globals;
			store.EnsureExpressionTypeVariable(factory, globals);

			StructureType s = new StructureType(null, 0);
			s.Fields.Add(0x00100000, PrimitiveType.Word32, null);

			TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals);
			EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals);
			eqGlobals.DataType = s;
			globals.TypeVariable.DataType = new Pointer(eqGlobals, 4);
			globals.DataType = globals.TypeVariable.DataType;
		}

	public BlockStructure(string DefaultType) {
		if (DefaultType == "Tree") {
			MyBlocks.Size = new Vector3 (6, 9, 6);
			MyType = StructureType.Tree;
		}
		MyBlocks.InitilizeData ();
		UpdateBlockStructureWithType ();
	}

		public void UnifyStructs()
		{
            StructureType m1 = new StructureType { Fields = { { 4, PrimitiveType.Word32 } } };
            StructureType m2 = new StructureType { Fields = { { 8, PrimitiveType.Word32 } } };

			StructureType m = (StructureType) un.Unify(m1, m2);
			Assert.AreEqual(2, m.Fields.Count);
		}

		public void MergeStaggeredArrays2()
		{
			StructureType s = new StructureType(null, 0);
			AddArrayField(s, 0, 8, PrimitiveType.Int32);
			AddArrayField(s, 4, 8, PrimitiveType.Int32);
			trans.MergeStaggeredArrays(s);
			Assert.AreEqual("(struct (0 (arr (struct 0008 (0 int32 dw0000) (4 int32 dw0004))) a0000))", s.ToString());
		}

		private StructureType BuildStaggeredArrays()
		{
			StructureType s = new StructureType(null, 0);
			s.Fields.Add(4, new ArrayType(new StructureType(null, 20) { Fields = { { 0, PrimitiveType.Int32 } } }, 0));
			s.Fields.Add(8, new ArrayType(new StructureType(null, 20) { Fields = { { 0, PrimitiveType.Real64} } }, 0));
			s.Fields.Add(12,new ArrayType(new StructureType(null, 20) { Fields = { { 0, PrimitiveType.Byte } } }, 0));
			return s;
		}

 public void DTS_issue_113()
 {
     // This recursive structure shoudn't blow up the stack.
     var str = new StructureType("foo", 0);
     str.Fields.Add(0, new Pointer(str, 4), "bar");
     var sStr = str.Accept(new DataTypeSerializer());
     Assert.AreEqual("struct(foo, (0, bar, ptr(struct(foo, ))))", sStr.ToString());
 }

		public void MergeOffsetStructures()
		{
			StructureType s1 = new StructureType(null, 20);
			s1.Fields.Add(0, PrimitiveType.Int32);
			StructureType s2 = new StructureType(null, 20);
			s2.Fields.Add(0, PrimitiveType.Real32);
			DataType dt = trans.MergeOffsetStructures(s1, 4, s2, 8);
			Assert.AreEqual("(struct 0014 (0 int32 dw0000) (4 real32 r0004))", dt.ToString());
		}

 public Structure(Vector2Int location, User owner, StructureType type)
 {
     _commands = new Dictionary<string, Command>();
     Squads = new List<Squad>();
     Enabled = true;
     Location = location;
     Owner = owner;
     Type = type;
 }

 public void HasNoCoincidentFields()
 {
     StructureType s = new StructureType(null, 0);
     s.Fields.Add(4, new TypeVariable(1));
     s.Fields.Add(5, PrimitiveType.Word16);
     Assert.AreEqual(2, s.Fields.Count);
     TypeTransformer trans = new TypeTransformer(factory, null, null);
     Assert.IsFalse(trans.HasCoincidentFields(s));
 }

        public Structure(StructureType structureType, int _floor)
        {
            IronTowerDBContext db = new IronTowerDBContext();

            //   Game game = db.Games.FirstOrDefault();
            //    this.Game = game;

            switch (structureType)
            {
                case StructureType.Laundry:
                    this.Floor = _floor;
                    this.Income = 1;
                    this.InitialCost = 1;
                    this.IsResidence = false;
                    this.PopulationCost = 1;
                    this.SupportedPopulation = 0;
                    this.Type = StructureType.Laundry;
                    this.UpKeep = 1;
                    break;

                case StructureType.Restaurant:
                    this.Floor = _floor;
                    this.Income = 2;
                    this.InitialCost = 1;
                    this.IsResidence = false;
                    this.PopulationCost = 3;
                    this.SupportedPopulation = 0;
                    this.Type = StructureType.Restaurant;
                    this.UpKeep = 1;
                    break;

                case StructureType.AmusementPark:
                    this.Floor = _floor;
                    this.Income = 3;
                    this.InitialCost = 3;
                    this.IsResidence = false;
                    this.PopulationCost = 1;
                    this.SupportedPopulation = 0;
                    this.Type = StructureType.AmusementPark;
                    this.UpKeep = 1;
                    break;

                case StructureType.Residence:
                    this.Floor = _floor;
                    this.Income = 0;
                    this.InitialCost = 1;
                    this.IsResidence = true;
                    this.PopulationCost = 0;
                    this.SupportedPopulation = 5;
                    this.Type = StructureType.Residence;
                    this.UpKeep = 1;
                    break;

                default:
                    break;
            }
        }

		private StructureType BuildDistinctArrays()
		{
			StructureType s = new StructureType(null, 0);
			AddArrayField(s, 0, 20, PrimitiveType.Int32);
			AddArrayField(s, 4, 20, PrimitiveType.Int32);
			AddArrayField(s, 40, 20, PrimitiveType.Real32);
			AddArrayField(s, 44, 20, PrimitiveType.Real32);
			return s;
		}

 public void StrFldMerger_FindOverlappingCluster()
 {
     StructureType str = new StructureType("foo", 0);
     str.Fields.Add(2, PrimitiveType.Word32);
     str.Fields.Add(4, PrimitiveType.Word32);
     foreach (List<StructureField> cluster in sfm.GetOverlappingClusters(str.Fields))
     {
         Assert.AreEqual(2, cluster.Count);
     }
 }

 public void CmpRecursiveEqualStructs()
 {
     // struct str1{struct *str2} == struct str2{struct *str1}
     StructureType s1 = new StructureType();
     StructureType s2 = new StructureType();
     s1.Fields.Add(0, new Pointer(s2, 4));
     s2.Fields.Add(0, new Pointer(s1, 4));
     DataTypeComparer c = new DataTypeComparer();
     Assert.AreEqual(0, c.Compare(s1, s2));
 }