Implements static library handlers.

PkmnLibRSharpTests/StaticData/Libraries/AbilityLibraryTests.cs

@@ -0,0 +1,51 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class AbilityLibraryTests
+    {
+        [Test]
+        public void Create()
+        {
+            using var lib = new AbilityLibrary(0);
+            Assert.AreEqual(0, lib.Count);
+        }
+
+        [Test]
+        public void CreateAndAdd()
+        {
+            using var lib = new AbilityLibrary(1);
+            Assert.AreEqual(0, lib.Count);
+            using var ability = new Ability("testAbility", "effect", Array.Empty<EffectParameter>());
+            lib.Add("foobar", ability);
+            Assert.AreEqual(1, lib.Count);
+            Assert.AreEqual("testAbility", lib["foobar"].Name);
+        }
+
+        [Test]
+        public void CreateAddIterate()
+        {
+            using var lib = new AbilityLibrary(10);
+            Assert.AreEqual(0, lib.Count);
+            for (ushort i = 0; i < 10; i++)
+            {
+                using var item = new Ability(i.ToString(), "effect", Array.Empty<EffectParameter>());
+                lib.Add(i + "_key", item);
+            }
+
+            Assert.AreEqual(10, lib.Count);
+            var index = 0;
+            foreach (var kv in lib)
+            {
+                Assert.AreEqual(kv.Key, index + "_key");
+                Assert.AreEqual(kv.Value.Name, index.ToString());
+                index++;
+            }
+
+            Assert.AreEqual(10, index);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/GrowthRateLibraryTests.cs

@@ -0,0 +1,43 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class GrowthRateLibraryTests
+    {
+        [Test]
+        public void CreateGrowthRateLibrary()
+        {
+            using var library = new GrowthRateLibrary(0);
+        }
+        
+        [Test]
+        public void AddGrowthRateToLibrary()
+        {
+            using var library = new GrowthRateLibrary(0);
+            using var growthRate = new LookupGrowthRate(new uint[] { 0, 1, 5, 10, 20, 100, 200, 500 });
+            library.AddGrowthRate("foobar", growthRate);
+        }
+
+        [Test]
+        public void CalculateLevel()
+        {
+            using var library = new GrowthRateLibrary(0);
+            using var growthRate = new LookupGrowthRate(new uint[] { 0, 1, 5, 10, 20, 100, 200, 500 });
+            library.AddGrowthRate("foobar", growthRate);
+            var level = library.CalculateLevel("foobar", 20);
+            Assert.AreEqual(5, level);
+        }
+
+        [Test]
+        public void CalculateExperience()
+        {
+            using var library = new GrowthRateLibrary(0);
+            using var growthRate = new LookupGrowthRate(new uint[] { 0, 1, 5, 10, 20, 100, 200, 500 });
+            library.AddGrowthRate("foobar", growthRate);
+            var experience = library.CalculateExperience("foobar", 5);
+            Assert.AreEqual(20, experience);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/ItemLibraryTests.cs

@@ -0,0 +1,52 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class ItemLibraryTests
+    {
+        [Test]
+        public void Create()
+        {
+            using var lib = new ItemLibrary(0);
+            Assert.AreEqual(0, lib.Count);
+        }
+
+        [Test]
+        public void CreateAndAdd()
+        {
+            using var lib = new ItemLibrary(1);
+            Assert.AreEqual(0, lib.Count);
+            using var item = new Item("testItem", ItemCategory.Mail, BattleItemCategory.None, 100, Array.Empty<string>());
+            lib.Add("foobar", item);
+            Assert.AreEqual(1, lib.Count);
+            Assert.AreEqual("testItem", lib["foobar"].Name);
+        }
+
+        [Test]
+        public void CreateAddIterate()
+        {
+            using var lib = new ItemLibrary(10);
+            Assert.AreEqual(0, lib.Count);
+            for (ushort i = 0; i < 10; i++)
+            {
+                using var item = new Item(i.ToString(), ItemCategory.Mail, BattleItemCategory.None, 100,
+                    Array.Empty<string>());
+                lib.Add(i + "_key", item);
+            }
+
+            Assert.AreEqual(10, lib.Count);
+            var index = 0;
+            foreach (var kv in lib)
+            {
+                Assert.AreEqual(kv.Key, index + "_key");
+                Assert.AreEqual(kv.Value.Name, index.ToString());
+                index++;
+            }
+
+            Assert.AreEqual(10, index);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/LibrarySettingsTests.cs

@@ -0,0 +1,21 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class LibrarySettingsTests
+    {
+        [Test]
+        public void CreateLibrarySettings()
+        {
+            using var settings = new LibrarySettings(100);
+        }
+        
+        [Test]
+        public void GetMaxLevel()
+        {
+            using var settings = new LibrarySettings(100);
+            Assert.AreEqual(100, settings.MaxLevel);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/MoveLibraryTests.cs

@@ -0,0 +1,53 @@
+using System;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class MoveLibraryTests
+    {
+        [Test]
+        public void Create()
+        {
+            using var lib = new MoveLibrary(0);
+            Assert.AreEqual(0, lib.Count);
+        }
+
+        [Test]
+        public void CreateAndAdd()
+        {
+            using var lib = new MoveLibrary(1);
+            Assert.AreEqual(0, lib.Count);
+            using var move = new MoveData("testMove", new TypeIdentifier(0), MoveCategory.Physical, 100, 100, 1,
+                MoveTarget.All, 0, null, Array.Empty<string>());
+            lib.Add("foobar", move);
+            Assert.AreEqual(1, lib.Count);
+            Assert.AreEqual("testMove", lib["foobar"].Name);
+        }
+
+        [Test]
+        public void CreateAddIterate()
+        {
+            using var lib = new MoveLibrary(10);
+            Assert.AreEqual(0, lib.Count);
+            for (ushort i = 0; i < 10; i++)
+            {
+                using var move = new MoveData(i.ToString(), new TypeIdentifier(0), MoveCategory.Physical, 100, 100, 1,
+                    MoveTarget.All, 0, null, Array.Empty<string>());
+                lib.Add(i + "_key", move);
+            }
+
+            Assert.AreEqual(10, lib.Count);
+            var index = 0;
+            foreach (var kv in lib)
+            {
+                Assert.AreEqual(kv.Key, index + "_key");
+                Assert.AreEqual(kv.Value.Name, index.ToString());
+                index++;
+            }
+
+            Assert.AreEqual(10, index);
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/NatureLibraryTests.cs

@@ -0,0 +1,71 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class NatureLibraryTests
+    {
+        [Test]
+        public void CreateNatureLibrary()
+        {
+            using var library = new NatureLibrary(0);
+        }
+        
+        [Test]
+        public void LoadNatures()
+        {
+            using var library = new NatureLibrary(0);
+            using var nature1 = Nature.NeutralNature();
+            using var nature2 = new Nature(Statistic.Attack, Statistic.Defense);
+            library.LoadNature("foo", nature1);
+            library.LoadNature("bar", nature2);
+        }
+
+        [Test]
+        public void LoadAndGetNature()
+        {
+            using var library = new NatureLibrary(0);
+            using var nature1 = new Nature(Statistic.Attack, Statistic.Defense);
+            library.LoadNature("foo", nature1);
+            
+            Assert.That(library.TryGetNature("foo", out var n));
+            Assert.AreEqual(Statistic.Attack, n.IncreasedStat);
+        }
+        
+        [Test]
+        public void LoadAndGetNatureTwice()
+        {
+            using var library = new NatureLibrary(0);
+            using var nature1 = new Nature(Statistic.Attack, Statistic.Defense);
+            library.LoadNature("foo", nature1);
+            
+            Assert.That(library.TryGetNature("foo", out var n));
+            Assert.AreEqual(Statistic.Attack, n.IncreasedStat);
+            
+            Assert.That(library.TryGetNature("foo", out n));
+            Assert.AreEqual(Statistic.Attack, n.IncreasedStat);
+        }
+        
+        [Test]
+        public void GetUnknownNature()
+        {
+            using var library = new NatureLibrary(0);
+            using var nature1 = new Nature(Statistic.Attack, Statistic.Defense);
+            
+            Assert.False(library.TryGetNature("foo", out _));
+        }
+
+        [Test]
+        public void GetNatureName()
+        {
+            using var library = new NatureLibrary(0);
+            using var nature1 = new Nature(Statistic.Attack, Statistic.Defense);
+            library.LoadNature("foo", nature1);
+            
+            Assert.That(library.TryGetNature("foo", out var n));
+            Assert.AreEqual("foo", library.GetNatureName(n));
+        }
+
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/SpeciesLibraryTests.cs

@@ -11,22 +11,47 @@ namespace PkmnLibRSharpTests.StaticData.Libraries
         public void Create()
         {
             using var lib = new SpeciesLibrary(0);
-            Assert.AreEqual(0, lib.Length);
+            Assert.AreEqual(0, lib.Count);
         }
 
         [Test]
         public void CreateAndAdd()
         {
-            using var lib = new SpeciesLibrary(0);
-            Assert.AreEqual(0, lib.Length);
+            using var lib = new SpeciesLibrary(1);
+            Assert.AreEqual(0, lib.Count);
             using var stats = new StaticStatisticSet<short>(5, 10, 30, 20, 2, 0);
             using var moves = new LearnableMoves();
             using var form = new Form("foobar", 0.2f, 5.8f, 300, new TypeIdentifier[] { new(1), new(2) }, stats,
                 new[] { "foo", "bar" }, new[] { "set" }, moves, Array.Empty<string>());
             using var species = new Species(10, "testSpecies", 0.2f, "growth", 120, form, Array.Empty<string>());
             lib.Add("foobar", species);
-            Assert.AreEqual(1, lib.Length);
+            Assert.AreEqual(1, lib.Count);
             Assert.AreEqual("testSpecies", lib["foobar"].Name);
         }
+        
+        [Test]
+        public void CreateAddIterate()
+        {
+            using var lib = new SpeciesLibrary(1);
+            Assert.AreEqual(0, lib.Count);
+            for (ushort i = 0; i < 10; i++)
+            {
+                using var stats = new StaticStatisticSet<short>(5, 10, 30, 20, 2, 0);
+                using var moves = new LearnableMoves();
+                using var form = new Form("foobar", 0.2f, 5.8f, 300, new TypeIdentifier[] { new(1), new(2) }, stats,
+                    new[] { "foo", "bar" }, new[] { "set" }, moves, Array.Empty<string>());
+                using var species = new Species(i, i.ToString(), 0.2f, "growth", 120, form, Array.Empty<string>());
+                lib.Add(i + "_key", species);
+            }
+            Assert.AreEqual(10, lib.Count);
+            var index = 0;
+            foreach (var kv in lib)
+            {
+                Assert.AreEqual(kv.Key, index + "_key");
+                Assert.AreEqual(kv.Value.Id, index);
+                index++;
+            }
+            Assert.AreEqual(10, index);
+        }
     }
 }

PkmnLibRSharpTests/StaticData/Libraries/StaticDataTests.cs

@@ -0,0 +1,79 @@
+using NUnit.Framework;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class StaticDataTests
+    {
+        [Test]
+        public void CreateNewStaticData()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+        }
+        
+        [Test]
+        public void GetSettings()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.LibrarySettings;
+        }
+
+        [Test]
+        public void GetSpecies()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.SpeciesLibrary;
+        }
+
+        [Test]
+        public void GetMoves()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.MoveLibrary;
+        }
+
+        [Test]
+        public void GetItems()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.ItemLibrary;
+        }
+        
+        [Test]
+        public void GetGrowthRates()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.GrowthRateLibrary;
+        }
+
+        [Test]
+        public void GetTypeLibrary()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.TypeLibrary;
+        }
+        
+        [Test]
+        public void GetNatureLibrary()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.NatureLibrary;
+        }
+
+        [Test]
+        public void GetAbilityLibrary()
+        {
+            using var settings = new LibrarySettings(100);
+            using var library = new PkmnLibSharp.StaticData.Libraries.StaticData(settings);
+            var _ = library.AbilityLibrary;
+        }
+    }
+}

