test

My project/Library/PackageCache/com.unity.inputsystem/Tests/TestFixture/AssetDatabaseUtils.cs

@@ -0,0 +1,216 @@
+#if UNITY_EDITOR
+
+using System;
+using System.IO;
+using UnityEditor;
+
+namespace UnityEngine.InputSystem
+{
+    /// Provides convenience functions for creating and managing assets for test purposes.
+    /// Note that all returned paths are converted to Unix paths when running on Windows
+    /// for consistency and to avoid mixed path names.
+    public static class AssetDatabaseUtils
+    {
+        private const string kAssetPath = "Assets";
+        private const string kTestPath = "TestFiles";
+        private const string kMetaExtension = ".meta";
+        private const string kDefaultAssetExtension = "asset";
+
+        // Perform an operation equivalent to a file delete operation outside of Unity Editor.
+        // Note that meta file is also removed to avoid generating warnings about non-clean delete.
+        public static void ExternalDeleteFileOrDirectory(string path)
+        {
+            FileUtil.DeleteFileOrDirectory(path);
+            FileUtil.DeleteFileOrDirectory(path + kMetaExtension);
+        }
+
+        // Perform an operation equivalent to a file move operation outside of Unity Editor.
+        // Note that meta file is also moved to avoid generating warnings about non-clean move.
+        public static void ExternalMoveFileOrDirectory(string source, string dest)
+        {
+            FileUtil.MoveFileOrDirectory(source, dest);
+            FileUtil.MoveFileOrDirectory(source + kMetaExtension, dest + kMetaExtension);
+        }
+
+        // Create an asset at the given path containing the given text content.
+        private static T CreateAssetAtPath<T>(string path, string content) where T : UnityEngine.Object
+        {
+            Debug.Assert(!File.Exists(path));
+
+            T obj;
+            try
+            {
+                CreateDirectories(Path.GetDirectoryName(path));
+
+                File.WriteAllText(path, content);
+                AssetDatabase.ImportAsset(path);
+                obj = AssetDatabase.LoadAssetAtPath<T>(path);
+                if (obj == null)
+                    throw new Exception($"Failed to create asset at \"{path}\"");
+            }
+            catch (Exception)
+            {
+                AssetDatabase.DeleteAsset(path);
+                throw;
+            }
+
+            return obj;
+        }
+
+        private static string SanitizePath(string path)
+        {
+            return path?.Replace("\\", "/");
+        }
+
+        private static void CreateRootDirectory()
+        {
+            CreateDirectories(RootPath());
+        }
+
+        // Creates all directories (including intermediate) defined in path.
+        private static string CreateDirectories(string path)
+        {
+            if (Directory.Exists(path))
+                return SanitizePath(path);
+
+            var parentFolder = kAssetPath;
+            path = path.Replace("\\", "/"); // Make sure we only get '/' separators.
+            var directories = path.Split('/');
+            if (directories[0] != kAssetPath)
+                throw new ArgumentException(path);
+            for (var i = 1; i < directories.Length; ++i)
+            {
+                var guid = AssetDatabase.CreateFolder(parentFolder, directories[i]);
+                if (guid == string.Empty)
+                    throw new Exception("Failed to create path \"" + path + "\"");
+                parentFolder = SanitizePath(Path.Combine(parentFolder, directories[i]));
+            }
+
+            AssetDatabase.Refresh();
+
+            return SanitizePath(path);
+        }
+
+        // Creates a random test directory within asset folder that is automatically removed after test run.
+        public static string CreateDirectory()
+        {
+            return CreateDirectories(RandomDirectoryPath());
+        }
+
+        // Creates an asset in the given directory path with an explicit or random file name containing the
+        // given content or the default content based on type.
+        public static T CreateAsset<T>(string directoryPath, string filename = null, string content = null) where T : UnityEngine.Object
+        {
+            Debug.Assert(directoryPath == null || directoryPath.Contains(RootPath()));
+            Debug.Assert(filename == null || !filename.Contains("/"));
+
+            if (directoryPath == null)
+                directoryPath = RootPath();
+            string path;
+            if (filename != null)
+            {
+                path = SanitizePath(Path.Combine(directoryPath, filename));
+                if (File.Exists(path))
+                    throw new Exception($"File already exists: {path}");
+            }
+            else
+            {
+                path = RandomAssetFilePath(directoryPath, AssetFileExtensionFromType(typeof(T)));
+            }
+
+            return CreateAsset<T>(path: path, content: content);
+        }
+
+        // Creates an asset at the given path containing the specified content.
+        // If path is null, a unique random file name is assigned, if content is null the default content based
+        // on type (extension) is used.
+        public static T CreateAsset<T>(string path = null, string content = null) where T : UnityEngine.Object
+        {
+            if (path == null)
+                path = RandomAssetFilePath(RootPath(), AssetFileExtensionFromType(typeof(T)));
+            if (content == null)
+                content = DefaultContentFromType(typeof(T));
+            return CreateAssetAtPath<T>(path, content);
+        }
+
+        public static void Restore()
+        {
+            var root = RootPath();
+
+            // Delete all files in test folder
+            if (!Directory.Exists(root))
+                return;
+
+            foreach (var asset in AssetDatabase.FindAssets("", new string[] { root }))
+            {
+                var path = AssetDatabase.GUIDToAssetPath(asset);
+                AssetDatabase.DeleteAsset(path);
+            }
+
+            AssetDatabase.DeleteAsset(root);
+        }
+
+        private static string RandomName()
+        {
+            const double scale = int.MaxValue;
+            double r = UnityEngine.Random.value;
+            return "Test_" + (int)(Math.Floor(r * scale));
+        }
+
+        private static string RandomAssetFilePath<T>(string directoryPath = null)
+        {
+            return RandomAssetFilePath(directoryPath, AssetFileExtensionFromType(typeof(T)));
+        }
+
+        private static string RandomAssetFilePath(string directoryPath = null, string extension = null)
+        {
+            // Default to using test files root path
+            if (directoryPath == null)
+                directoryPath = RootPath();
+
+            // Default to default extension
+            if (extension == null)
+                extension = kDefaultAssetExtension;
+
+            string path;
+            do
+            {
+                path = SanitizePath(Path.Combine(directoryPath, RandomName() + "." + extension)); // EDIT
+            }
+            while (File.Exists(path));
+            return path;
+        }
+
+        private static string RootPath()
+        {
+            return SanitizePath(Path.Combine(kAssetPath, kTestPath));
+        }
+
+        public static string RandomDirectoryPath()
+        {
+            string path;
+            do
+            {
+                path = Path.Combine(RootPath(), RandomName());
+            }
+            while (File.Exists(path));
+            return SanitizePath(path);
+        }
+
+        private static string AssetFileExtensionFromType(Type type)
+        {
+            if (type == typeof(InputActionAsset))
+                return InputActionAsset.Extension;
+            return kDefaultAssetExtension;
+        }
+
+        private static string DefaultContentFromType(Type type)
+        {
+            if (type == typeof(InputActionAsset))
+                return "{}";
+            return string.Empty;
+        }
+    }
+}
+
+#endif // UNITY_EDITOR