public IntegerListProperty(PropertyHolder parent, string name)
   : base(parent, name)
 {
   IntegerListProperty integerListProperty = this;
   this.valueSplit = ", ";
   this.delimiter = ",";
 }

 internal LoadedScene(string name, PropertyHolder values, SceneLoader loader, Game game, LoaderUtility loaderUtil)
     : base(values, loaderUtil)
 {
     Loader = loader;
     Game = game;
     Name = name;
 }

 public FileProperty(PropertyHolder parent, string name, string defaultValue)
   : base((Class) ClassLiteral<String>.Value, parent, name, (object) defaultValue)
 {
   FileProperty fileProperty = this;
   JFileChooser.__\u003Cclinit\u003E();
   this.chooser = new JFileChooser((string) this.getValue());
 }

    public static int Main(string[] args)
    {
        PropertyHolder propHold = new PropertyHolder(5);

        Console.WriteLine("Property Value: {0}", propHold.SomeProperty);

        return 0;
    }

 public BooleanProperty(PropertyHolder element, string name)
   : base((Class) ClassLiteral<Boolean>.Value, element, name)
 {
   BooleanProperty booleanProperty = this;
   this.box = new JCheckBox();
   this.checkbox = new DefaultCellEditor(this.box);
   this.renderer = (TableCellRenderer) new BooleanProperty\u00241(this);
 }

    public static int Main(string[] args)
    {
        PropertyHolder propHold = new PropertyHolder();

        propHold.SomeProperty = 5;

        return 0;
    }

 protected internal Property(PropertyHolder element, string name)
 {
   base.\u002Ector();
   Property property = this;
   this.element = element;
   this.name = name;
   element.getProperties().put((object) name, (object) this);
 }

        public void AutoDataProvidesMultipleObjects(PropertyHolder<Version> ph, SingleParameterType<OperatingSystem> spt)
        {
            Assert.NotNull(ph);
            Assert.NotNull(ph.Property);

            Assert.NotNull(spt);
            Assert.NotNull(spt.Parameter);
        }

 public MultiProperty(PropertyHolder holder, string name)
   : base(holder, name)
 {
   MultiProperty multiProperty = this;
   this.comboBox = new JComboBox();
   this.cellEditor = new DefaultCellEditor(this.comboBox);
   this.values = (Map) new HashMap();
   this.renderer = (TableCellRenderer) new MultiProperty\u00241(this);
 }

 public void SutIsGuardClauseCommand()
 {
     // Fixture setup
     var dummyOwner = new PropertyHolder<object>();
     var dummyProperty = dummyOwner.GetType().GetProperty("Property");
     // Exercise system
     var sut = new PropertySetCommand(dummyProperty, dummyOwner);
     // Verify outcome
     Assert.IsAssignableFrom<IGuardClauseCommand>(sut);
     // Teardown
 }

        public PropertyHolder GetProperties(ParseTreeNode node)
        {
            PropertyHolder propertyHolder = new PropertyHolder();

            if (grammar.Prototype == node.Term || grammar.Entity == node.Term)
                node = node.ChildNodes.First(child => child.Term == grammar.EntityDefinition);

            foreach (ParseTreeNode property in grammar.GetOfType(node, grammar.Properties))
                propertyHolder.AddValue(property.ChildNodes[0].Token.ValueString, property.ChildNodes[1]);

            return propertyHolder;
        }

 public void PropertyInfoIsCorrect()
 {
     // Fixture setup
     var dummyOwner = new PropertyHolder<object>();
     var propertyInfo = dummyOwner.GetType().GetProperty("Property");
     var sut = new PropertySetCommand(propertyInfo, dummyOwner);
     // Exercise system
     PropertyInfo result = sut.PropertyInfo;
     // Verify outcome
     Assert.Equal(propertyInfo, result);
     // Teardown
 }

 public void OwnerIsCorrect()
 {
     // Fixture setup
     var owner = new PropertyHolder<object>();
     var dummyProperty = owner.GetType().GetProperty("Property");
     var sut = new PropertySetCommand(dummyProperty, owner);
     // Exercise system
     var result = sut.Owner;
     // Verify outcome
     Assert.Equal(owner, result);
     // Teardown
 }

 public void RequestedTypeIsCorrect()
 {
     // Fixture setup
     var dummyOwner = new PropertyHolder<Version>();
     var property = dummyOwner.GetType().GetProperty("Property");
     var sut = new PropertySetCommand(property, dummyOwner);
     // Exercise system
     var result = sut.RequestedType;
     // Verify outcome
     Assert.Equal(property.PropertyType, result);
     // Teardown
 }

 public void ExecuteAssignsValueToOwnerProperty()
 {
     // Fixture setup
     var owner = new PropertyHolder<object>();
     var property = owner.GetType().GetProperty("Property");
     var sut = new PropertySetCommand(property, owner);
     var value = new object();
     // Exercise system
     sut.Execute(value);
     // Verify outcome
     Assert.Equal(value, owner.Property);
     // Teardown
 }

 public void CreateExceptionReturnsExceptionWithCorrectMessage()
 {
     // Fixture setup
     var dummyOwner = new PropertyHolder<Version>();
     var dummyProperty = dummyOwner.GetType().GetProperty("Property");
     var sut = new PropertySetCommand(dummyProperty, dummyOwner);
     // Exercise system
     var message = Guid.NewGuid().ToString();
     var result = sut.CreateException(message);
     // Verify outcome
     var e = Assert.IsAssignableFrom<GuardClauseException>(result);
     Assert.Contains(message, e.Message);
     // Teardown
 }

        public void ExecuteWillAssignCorrectPropertyValue()
        {
            // Fixture setup
            var expectedPropertyValue = new object();
            var container = new DelegatingSpecimenContext { OnResolve = r => expectedPropertyValue };

            var sut = new AutoPropertiesCommand<PropertyHolder<object>>();

            var specimen = new PropertyHolder<object>();
            // Exercise system
            sut.Execute(specimen, container);
            // Verify outcome
            Assert.Equal(expectedPropertyValue, specimen.Property);
            // Teardown
        }

        private static void PrintDescription(String propName, PropertyHolder prop, OutputDevice output)
        {
            if (prop.ShortDescription != null) {
                output.WriteBold("PROPERTY");
                output.WriteLine();
                output.WriteLine("\t" + propName + " : " + prop.ShortDescription);
                output.WriteLine();
            }

            String desc = prop.LongDescription;
            if (desc != null) {
                output.WriteBold("DESCRIPTION");
                output.WriteLine();
                output.WriteLine(desc);
            } else {
                output.WriteLine("no detailed help for '" + propName + "'");
            }
        }

        internal LoadedEntity(string name, PropertyHolder values, int id, IEnumerable<string> prototypes, LoaderUtility loaderUtil)
            : base(values, loaderUtil)
        {
            Name = name;
            this.id = id;
            foreach (string prototype in prototypes)
            {
                isExactType.Add(prototype);
                isType.Add(prototype);
                isType.AddRange(Prototypes[prototype].isType);
            }

            //it is a prototype
            #if !TEST
            if(name != null && Prototypes.ContainsKey(name)) Game.CurrentGame.Die("The prototype " + name + " was already defined");
            #endif
            if (id < 0) Prototypes[name] = this;
        }

        internal static LoadedManager GetLoadedManager(string type, LoadedScene ls, PropertyHolder values, LoaderUtility loaderUtil)
        {
            Dictionary<string, LoadedManager> managersByName;

            if(!ManagerMap.TryGetValue(ls, out managersByName))
            {
                ManagerMap[ls] =  managersByName = new Dictionary<string, LoadedManager>();
            }

            LoadedManager loadedManager;
            if (!managersByName.TryGetValue(type, out loadedManager))
            {
                loadedManager = new LoadedManager(type, values, loaderUtil);
                managersByName[type] = loadedManager;
            }
            else
            {
                if (values != null) loadedManager.Values.AddRange(values);
            }
            return loadedManager;
        }