PkmnLibRSharpTests/StaticData/Libraries/TypeLibraryTests.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using PkmnLibSharp.StaticData;
+using PkmnLibSharp.StaticData.Libraries;
+
+namespace PkmnLibRSharpTests.StaticData.Libraries
+{
+    public class TypeLibraryTests
+    {
+        [Test]
+        public void CreateTypeLibrary()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+        }
+
+        [Test]
+        public void RegisterType()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            typeLibrary.RegisterType("foobar");
+        }
+
+        [Test]
+        public void RegisterTypeRetrieve()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            var typeIdentifier1 = typeLibrary.RegisterType("foo");
+            Assert.AreEqual(typeIdentifier1, new TypeIdentifier(1));
+            var typeIdentifier2 = typeLibrary.RegisterType("bar");
+            Assert.AreEqual(typeIdentifier2, new TypeIdentifier(2));
+            Assert.AreEqual(typeIdentifier1, typeLibrary.GetTypeId("foo"));
+            Assert.AreEqual(typeIdentifier2, typeLibrary.GetTypeId("bar"));
+        }
+        
+        [Test]
+        public void GetUnknownTypeErrors()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            typeLibrary.RegisterType("foo");
+            Assert.Throws<KeyNotFoundException>(() =>
+            {
+                typeLibrary.GetTypeId("bar");
+            });
+        }
+
+        [Test]
+        public void GetTypeName()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            var typeIdentifier1 = typeLibrary.RegisterType("foo");
+            Assert.AreEqual("foo", typeLibrary.GetTypeName(typeIdentifier1));
+        }
+        
+        [Test]
+        public void GetUnknownTypeNameErrors()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            typeLibrary.RegisterType("foo");
+            Assert.Throws<KeyNotFoundException>(() =>
+            {
+                typeLibrary.GetTypeName(new TypeIdentifier(100));
+            });
+        }
+
+        [Test]
+        public void SetEffectiveness()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            var typeIdentifier1 = typeLibrary.RegisterType("foo");
+            var typeIdentifier2 = typeLibrary.RegisterType("bar");
+            typeLibrary.SetEffectiveness(typeIdentifier1, typeIdentifier2, 0.5f);
+        }
+
+        [Test]
+        public void GetEffectiveness()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            var typeIdentifier1 = typeLibrary.RegisterType("foo");
+            var typeIdentifier2 = typeLibrary.RegisterType("bar");
+            typeLibrary.SetEffectiveness(typeIdentifier1, typeIdentifier2, 0.5f);
+            Assert.AreEqual(0.5f, typeLibrary.GetSingleEffectiveness(typeIdentifier1, typeIdentifier2));
+        }
+
+        [Test]
+        public void GetMultipleEffectiveness()
+        {
+            using var typeLibrary = new TypeLibrary(0);
+            var typeIdentifier1 = typeLibrary.RegisterType("foo");
+            var typeIdentifier2 = typeLibrary.RegisterType("bar");
+            typeLibrary.SetEffectiveness(typeIdentifier1, typeIdentifier2, 0.5f);
+            Assert.AreEqual(0.25f,
+                typeLibrary.GetEffectiveness(typeIdentifier1, new[] { typeIdentifier2, typeIdentifier2 }));
+        }
+    }
+}