public async Task TestDamageClassDamageAndHeal()
        {
            var server = StartServerDummyTicker(new ServerContentIntegrationOption
            {
                ExtraPrototypes = Prototypes
            });

            await server.WaitIdleAsync();

            var sEntityManager = server.ResolveDependency <IEntityManager>();
            var sMapManager    = server.ResolveDependency <IMapManager>();

            IEntity sDamageableEntity = null;
            IDamageableComponent sDamageableComponent = null;

            await server.WaitPost(() =>
            {
                var mapId       = sMapManager.NextMapId();
                var coordinates = new MapCoordinates(0, 0, mapId);
                sMapManager.CreateMap(mapId);

                sDamageableEntity    = sEntityManager.SpawnEntity(DamageableEntityId, coordinates);
                sDamageableComponent = sDamageableEntity.GetComponent <IDamageableComponent>();
            });

            await server.WaitRunTicks(5);

            await server.WaitAssertion(() =>
            {
                Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(0));

                foreach (var @class in Enum.GetValues <DamageClass>())
                {
                    Assert.That(sDamageableComponent.SupportsDamageClass(@class));

                    var types = @class.ToTypes();

                    foreach (var type in types)
                    {
                        Assert.That(sDamageableComponent.SupportsDamageType(type));
                    }

                    var damageToDeal = types.Count * 5;

                    // Damage
                    Assert.That(sDamageableComponent.ChangeDamage(@class, damageToDeal, true), Is.True);
                    Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal));
                    Assert.That(sDamageableComponent.TryGetDamage(@class, out var classDamage), Is.True);
                    Assert.That(classDamage, Is.EqualTo(damageToDeal));

                    foreach (var type in types)
                    {
                        Assert.That(sDamageableComponent.TryGetDamage(type, out var typeDamage), Is.True);
                        Assert.That(typeDamage, Is.EqualTo(damageToDeal / types.Count));
                    }

                    // Heal
                    Assert.That(sDamageableComponent.ChangeDamage(@class, -damageToDeal, true), Is.True);
                    Assert.That(sDamageableComponent.TotalDamage, Is.Zero);
                    Assert.That(sDamageableComponent.TryGetDamage(@class, out classDamage), Is.True);
                    Assert.That(classDamage, Is.Zero);

                    foreach (var type in types)
                    {
                        Assert.That(sDamageableComponent.TryGetDamage(type, out var typeDamage), Is.True);
                        Assert.That(typeDamage, Is.Zero);
                    }
                }
            });
        }