Initial work

PkmnLibRSharpTests/StaticData/AbilityTests.cs

@@ -0,0 +1,35 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class AbilityTests
+    {
+        [Test]
+        public void AbilityGetName([Values("foo", "bar", "", "zet", "xy")] string name)
+        {
+            using var ability = new Ability(name, "", Array.Empty<EffectParameter>());
+            Assert.AreEqual(name, ability.Name);
+        }
+
+        [Test]
+        public void AbilityGetEffect([Values("foo", "bar", "", "zet", "xy")] string effect)
+        {
+            using var ability = new Ability("", effect, Array.Empty<EffectParameter>());
+            Assert.AreEqual(effect, ability.Effect);
+        }
+
+        [Test]
+        public void AbilityGetParameters()
+        {
+            using var ability = new Ability("", "",
+                new EffectParameter[] { new(100), new(false), new("foobar"), new(true) });
+            Assert.AreEqual(4, ability.ParameterLength);
+            Assert.AreEqual(100, ability.GetParameter(0).Data);
+            Assert.AreEqual(false, ability.GetParameter(1).Data);
+            Assert.AreEqual("foobar", ability.GetParameter(2).Data);
+            Assert.AreEqual(true, ability.GetParameter(3).Data);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/EffectParameterTests.cs

@@ -0,0 +1,40 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class EffectParameterTests
+    {
+        [Test]
+        public void BoolParameter([Values(true, false)] bool value)
+        {
+            using var parameter = new EffectParameter(value);
+            Assert.AreEqual(EffectParameter.ParameterType.Bool, parameter.Type);
+            Assert.AreEqual(value, parameter.Data);
+        }
+        
+        [Test]
+        public void IntParameter([Random(long.MinValue, long.MaxValue, 10)] long value)
+        {
+            using var parameter = new EffectParameter(value);
+            Assert.AreEqual(EffectParameter.ParameterType.Int, parameter.Type);
+            Assert.AreEqual(value, parameter.Data);
+        }
+
+        [Test]
+        public void FloatParameter([Random(float.MinValue, float.MaxValue, 10)] float value)
+        {
+            using var parameter = new EffectParameter(value);
+            Assert.AreEqual(EffectParameter.ParameterType.Float, parameter.Type);
+            Assert.AreEqual(value, parameter.Data);
+        }
+
+        [Test]
+        public void StringParameter([Values("foo", "bar", "zet", "x", "")] string value)
+        {
+            using var parameter = new EffectParameter(value);
+            Assert.AreEqual(EffectParameter.ParameterType.String, parameter.Type);
+            Assert.AreEqual(value, parameter.Data);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/MoveDataTests.cs

@@ -0,0 +1,24 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class MoveDataTests
+    {
+        [Test]
+        public void BasicTests()
+        {
+            using var move = new MoveData("foobar", new TypeIdentifier(), MoveCategory.Physical, 68, 23, 56,
+                MoveTarget.Any, -3, null, Array.Empty<string>());
+            Assert.AreEqual("foobar", move.Name);
+            Assert.AreEqual(MoveCategory.Physical, move.Category);
+            Assert.AreEqual(68, move.BasePower);
+            Assert.AreEqual(23, move.Accuracy);
+            Assert.AreEqual(56, move.BaseUsages);
+            Assert.AreEqual(MoveTarget.Any, move.Target);
+            Assert.AreEqual(-3, move.Priority);
+            Assert.AreEqual(null, move.SecondaryEffect);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/NatureTests.cs

@@ -0,0 +1,29 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class NatureTests
+    {
+        [Test]
+        public void InstantiateNatures(
+            [Values] Statistic increasedStat,
+            [Values] Statistic decreasedStat
+            )
+        {
+            var nature = new Nature(increasedStat, decreasedStat);
+            Assert.AreEqual(increasedStat, nature.IncreasedStat);
+            Assert.AreEqual(decreasedStat, nature.DecreasedStat);
+            if (increasedStat == decreasedStat)
+            {
+                Assert.AreEqual(1.0f, nature.GetStatModifier(increasedStat), 0.001f);
+                Assert.AreEqual(1.0f, nature.GetStatModifier(decreasedStat), 0.001f);
+            }
+            else
+            {
+                Assert.AreEqual(1.1f, nature.GetStatModifier(increasedStat), 0.001f);
+                Assert.AreEqual(0.9f, nature.GetStatModifier(decreasedStat), 0.001f);
+            }
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/SecondaryEffectTests.cs

@@ -0,0 +1,20 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class SecondaryEffectTests
+    {
+        [Test]
+        public void BasicTests(
+            [Values(0, 100, 50, 22.5f)] float chance,
+            [Values("foo", "bar", "", "ssdsdsdsdsd")] string effectName
+        )
+        {
+            using var effect = new SecondaryEffect(chance, effectName, Array.Empty<EffectParameter>());
+            Assert.AreEqual(effectName, effect.Name);
+            Assert.AreEqual(chance, effect.Chance);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/StaticStatisticSetTests.cs

@@ -0,0 +1,86 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class StaticStaticStatisticSetTests
+    {
+        [Test]
+        public void ByteStaticStatisticSet([Random(1)] byte hp, [Random(1)] byte attack, [Random(1)] byte defense,
+            [Random(1)] byte specialAttack, [Random(1)] byte specialDefense, [Random(1)] byte speed)
+        {
+            using var set = new StaticStatisticSet<byte>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void UShortStaticStatisticSet([Random(1)] ushort hp, [Random(1)] ushort attack, [Random(1)] ushort defense,
+            [Random(1)] ushort specialAttack, [Random(1)] ushort specialDefense, [Random(1)] ushort speed)
+        {
+            using var set = new StaticStatisticSet<ushort>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void UintStaticStatisticSet([Random(1)] uint hp, [Random(1)] uint attack, [Random(1)] uint defense,
+            [Random(1)] uint specialAttack, [Random(1)] uint specialDefense, [Random(1)] uint speed)
+        {
+            using var set = new StaticStatisticSet<uint>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void SbyteStaticStatisticSet([Random(1)] sbyte hp, [Random(1)] sbyte attack, [Random(1)] sbyte defense,
+            [Random(1)] sbyte specialAttack, [Random(1)] sbyte specialDefense, [Random(1)] sbyte speed)
+        {
+            using var set = new StaticStatisticSet<sbyte>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void ShortStaticStatisticSet([Random(1)] short hp, [Random(1)] short attack, [Random(1)] short defense,
+            [Random(1)] short specialAttack, [Random(1)] short specialDefense, [Random(1)] short speed)
+        {
+            using var set = new StaticStatisticSet<short>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void IntStaticStatisticSet([Random(1)] int hp, [Random(1)] int attack, [Random(1)] int defense,
+            [Random(1)] int specialAttack, [Random(1)] int specialDefense, [Random(1)] int speed)
+        {
+            using var set = new StaticStatisticSet<int>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/StatisticSetTests.cs

@@ -0,0 +1,105 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+
+namespace PkmnLibRSharpTests.StaticData
+{
+    public class StatisticSetTests
+    {
+        [Test]
+        public void ByteStatisticSet([Random(1)] byte hp, [Random(1)] byte attack, [Random(1)] byte defense,
+            [Random(1)] byte specialAttack, [Random(1)] byte specialDefense, [Random(1)] byte speed)
+        {
+            using var set = new StatisticSet<byte>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+        
+        [Test]
+        public void ByteStatisticSetModifying([Random(1)] byte hp, [Random(1)] byte attack, [Random(1)] byte defense,
+            [Random(1)] byte specialAttack, [Random(1)] byte specialDefense, [Random(1)] byte speed)
+        {
+            using var set = new StatisticSet<byte>(0,0,0,0,0,0);
+            set.HP = hp;
+            Assert.AreEqual(set.HP, hp);
+            set.Attack = attack;
+            Assert.AreEqual(set.Attack, attack);
+            set.Defense = defense;
+            Assert.AreEqual(set.Defense, defense);
+            set.SpecialAttack = specialAttack;
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            set.SpecialDefense = specialDefense;
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            set.Speed = speed;
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void UShortStatisticSet([Random(1)] ushort hp, [Random(1)] ushort attack, [Random(1)] ushort defense,
+            [Random(1)] ushort specialAttack, [Random(1)] ushort specialDefense, [Random(1)] ushort speed)
+        {
+            using var set = new StatisticSet<ushort>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void UintStatisticSet([Random(1)] uint hp, [Random(1)] uint attack, [Random(1)] uint defense,
+            [Random(1)] uint specialAttack, [Random(1)] uint specialDefense, [Random(1)] uint speed)
+        {
+            using var set = new StatisticSet<uint>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void SbyteStatisticSet([Random(1)] sbyte hp, [Random(1)] sbyte attack, [Random(1)] sbyte defense,
+            [Random(1)] sbyte specialAttack, [Random(1)] sbyte specialDefense, [Random(1)] sbyte speed)
+        {
+            using var set = new StatisticSet<sbyte>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void ShortStatisticSet([Random(1)] short hp, [Random(1)] short attack, [Random(1)] short defense,
+            [Random(1)] short specialAttack, [Random(1)] short specialDefense, [Random(1)] short speed)
+        {
+            using var set = new StatisticSet<short>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+
+        [Test]
+        public void IntStatisticSet([Random(1)] int hp, [Random(1)] int attack, [Random(1)] int defense,
+            [Random(1)] int specialAttack, [Random(1)] int specialDefense, [Random(1)] int speed)
+        {
+            using var set = new StatisticSet<int>(hp, attack, defense, specialAttack, specialDefense, speed);
+            Assert.AreEqual(set.HP, hp);
+            Assert.AreEqual(set.Attack, attack);
+            Assert.AreEqual(set.Defense, defense);
+            Assert.AreEqual(set.SpecialAttack, specialAttack);
+            Assert.AreEqual(set.SpecialDefense, specialDefense);
+            Assert.AreEqual(set.Speed, speed);
+        }
+    }
+}