Adding Tests. Removing reference to the UnityEditor namespace that shouldn't be there.

Author: coryleach

Runtime/SaveLoadManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using UnityEditor;
 using UnityEngine;
 
 namespace Gameframe.SaveLoad
@@ -74,6 +73,16 @@ public void Save(object obj, string filename, string folder = null)
             SaveLoadUtility.Save(obj,saveLoadMethod,filename,folder, baseFolder);
         }
 
+        /// <summary>
+        /// Gets the list of save files that have been created
+        /// </summary>
+        /// <param name="folder">sub folder</param>
+        /// <returns>list of file names (excludes the path)</returns>
+        public string[] GetFiles(string folder = null)
+        {
+            return SaveLoadUtility.GetSavedFiles(folder,baseFolder);
+        }
+
         /// <summary>
         /// Creat a copy of an object by serializing and deserializing it.
         /// Not compatible with unity objects.

Runtime/SaveLoadUtility.cs

@@ -1,4 +1,6 @@
-using System.IO;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using UnityEngine;
 
 namespace Gameframe.SaveLoad
@@ -66,9 +68,9 @@ public static void Save(object saveObject, ISerializationMethod serializationMet
                 saveFile.Close();
             }
         }
-        
+
         /// <summary>
-        /// 
+        /// Load object from file
         /// </summary>
         /// <param name="objectType"></param>
         /// <param name="serializationMethod"></param>
@@ -98,7 +100,33 @@ public static object Load(System.Type objectType, ISerializationMethod serializa
         }
 
         /// <summary>
-        /// 
+        /// Enumerate files in the save directory
+        /// </summary>
+        /// <param name="folderName">folder containing the save files</param>
+        /// <param name="baseFolderPath">base path to the folder</param>
+        /// <returns>list of file names</returns>
+        public static IEnumerable<string> EnumerateSavedFiles(string folderName = null, string baseFolderPath = null)
+        {
+            var savePath = GetSavePath(folderName,baseFolderPath);
+            foreach ( var file in Directory.EnumerateFiles(savePath,"*",SearchOption.AllDirectories) )
+            {
+                yield return Path.GetFileName(file);
+            }
+        }
+        
+        /// <summary>
+        /// Creates an array list of save files in the given folder and path
+        /// </summary>
+        /// <param name="folderName"></param>
+        /// <param name="baseFolderPath"></param>
+        /// <returns>Array of file names</returns>
+        public static string[] GetSavedFiles(string folderName = null, string baseFolderPath = null)
+        {
+            return EnumerateSavedFiles(folderName, baseFolderPath).ToArray();
+        }
+        
+        /// <summary>
+        /// Check if a saved file exists
         /// </summary>
         /// <param name="filename"></param>
         /// <param name="folderName"></param>
@@ -112,7 +140,7 @@ public static bool Exists(string filename, string folderName = null, string base
         }
 
         /// <summary>
-        /// 
+        /// Delete a savedd file
         /// </summary>
         /// <param name="filename"></param>
         /// <param name="folderName"></param>

Tests/Editor.meta

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using NUnit.Framework;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Gameframe.SaveLoad.Tests
+{
+    public class SaveLoadUtilityTests
+    {
+        private string TestKey = "TestKey";
+        private string TestSalt = "TestSalt";
+        
+        private ISerializationMethod GetSerializationMethod(SerializationMethodType method)
+        {
+            switch (method)
+            {
+                case SerializationMethodType.Default:
+                    return new SerializationMethodUnityJson();
+                case SerializationMethodType.Binary:
+                    return new SerializationMethodBinary();
+                case SerializationMethodType.BinaryEncrypted:
+                    return new SerializationMethodBinaryEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.UnityJson:
+                    return new SerializationMethodUnityJson();
+                case SerializationMethodType.UnityJsonEncrypted:
+                    return new SerializationMethodUnityJsonEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.JsonDotNet:
+                    return new SerializationMethodJsonDotNet();
+                case SerializationMethodType.JsonDotNetEncrypted:
+                    return new SerializationMethodJsonDotNetEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.Custom:
+                    return new SerializationMethodBinary();
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(method), method, null);
+            }
+        }
+        
+        [Serializable]
+        public class SaveLoadTestObject
+        {
+            public string testData;
+        }
+        
+        [Test]
+        public void SaveLoadAndDelete([Values]SerializationMethodType method)
+        {
+            var testSave = new SaveLoadTestObject() {testData = "SaveFileExists"};
+            var serializationMethod = GetSerializationMethod(method);
+            var filename = "TestSave.sav";
+            
+            SaveLoadUtility.Save(testSave,serializationMethod,filename);
+            
+            Assert.IsTrue(SaveLoadUtility.Exists(filename));
+
+            var loadedSave = (SaveLoadTestObject)SaveLoadUtility.Load(typeof(SaveLoadTestObject), serializationMethod, filename);
+            Assert.NotNull(loadedSave);
+            Assert.IsTrue(loadedSave.testData == testSave.testData);
+            
+            SaveLoadUtility.DeleteSavedFile(filename);
+            
+            Assert.IsFalse(SaveLoadUtility.Exists(filename));
+        }
+
+        [Test]
+        public void CanGetFiles_Empty()
+        {
+            var files = SaveLoadUtility.GetSavedFiles();
+            Assert.IsTrue(files.Length == 0);
+        }
+
+        [Test]
+        public void CanGetFiles()
+        {
+            var testSave = new SaveLoadTestObject() {testData = "SaveFileExists"};
+            var serializationMethod = GetSerializationMethod(SerializationMethodType.Binary);
+            var filename = "TestSave.sav";
+            var folder = "TestFolder";
+            
+            SaveLoadUtility.Save(testSave,serializationMethod,filename,folder);
+
+            var files = SaveLoadUtility.GetSavedFiles(folder);
+            Assert.IsTrue(files.Length == 1);
+            
+            //Files should contain a list of names that exactly match the file name used
+            //omits the path of the file
+            Assert.IsTrue(files[0] == filename);
+            
+            SaveLoadUtility.DeleteSavedFile(filename,folder);
+
+            files = SaveLoadUtility.GetSavedFiles();
+            Assert.IsTrue(files.Length == 0);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            var path = SaveLoadUtility.GetSavePath();
+            string[] files = {"TestSave.sav"};
+
+            foreach (var file in files)
+            {
+                var filename = path + file;
+                if (File.Exists(filename))
+                {
+                    File.Delete(filename);
+                }
+            }
+        }
+        
+    }
+
+}
+

Tests/Editor/SaveLoadUtilityTests.cs

@@ -0,0 +1,21 @@
+{
+    "name": "com.gameframe.saveload.editor.tests",
+    "references": [
+        "GUID:b894308b0ac81480cb726cb405d83944",
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}