862 lines
37 KiB
C#
862 lines
37 KiB
C#
using NUnit.Framework;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using UnityEditor.Build.Content;
|
|
using UnityEditor.Build.Pipeline.Injector;
|
|
using UnityEditor.Build.Pipeline.Interfaces;
|
|
using UnityEditor.Build.Pipeline.Tasks;
|
|
using UnityEditor.Build.Pipeline.Utilities;
|
|
using UnityEditor.Build.Pipeline.WriteTypes;
|
|
using UnityEditor.SceneManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.Build.Pipeline;
|
|
using UnityEngine.SceneManagement;
|
|
using UnityEngine.TestTools;
|
|
|
|
namespace UnityEditor.Build.Pipeline.Tests
|
|
{
|
|
[TestFixture]
|
|
class ScriptableBuildPipelineTests
|
|
{
|
|
const string k_FolderPath = "Test";
|
|
const string k_TmpPath = "tmp";
|
|
|
|
const string k_ScenePath = "Assets/testScene.unity";
|
|
const string k_TestAssetsPath = "Assets/TestAssetsOnlyWillBeDeleted";
|
|
const string k_CubePath = k_TestAssetsPath + "/Cube.prefab";
|
|
const string k_CubePath2 = k_TestAssetsPath + "/Cube2.prefab";
|
|
const string k_CubePath3 = k_TestAssetsPath + "/Cube3.prefab";
|
|
|
|
ScriptableBuildPipeline.Settings m_Settings;
|
|
|
|
[OneTimeSetUp]
|
|
public void Setup()
|
|
{
|
|
EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo();
|
|
Directory.CreateDirectory(k_TestAssetsPath);
|
|
#if UNITY_2018_3_OR_NEWER
|
|
PrefabUtility.SaveAsPrefabAsset(GameObject.CreatePrimitive(PrimitiveType.Cube), k_CubePath);
|
|
PrefabUtility.SaveAsPrefabAsset(GameObject.CreatePrimitive(PrimitiveType.Cube), k_CubePath2);
|
|
PrefabUtility.SaveAsPrefabAsset(GameObject.CreatePrimitive(PrimitiveType.Cube), k_CubePath3);
|
|
#else
|
|
PrefabUtility.CreatePrefab(k_CubePath, GameObject.CreatePrimitive(PrimitiveType.Cube));
|
|
PrefabUtility.CreatePrefab(k_CubePath2, GameObject.CreatePrimitive(PrimitiveType.Cube));
|
|
PrefabUtility.CreatePrefab(k_CubePath3, GameObject.CreatePrimitive(PrimitiveType.Cube));
|
|
#endif
|
|
AssetDatabase.ImportAsset(k_CubePath);
|
|
AssetDatabase.ImportAsset(k_CubePath2);
|
|
AssetDatabase.ImportAsset(k_CubePath3);
|
|
|
|
m_Settings = LoadSettingsFromFile();
|
|
}
|
|
|
|
[OneTimeTearDown]
|
|
public void Cleanup()
|
|
{
|
|
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
AssetDatabase.DeleteAsset(k_ScenePath);
|
|
AssetDatabase.DeleteAsset(k_CubePath);
|
|
AssetDatabase.DeleteAsset(k_CubePath2);
|
|
AssetDatabase.DeleteAsset(k_CubePath3);
|
|
AssetDatabase.DeleteAsset(k_TestAssetsPath);
|
|
|
|
if (Directory.Exists(k_FolderPath))
|
|
Directory.Delete(k_FolderPath, true);
|
|
if (Directory.Exists(k_TmpPath))
|
|
Directory.Delete(k_TmpPath, true);
|
|
|
|
ScriptableBuildPipeline.s_Settings = m_Settings;
|
|
ScriptableBuildPipeline.SaveSettings();
|
|
}
|
|
|
|
static ReturnCode RunTask<T>(params IContextObject[] args) where T : IBuildTask
|
|
{
|
|
IBuildContext context = new BuildContext(args);
|
|
IBuildTask instance = Activator.CreateInstance<T>();
|
|
ContextInjector.Inject(context, instance);
|
|
var result = instance.Run();
|
|
ContextInjector.Extract(context, instance);
|
|
return result;
|
|
}
|
|
|
|
static void RequirePlayerBuildSupport()
|
|
{
|
|
// Building asset bundles compiles player scripts, which requires the player build
|
|
// support for the active build target to be installed.
|
|
var target = EditorUserBuildSettings.activeBuildTarget;
|
|
if (!BuildPipeline.IsBuildTargetSupported(BuildPipeline.GetBuildTargetGroup(target), target))
|
|
Assert.Ignore($"Build support for {target} is not installed.");
|
|
}
|
|
|
|
static IBundleBuildParameters GetBuildParameters()
|
|
{
|
|
if (Directory.Exists(k_FolderPath))
|
|
Directory.Delete(k_FolderPath, true);
|
|
if (Directory.Exists(k_TmpPath))
|
|
Directory.Delete(k_TmpPath, true);
|
|
|
|
Directory.CreateDirectory(k_FolderPath);
|
|
Directory.CreateDirectory(k_TmpPath);
|
|
|
|
IBundleBuildParameters buildParams = new BundleBuildParameters(EditorUserBuildSettings.activeBuildTarget, EditorUserBuildSettings.selectedBuildTargetGroup, k_FolderPath);
|
|
buildParams.TempOutputFolder = k_TmpPath;
|
|
return buildParams;
|
|
}
|
|
|
|
static AssetBundleBuild CreateBundleBuild(string name, string path)
|
|
{
|
|
return new AssetBundleBuild()
|
|
{
|
|
addressableNames = new[] { path },
|
|
assetBundleName = name,
|
|
assetBundleVariant = "",
|
|
assetNames = new[] { path }
|
|
};
|
|
}
|
|
|
|
static IBundleBuildContent GetBundleContent(bool createAllBundles = false)
|
|
{
|
|
List<AssetBundleBuild> buildData = new List<AssetBundleBuild>();
|
|
buildData.Add(CreateBundleBuild("bundle", k_CubePath));
|
|
if (createAllBundles)
|
|
buildData.Add(CreateBundleBuild("bundle2", k_CubePath2));
|
|
|
|
IBundleBuildContent buildContent = new BundleBuildContent(buildData);
|
|
return buildContent;
|
|
}
|
|
|
|
static IDependencyData GetDependencyData()
|
|
{
|
|
GUID guid;
|
|
GUID.TryParse(AssetDatabase.AssetPathToGUID(k_CubePath), out guid);
|
|
ObjectIdentifier[] oId = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(guid, EditorUserBuildSettings.activeBuildTarget);
|
|
AssetLoadInfo loadInfo = new AssetLoadInfo()
|
|
{
|
|
asset = guid,
|
|
address = k_CubePath,
|
|
includedObjects = oId.ToList(),
|
|
referencedObjects = oId.ToList()
|
|
};
|
|
|
|
IDependencyData dep = new BuildDependencyData();
|
|
dep.AssetInfo.Add(guid, loadInfo);
|
|
dep.AssetUsage.Add(guid, new BuildUsageTagSet());
|
|
|
|
return dep;
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator BuildPipeline_AssetBundleBuild_DoesNotResetUnsavedScene()
|
|
{
|
|
Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
yield return null;
|
|
EditorSceneManager.SaveScene(s, k_ScenePath);
|
|
GameObject.CreatePrimitive(PrimitiveType.Cube);
|
|
EditorSceneManager.MarkSceneDirty(s);
|
|
|
|
GameObject objectWeAdded = GameObject.Find("Cube");
|
|
Assert.IsNotNull(objectWeAdded, "No object before entering playmode");
|
|
Assert.AreEqual("testScene", SceneManager.GetActiveScene().name);
|
|
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IBundleBuildResults results;
|
|
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
|
|
Assert.AreEqual(ReturnCode.UnsavedChanges, exitCode);
|
|
|
|
Assert.AreEqual("testScene", SceneManager.GetActiveScene().name);
|
|
objectWeAdded = GameObject.Find("Cube");
|
|
Assert.IsNotNull(objectWeAdded, "No object after entering playmode");
|
|
|
|
EditorSceneManager.SaveScene(s, k_ScenePath);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildPipeline_AssetBundleBuild_WritesLinkXMLFile()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
buildParameters.WriteLinkXML = true;
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IBundleBuildResults results;
|
|
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
|
|
|
|
var assemblies = new HashSet<Assembly>();
|
|
var types = new HashSet<Type>();
|
|
foreach (var writeResult in results.WriteResults)
|
|
{
|
|
foreach (var type in writeResult.Value.includedTypes)
|
|
{
|
|
assemblies.Add(type.Assembly);
|
|
types.Add(type);
|
|
}
|
|
}
|
|
|
|
var xml = LinkXMLGeneratorTests.ReadLinkXML(buildParameters.GetOutputFilePathForIdentifier("link.xml"), out int assemblyCount, out int typeCount);
|
|
Assert.AreEqual(assemblyCount, assemblies.Count);
|
|
Assert.AreEqual(typeCount, types.Count);
|
|
foreach (var t in types)
|
|
LinkXMLGeneratorTests.AssertTypePreserved(xml, t);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildPipeline_CompatibilityBuildPipeline_WritesManifest()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
// Confirm that calling CompatibilityBuildPipeline.BuildAssetBundles generates a .manifest file similar to the top level file generated by BuildPipeline.BuildAssetBundles
|
|
|
|
var buildParameters = GetBuildParameters() as BundleBuildParameters;
|
|
string outputPath = buildParameters.OutputFolder;
|
|
|
|
var bundleDefinitions = new AssetBundleBuild[2];
|
|
bundleDefinitions[0] = CreateBundleBuild("bundle", k_CubePath);
|
|
bundleDefinitions[1] = CreateBundleBuild("bundle2", k_CubePath2);
|
|
|
|
CompatibilityAssetBundleManifest manifestObject = CompatibilityBuildPipeline.BuildAssetBundles(
|
|
outputPath,
|
|
bundleDefinitions, BuildAssetBundleOptions.ChunkBasedCompression | BuildAssetBundleOptions.ForceRebuildAssetBundle,
|
|
buildParameters.Target);
|
|
Assert.IsNotNull(manifestObject);
|
|
|
|
// .manifest file is created with name that matches the output build directory name
|
|
var buildDirectoryName = Path.GetFileName(k_FolderPath);
|
|
var expectedManifestPath = outputPath + "/" + buildDirectoryName + ".manifest";
|
|
|
|
// GetOutputFilePathForIdentifier is an alternative way to calculate the expected output path
|
|
Assert.AreEqual(buildParameters.GetOutputFilePathForIdentifier(buildDirectoryName + ".manifest"), expectedManifestPath);
|
|
|
|
FileAssert.Exists(expectedManifestPath);
|
|
|
|
// Confirm the .manifest file contains the expected content
|
|
string manifestContent = File.ReadAllText(expectedManifestPath);
|
|
string expectedManifestContent = manifestObject.ToString();
|
|
Assert.AreEqual(expectedManifestContent, manifestContent);
|
|
|
|
// Sanity check a few items of expected content
|
|
Assert.IsTrue(manifestContent.Contains("bundle"));
|
|
Assert.IsTrue(manifestContent.Contains("bundle2"));
|
|
Assert.IsTrue(manifestContent.Contains("CRC:"));
|
|
Assert.IsTrue(manifestContent.Contains("Hash:"));
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator ValidationMethods_HasDirtyScenes()
|
|
{
|
|
Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
yield return null;
|
|
|
|
bool dirty = ValidationMethods.HasDirtyScenes();
|
|
Assert.IsFalse(dirty);
|
|
|
|
EditorSceneManager.MarkSceneDirty(s);
|
|
|
|
dirty = ValidationMethods.HasDirtyScenes();
|
|
Assert.IsTrue(dirty);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_WriteSerializedFiles()
|
|
{
|
|
IBuildParameters buildParams = GetBuildParameters();
|
|
IDependencyData dependencyData = new BuildDependencyData();
|
|
IWriteData writeData = new BuildWriteData();
|
|
IBuildResults results = new BuildResults();
|
|
|
|
ReturnCode exitCode = RunTask<WriteSerializedFiles>(buildParams, dependencyData, writeData, results);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_GenerateBundlePacking()
|
|
{
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IDependencyData dep = GetDependencyData();
|
|
IBundleWriteData writeData = new BundleWriteData();
|
|
IDeterministicIdentifiers deterministicId = new PrefabPackedIdentifiers();
|
|
|
|
ReturnCode exitCode = RunTask<GenerateBundlePacking>(buildContent, dep, writeData, deterministicId);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_GenerateBundleCommands()
|
|
{
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IDependencyData dep = GetDependencyData();
|
|
IBundleWriteData writeData = new BundleWriteData();
|
|
IDeterministicIdentifiers deterministicId = new PrefabPackedIdentifiers();
|
|
|
|
RunTask<GenerateBundlePacking>(buildContent, dep, writeData, deterministicId);
|
|
|
|
IBundleBuildParameters buildParams = GetBuildParameters();
|
|
|
|
ReturnCode exitCode = RunTask<GenerateBundleCommands>(buildParams, buildContent, dep, writeData, deterministicId);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_GenerateBundleMaps()
|
|
{
|
|
IDependencyData dep = GetDependencyData();
|
|
IBundleWriteData writeData = new BundleWriteData();
|
|
|
|
ReturnCode exitCode = RunTask<GenerateBundleMaps>(dep, writeData);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_PostPackingCallback()
|
|
{
|
|
bool packingCallbackCalled = false;
|
|
|
|
IBuildParameters buildParams = GetBuildParameters();
|
|
IDependencyData dep = GetDependencyData();
|
|
IBundleWriteData writeData = new BundleWriteData();
|
|
BuildCallbacks callback = new BuildCallbacks();
|
|
callback.PostPackingCallback = (parameters, data, arg3) =>
|
|
{
|
|
packingCallbackCalled = true;
|
|
return ReturnCode.Success;
|
|
};
|
|
|
|
ReturnCode exitCode = RunTask<PostPackingCallback>(buildParams, dep, writeData, callback);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
Assert.IsTrue(packingCallbackCalled);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_PostWritingCallback()
|
|
{
|
|
bool writingCallbackCalled = false;
|
|
|
|
IBuildParameters buildParams = GetBuildParameters();
|
|
IDependencyData dep = GetDependencyData();
|
|
IWriteData writeData = new BuildWriteData();
|
|
IBuildResults results = new BuildResults();
|
|
BuildCallbacks callback = new BuildCallbacks();
|
|
callback.PostWritingCallback = (parameters, data, arg3, arg4) =>
|
|
{
|
|
writingCallbackCalled = true;
|
|
return ReturnCode.Success;
|
|
};
|
|
|
|
ReturnCode exitCode = RunTask<PostWritingCallback>(buildParams, dep, writeData, results, callback);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
Assert.IsTrue(writingCallbackCalled);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_PostDependencyCallback()
|
|
{
|
|
bool dependencyCallbackCalled = false;
|
|
|
|
IBuildParameters buildParameters = GetBuildParameters();
|
|
IDependencyData dep = GetDependencyData();
|
|
BuildCallbacks callback = new BuildCallbacks();
|
|
callback.PostDependencyCallback = (parameters, data) =>
|
|
{
|
|
dependencyCallbackCalled = true;
|
|
return ReturnCode.Success;
|
|
};
|
|
|
|
ReturnCode exitCode = RunTask<PostDependencyCallback>(buildParameters, dep, callback);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
Assert.IsTrue(dependencyCallbackCalled);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_PostScriptsCallbacks()
|
|
{
|
|
bool scriptsCallbackCalled = false;
|
|
|
|
IBuildParameters buildParameters = GetBuildParameters();
|
|
IBuildResults results = new BuildResults();
|
|
BuildCallbacks callback = new BuildCallbacks();
|
|
callback.PostScriptsCallbacks = (parameters, buildResults) =>
|
|
{
|
|
scriptsCallbackCalled = true;
|
|
return ReturnCode.Success;
|
|
};
|
|
|
|
ReturnCode exitCode = RunTask<PostScriptsCallback>(buildParameters, results, callback);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
Assert.IsTrue(scriptsCallbackCalled);
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultBuildTasks_AppendBundleHash()
|
|
{
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
buildParameters.AppendHash = true;
|
|
var fileName = k_FolderPath + "/TestBundle";
|
|
var fileHash = HashingMethods.Calculate(fileName).ToHash128();
|
|
File.WriteAllText(fileName, fileName);
|
|
IBundleBuildResults results = new BundleBuildResults();
|
|
results.BundleInfos["TestBundle"] = new BundleDetails
|
|
{
|
|
Crc = 0,
|
|
FileName = fileName,
|
|
Hash = fileHash
|
|
};
|
|
|
|
ReturnCode exitCode = RunTask<AppendBundleHash>(buildParameters, results);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
FileAssert.Exists(fileName + "_" + fileHash);
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator SceneDataWriteOperation_HashChanges_WhenPrefabDepenencyChanges()
|
|
{
|
|
Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
yield return null;
|
|
|
|
var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(k_CubePath);
|
|
prefab.transform.position = new Vector3(0, 0, 0);
|
|
EditorUtility.SetDirty(prefab);
|
|
AssetDatabase.SaveAssets();
|
|
PrefabUtility.InstantiatePrefab(prefab);
|
|
|
|
EditorSceneManager.SaveScene(s, k_ScenePath);
|
|
|
|
var op = new SceneDataWriteOperation
|
|
{
|
|
Command = new WriteCommand(),
|
|
PreloadInfo = new PreloadInfo(),
|
|
ReferenceMap = new BuildReferenceMap(),
|
|
UsageSet = new BuildUsageTagSet(),
|
|
Scene = k_ScenePath,
|
|
DependencyHash = AssetDatabase.GetAssetDependencyHash(k_CubePath)
|
|
};
|
|
var cacheVersion1 = op.GetHash128();
|
|
|
|
prefab.transform.position = new Vector3(1, 1, 1);
|
|
EditorUtility.SetDirty(prefab);
|
|
AssetDatabase.SaveAssets();
|
|
op.DependencyHash = AssetDatabase.GetAssetDependencyHash(k_CubePath);
|
|
var cacheVersion2 = op.GetHash128();
|
|
|
|
Assert.AreNotEqual(cacheVersion1, cacheVersion2);
|
|
}
|
|
|
|
[UnityTest]
|
|
public IEnumerator SceneBundleWriteOperation_HashChanges_WhenPrefabDepenencyChanges()
|
|
{
|
|
Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
yield return null;
|
|
|
|
var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(k_CubePath);
|
|
prefab.transform.position = new Vector3(0, 0, 0);
|
|
EditorUtility.SetDirty(prefab);
|
|
AssetDatabase.SaveAssets();
|
|
PrefabUtility.InstantiatePrefab(prefab);
|
|
|
|
EditorSceneManager.SaveScene(s, k_ScenePath);
|
|
|
|
var op = new SceneBundleWriteOperation
|
|
{
|
|
Command = new WriteCommand(),
|
|
PreloadInfo = new PreloadInfo(),
|
|
ReferenceMap = new BuildReferenceMap(),
|
|
UsageSet = new BuildUsageTagSet(),
|
|
Info = new SceneBundleInfo(),
|
|
Scene = k_ScenePath,
|
|
DependencyHash = AssetDatabase.GetAssetDependencyHash(k_CubePath)
|
|
};
|
|
var cacheVersion1 = op.GetHash128();
|
|
|
|
prefab.transform.position = new Vector3(1, 1, 1);
|
|
EditorUtility.SetDirty(prefab);
|
|
AssetDatabase.SaveAssets();
|
|
op.DependencyHash = AssetDatabase.GetAssetDependencyHash(k_CubePath);
|
|
var cacheVersion2 = op.GetHash128();
|
|
|
|
Assert.AreNotEqual(cacheVersion1, cacheVersion2);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildAssetBundles_WhenNoBuildInContextLog_CreatesPerformanceLogReport()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IBundleBuildResults results;
|
|
|
|
buildParameters.Group = EditorUserBuildSettings.selectedBuildTargetGroup;
|
|
|
|
ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
|
|
|
|
string tepBuildLog = buildParameters.GetOutputFilePathForIdentifier("buildlogtep.json");
|
|
FileAssert.Exists(tepBuildLog);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildAssetBundles_WhenBuildLogProvided_DoesNotCreatePerformanceLogReport()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
IBundleBuildContent buildContent = GetBundleContent();
|
|
IBundleBuildResults results;
|
|
|
|
var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible);
|
|
ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results, taskList, new BuildLog());
|
|
|
|
string tepBuildLog = buildParameters.GetOutputFilePathForIdentifier("buildlogtep.json");
|
|
FileAssert.DoesNotExist(tepBuildLog);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildAssetBundles_WithDuplicateAddresses_InSeparateBundles_DoesNotLogErrorMessage()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
List<AssetBundleBuild> buildData = new List<AssetBundleBuild>();
|
|
var bundle1 = new AssetBundleBuild()
|
|
{
|
|
addressableNames = new[] { k_CubePath },
|
|
assetBundleName = k_CubePath,
|
|
assetBundleVariant = "",
|
|
assetNames = new[] { k_CubePath }
|
|
};
|
|
var bundle2 = new AssetBundleBuild()
|
|
{
|
|
addressableNames = new[] { k_CubePath },
|
|
assetBundleName = k_CubePath2,
|
|
assetBundleVariant = "",
|
|
assetNames = new[] { k_CubePath2 }
|
|
};
|
|
buildData.Add(bundle1);
|
|
buildData.Add(bundle2);
|
|
// different asset, same addressable name.
|
|
|
|
IBundleBuildContent buildContent = new BundleBuildContent(buildData);
|
|
IBundleBuildResults results;
|
|
|
|
|
|
var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible);
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results, taskList, new BuildLog());
|
|
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
#if UNITY_6000_0_OR_NEWER
|
|
[Test]
|
|
public void BuildAssetBundles_WithDuplicateAddresses_InSameBundle_LogsErrorMessage()
|
|
{
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
List<AssetBundleBuild> buildData = new List<AssetBundleBuild>();
|
|
var bundle1 = new AssetBundleBuild()
|
|
{
|
|
addressableNames = new[] { k_CubePath, k_CubePath },
|
|
assetBundleName = k_CubePath,
|
|
assetBundleVariant = "",
|
|
assetNames = new[] { k_CubePath, k_CubePath2 }
|
|
};
|
|
buildData.Add(bundle1);
|
|
// different asset, same addressable name.
|
|
|
|
IBundleBuildContent buildContent = new BundleBuildContent(buildData);
|
|
IBundleBuildResults results;
|
|
|
|
LogAssert.Expect(LogType.Exception, new Regex($"Duplicate internal id '{k_CubePath}' for guid *"));
|
|
var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible);
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results, taskList, new BuildLog());
|
|
Assert.AreEqual(ReturnCode.Exception, exitCode);
|
|
}
|
|
#endif
|
|
|
|
[Test]
|
|
public void BuildParameters_SetsBuildCacheServerParameters_WhenUseBuildCacheServerEnabled()
|
|
{
|
|
int port = 9999;
|
|
string host = "fake host";
|
|
|
|
using (new StoreCacheServerConfig(true, host, port))
|
|
{
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
|
|
Assert.AreEqual(port, buildParameters.CacheServerPort);
|
|
Assert.AreEqual(host, buildParameters.CacheServerHost);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void BuildParameters_DoesNotSetBuildCacheServerParameters_WhenUseBuildCacheServerDisabled()
|
|
{
|
|
int port = 9999;
|
|
string host = "testHost";
|
|
|
|
using (new StoreCacheServerConfig(false, host, port))
|
|
{
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
|
|
Assert.AreEqual(8126, buildParameters.CacheServerPort);
|
|
Assert.AreEqual(null, buildParameters.CacheServerHost);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void BuildAssetBundles_WithCache_Succeeds()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
IBundleBuildContent buildContent = GetBundleContent(true);
|
|
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out IBundleBuildResults results);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildAssetBundles_WithoutCache_Succeeds()
|
|
{
|
|
RequirePlayerBuildSupport();
|
|
IBundleBuildParameters buildParameters = GetBuildParameters();
|
|
buildParameters.UseCache = false;
|
|
IBundleBuildContent buildContent = GetBundleContent(true);
|
|
|
|
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out IBundleBuildResults results);
|
|
Assert.AreEqual(ReturnCode.Success, exitCode);
|
|
}
|
|
|
|
BuildDependencyData BuildBundleDepData(params string[] paths)
|
|
{
|
|
var depData = new BuildDependencyData();
|
|
foreach (var p in paths)
|
|
{
|
|
GUID guid1;
|
|
GUID.TryParse(AssetDatabase.AssetPathToGUID(p), out guid1);
|
|
var objIds1 = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(guid1, EditorUserBuildSettings.activeBuildTarget);
|
|
depData.AssetInfo.Add(guid1, new AssetLoadInfo
|
|
{
|
|
asset = guid1,
|
|
address = p,
|
|
includedObjects = objIds1.ToList(),
|
|
referencedObjects = new List<ObjectIdentifier>(ContentBuildInterface.GetPlayerDependenciesForObjects(objIds1, EditorUserBuildSettings.activeBuildTarget, null))
|
|
});
|
|
depData.AssetUsage.Add(guid1, new BuildUsageTagSet());
|
|
}
|
|
return depData;
|
|
}
|
|
|
|
#if UNITY_6000_0_OR_NEWER
|
|
[Test]
|
|
public void ClusterBuildLayout_GenerateClusterName_Stress([Values(100, 1000)] int listCount, [Values(100, 1000)] int idCount)
|
|
{
|
|
var idLists = new List<List<ObjectIdentifier>>();
|
|
for (int i = 0; i < listCount; i++)
|
|
{
|
|
var ids = new List<ObjectIdentifier>();
|
|
for (int j = 0; j < idCount; j++)
|
|
ids.Add(new ObjectIdentifier { filePath = $"long asset path to stress the hashing speed {i} - {j}", fileType = FileType.SerializedAssetType, guid = GUID.Generate(), localIdentifierInFile = i * listCount + j });
|
|
idLists.Add(ids);
|
|
}
|
|
//ensure that all hashes are unique
|
|
var collisionDetection = new HashSet<Hash128>();
|
|
for (int i = 0; i < idLists.Count; i++)
|
|
{
|
|
var hash = ClusterBuildLayout.ComputeClusterId(idLists[i]);
|
|
Assert.IsTrue(collisionDetection.Add(hash));
|
|
}
|
|
//ensure that the hashes are deterministic
|
|
for (int i = 0; i < idLists.Count; i++)
|
|
{
|
|
var hash = ClusterBuildLayout.ComputeClusterId(idLists[i]);
|
|
Assert.IsTrue(collisionDetection.Contains(hash));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ClusterBuildLayout_Adding_New_Prefab_Preserves_Existing_Clusters()
|
|
{
|
|
var clusterResult1 = new ClusterOutput();
|
|
{
|
|
var buildParams = GetBuildParameters();
|
|
var depData = BuildBundleDepData(k_CubePath, k_CubePath2);
|
|
var writeData = new BundleWriteData();
|
|
var identifier = new PrefabPackedIdentifiers();
|
|
var result = ClusterBuildLayout.Run(buildParams, depData, writeData, identifier, clusterResult1, true);
|
|
Assert.AreEqual(ReturnCode.Success, result);
|
|
}
|
|
var clusterResult2 = new ClusterOutput();
|
|
{
|
|
var buildParams = GetBuildParameters();
|
|
var depData = BuildBundleDepData(k_CubePath, k_CubePath2, k_CubePath3);
|
|
var writeData = new BundleWriteData();
|
|
var identifier = new PrefabPackedIdentifiers();
|
|
var result = ClusterBuildLayout.Run(buildParams, depData, writeData, identifier, clusterResult2, true);
|
|
Assert.AreEqual(ReturnCode.Success, result);
|
|
}
|
|
Assert.Greater(clusterResult1.ObjectToCluster.Count, 0, "clusterResult1 should have clustered objects");
|
|
Assert.Greater(clusterResult2.ObjectToCluster.Count, 0, "clusterResult2 should have clustered objects");
|
|
|
|
// Check that all objects from clusterResult1 exist in clusterResult2 with the same cluster ID
|
|
foreach (var kvp in clusterResult1.ObjectToCluster)
|
|
{
|
|
var objectId = kvp.Key;
|
|
var cluster1 = kvp.Value;
|
|
|
|
Assert.IsTrue(clusterResult2.ObjectToCluster.ContainsKey(objectId),
|
|
$"Object {objectId} from clusterResult1 is missing in clusterResult2");
|
|
|
|
var cluster2 = clusterResult2.ObjectToCluster[objectId];
|
|
Assert.AreEqual(cluster1, cluster2,
|
|
$"Object {objectId} has different cluster IDs: {cluster1} in clusterResult1 vs {cluster2} in clusterResult2");
|
|
}
|
|
|
|
// Check that all local ID mappings from clusterResult1 exist in clusterResult2 with the same value
|
|
foreach (var kvp in clusterResult1.ObjectToLocalID)
|
|
{
|
|
var objectId = kvp.Key;
|
|
var localId1 = kvp.Value;
|
|
|
|
Assert.IsTrue(clusterResult2.ObjectToLocalID.ContainsKey(objectId),
|
|
$"Object {objectId} local ID mapping from clusterResult1 is missing in clusterResult2");
|
|
|
|
var localId2 = clusterResult2.ObjectToLocalID[objectId];
|
|
Assert.AreEqual(localId1, localId2,
|
|
$"Object {objectId} has different local IDs: {localId1} in clusterResult1 vs {localId2} in clusterResult2");
|
|
}
|
|
|
|
// Verify that clusterResult2 has more mappings due to the additional prefab
|
|
Assert.Greater(clusterResult2.ObjectToCluster.Count, clusterResult1.ObjectToCluster.Count,
|
|
"clusterResult2 should have more clustered objects due to the additional prefab");
|
|
Assert.Greater(clusterResult2.ObjectToLocalID.Count, clusterResult1.ObjectToLocalID.Count,
|
|
"clusterResult2 should have more local ID mappings due to the additional prefab");
|
|
}
|
|
|
|
[Test]
|
|
public void ClusterBuildLayout_Produces_ExpectedResults([Values(true, false)] bool useContentIds)
|
|
{
|
|
// Create concrete test data for ClusterBuildLayout.Run parameters
|
|
var buildParams = GetBuildParameters();
|
|
var depData = BuildBundleDepData(k_CubePath, k_CubePath2);
|
|
var writeData = new BundleWriteData();
|
|
var identifier = new PrefabPackedIdentifiers();
|
|
var clusterResult = new ClusterOutput();
|
|
|
|
var result = ClusterBuildLayout.Run(buildParams, depData, writeData, identifier, clusterResult, true);
|
|
|
|
Assert.AreEqual(ReturnCode.Success, result);
|
|
// Verify that clustering produced expected outputs
|
|
Assert.AreEqual(writeData.WriteOperations.Count, 3, "Expected 3 clusters");
|
|
|
|
for (int i = 0; i < writeData.WriteOperations.Count; i++)
|
|
{
|
|
var writeOp1 = writeData.WriteOperations[i];
|
|
if (writeOp1.Command == null || writeOp1.Command.serializeObjects == null)
|
|
continue;
|
|
|
|
var serializedObjects1 = new HashSet<ObjectIdentifier>(
|
|
writeOp1.Command.serializeObjects.Select(s => s.serializationObject));
|
|
|
|
for (int j = i + 1; j < writeData.WriteOperations.Count; j++)
|
|
{
|
|
var writeOp2 = writeData.WriteOperations[j];
|
|
if (writeOp2.Command == null || writeOp2.Command.serializeObjects == null)
|
|
continue;
|
|
|
|
foreach (var serializationInfo in writeOp2.Command.serializeObjects)
|
|
{
|
|
Assert.IsFalse(serializedObjects1.Contains(serializationInfo.serializationObject),
|
|
$"WriteOperation {i} (fileName: {writeOp1.Command.fileName}) and WriteOperation {j} " +
|
|
$"(fileName: {writeOp2.Command.fileName}) both contain the same serialized object: {serializationInfo.serializationObject}");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
#endif
|
|
|
|
ScriptableBuildPipeline.Settings LoadSettingsFromFile()
|
|
{
|
|
var settings = new ScriptableBuildPipeline.Settings();
|
|
if (File.Exists(ScriptableBuildPipeline.kSettingPath))
|
|
{
|
|
var json = File.ReadAllText(ScriptableBuildPipeline.kSettingPath);
|
|
EditorJsonUtility.FromJsonOverwrite(json, settings);
|
|
}
|
|
return settings;
|
|
}
|
|
|
|
void AssertSettingsChanged(ScriptableBuildPipeline.Settings preSettings, ScriptableBuildPipeline.Settings postSettings, FieldInfo[] fields, int fieldChanged)
|
|
{
|
|
for (int i = 0; i < fields.Length; i++)
|
|
{
|
|
if (i == fieldChanged)
|
|
Assert.AreNotEqual(fields[i].GetValue(preSettings), fields[i].GetValue(postSettings), $"Unexpected field '{fields[i].Name}' value is unchanged.");
|
|
else
|
|
Assert.AreEqual(fields[i].GetValue(preSettings), fields[i].GetValue(postSettings), $"Unexpected field '{fields[i].Name}' value is changed.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void PreferencesProperties_ChangesSerializeToDisk()
|
|
{
|
|
PropertyInfo[] properties = typeof(ScriptableBuildPipeline).GetProperties(BindingFlags.Public | BindingFlags.Static);
|
|
FieldInfo[] fields = typeof(ScriptableBuildPipeline.Settings).GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
|
|
for (int i = 0; i < properties.Length; i++)
|
|
{
|
|
var preSettings = LoadSettingsFromFile();
|
|
|
|
if (properties[i].PropertyType == typeof(bool))
|
|
{
|
|
bool previousValue = (bool)fields[i].GetValue(preSettings);
|
|
properties[i].SetValue(null, !previousValue);
|
|
}
|
|
else if (properties[i].PropertyType == typeof(int))
|
|
{
|
|
int previousValue = (int)fields[i].GetValue(preSettings);
|
|
properties[i].SetValue(null, previousValue + 5);
|
|
}
|
|
else if (properties[i].PropertyType == typeof(string))
|
|
{
|
|
string previousValue = (string)fields[i].GetValue(preSettings);
|
|
properties[i].SetValue(null, previousValue + "Test");
|
|
}
|
|
else
|
|
{
|
|
Assert.Fail($"Unhandled property type '{properties[i].PropertyType.Name}' in test '{nameof(PreferencesProperties_ChangesSerializeToDisk)}'");
|
|
}
|
|
|
|
AssertSettingsChanged(preSettings, LoadSettingsFromFile(), fields, i);
|
|
}
|
|
}
|
|
|
|
internal class StoreCacheServerConfig : IDisposable
|
|
{
|
|
private bool m_StoredUseServerFlag;
|
|
private string m_StoredServerHost;
|
|
private int m_UseServerPort;
|
|
|
|
public StoreCacheServerConfig(bool useCacheServer, string host, int port)
|
|
{
|
|
m_StoredUseServerFlag = ScriptableBuildPipeline.UseBuildCacheServer;
|
|
ScriptableBuildPipeline.UseBuildCacheServer = useCacheServer;
|
|
|
|
m_StoredServerHost = ScriptableBuildPipeline.CacheServerHost;
|
|
ScriptableBuildPipeline.CacheServerHost = host;
|
|
|
|
m_UseServerPort = ScriptableBuildPipeline.CacheServerPort;
|
|
ScriptableBuildPipeline.CacheServerPort = port;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
ScriptableBuildPipeline.UseBuildCacheServer = m_StoredUseServerFlag;
|
|
ScriptableBuildPipeline.CacheServerHost = m_StoredServerHost;
|
|
ScriptableBuildPipeline.CacheServerPort = m_UseServerPort;
|
|
}
|
|
}
|
|
}
|
|
}
|