719 lines
27 KiB
C#
719 lines
27 KiB
C#
using NUnit.Framework;
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnityEditor;
|
|
using UnityEditor.AddressableAssets.Build.BuildPipelineTasks;
|
|
using UnityEditor.AddressableAssets.Build.DataBuilders;
|
|
using UnityEditor.AddressableAssets.Build.Layout;
|
|
using UnityEditor.AddressableAssets.Settings;
|
|
using UnityEditor.AddressableAssets.Settings.GroupSchemas;
|
|
using UnityEditor.AddressableAssets.Tests;
|
|
using UnityEditor.Build.Pipeline.Utilities;
|
|
using UnityEditor.SceneManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
using UnityEngine.U2D;
|
|
using UnityEditor.U2D;
|
|
using UnityEditor.Presets;
|
|
|
|
public class BuildLayoutGenerationTaskTests
|
|
{
|
|
AddressableAssetSettings m_Settings;
|
|
|
|
AddressableAssetSettings Settings
|
|
{
|
|
get
|
|
{
|
|
if (m_Settings == null)
|
|
{
|
|
var path = Path.Combine(TempPath, "Settings", "/AddressableAssetSettings.Tests.asset");
|
|
m_Settings = AssetDatabase.LoadAssetAtPath<AddressableAssetSettings>(path);
|
|
}
|
|
|
|
return m_Settings;
|
|
}
|
|
}
|
|
|
|
static string kTempPath = "Assets/BuildLayoutGenerationTaskTestsData";
|
|
static string TempPath;
|
|
static int ExecCount;
|
|
bool m_PrevGenerateBuildLayout;
|
|
ProjectConfigData.ReportFileFormat m_PrevFileFormat;
|
|
|
|
[OneTimeSetUp]
|
|
public void OneTimeSetup()
|
|
{
|
|
ExecCount = 0;
|
|
}
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
TempPath = kTempPath + (ExecCount++).ToString();
|
|
foreach (var fileFormat in Enum.GetValues(typeof(ProjectConfigData.ReportFileFormat)))
|
|
{
|
|
string layoutFile = BuildLayoutGenerationTask.GetLayoutFilePathForFormat((ProjectConfigData.ReportFileFormat)fileFormat);
|
|
if (File.Exists(layoutFile))
|
|
File.Delete(layoutFile);
|
|
}
|
|
|
|
m_PrevGenerateBuildLayout = ProjectConfigData.GenerateBuildLayout;
|
|
m_PrevFileFormat = ProjectConfigData.BuildLayoutReportFileFormat;
|
|
BuildScriptPackedMode.s_SkipCompilePlayerScripts = true;
|
|
ProjectConfigData.GenerateBuildLayout = true;
|
|
if (Directory.Exists(TempPath))
|
|
Directory.Delete(TempPath, true);
|
|
Directory.CreateDirectory(TempPath);
|
|
|
|
m_Settings = AddressableAssetSettings.Create(Path.Combine(TempPath, "Settings"), "AddressableAssetSettings.Tests", false, true);
|
|
}
|
|
|
|
[TearDown]
|
|
public void Teardown()
|
|
{
|
|
BuildScriptPackedMode.s_SkipCompilePlayerScripts = false;
|
|
ProjectConfigData.GenerateBuildLayout = m_PrevGenerateBuildLayout;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = m_PrevFileFormat;
|
|
// Many of the tests keep recreating assets in the same path, so we need to unload them completely so they don't get reused by the next test
|
|
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(Settings));
|
|
Resources.UnloadAsset(Settings);
|
|
|
|
FileUtil.DeleteFileOrDirectory(TempPath);
|
|
FileUtil.DeleteFileOrDirectory(TempPath + ".meta");
|
|
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
string MakeAddressable(AddressableAssetGroup group, string guid, string address = null)
|
|
{
|
|
var entry = Settings.CreateOrMoveEntry(guid, group, false, false);
|
|
entry.address = address == null ? Path.GetFileNameWithoutExtension(entry.AssetPath) : address;
|
|
entry.BundleFileId = "GenericFileId";
|
|
return guid;
|
|
}
|
|
|
|
// Prefab asset emthods
|
|
|
|
static string CreatePrefabAsset(string name)
|
|
{
|
|
return CreatePrefabAsset($"{TempPath}/{name}.prefab", name);
|
|
}
|
|
|
|
static string CreatePrefabAsset(string assetPath, string objectName)
|
|
{
|
|
GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
|
go.name = objectName;
|
|
//this is to ensure that bundles are different for every run.
|
|
go.transform.localPosition = UnityEngine.Random.onUnitSphere;
|
|
PrefabUtility.SaveAsPrefabAsset(go, assetPath);
|
|
UnityEngine.Object.DestroyImmediate(go, false);
|
|
return AssetDatabase.AssetPathToGUID(assetPath);
|
|
}
|
|
|
|
static string CreateScriptableObjectAsset(string assetPath, string objectName)
|
|
{
|
|
TestObject.Create(objectName, assetPath);
|
|
return AssetDatabase.AssetPathToGUID(assetPath);
|
|
}
|
|
|
|
string CreateAddressablePrefab(string name, AddressableAssetGroup group)
|
|
{
|
|
string guid = CreatePrefabAsset($"{TempPath}/{name}.prefab", name);
|
|
return MakeAddressable(group, guid);
|
|
}
|
|
|
|
string CreateAddressableScriptableObject(string name, AddressableAssetGroup group)
|
|
{
|
|
string guid = CreateScriptableObjectAsset($"{TempPath}/{name}.asset", name);
|
|
return MakeAddressable(group, guid);
|
|
}
|
|
|
|
bool DeletePrefab(string name)
|
|
{
|
|
string path = $"{TempPath}/{name}.prefab";
|
|
return AssetDatabase.DeleteAsset(path);
|
|
}
|
|
|
|
bool DeleteScriptableObject(string name)
|
|
{
|
|
string path = $"{TempPath}/{name}.asset";
|
|
return AssetDatabase.DeleteAsset(path);
|
|
}
|
|
|
|
// Texture asset creation
|
|
|
|
static string CreateTexture(string name, int size = 32)
|
|
{
|
|
string assetPath = $"{TempPath}/{name}.png";
|
|
var texture = new Texture2D(size, size);
|
|
var data = ImageConversion.EncodeToPNG(texture);
|
|
UnityEngine.Object.DestroyImmediate(texture);
|
|
File.WriteAllBytes(assetPath, data);
|
|
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
|
|
return AssetDatabase.AssetPathToGUID(assetPath);
|
|
}
|
|
|
|
string CreateAddressableTexture(string name, AddressableAssetGroup group, int size = 32)
|
|
{
|
|
string guid = CreateTexture(name, size);
|
|
TextureImporter ti = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GUIDToAssetPath(guid));
|
|
ti.isReadable = false;
|
|
ti.SaveAndReimport();
|
|
return MakeAddressable(group, guid);
|
|
}
|
|
|
|
static string CreateSpriteAtlas(string name, string guidTargetTexture)
|
|
{
|
|
var sa = new SpriteAtlas();
|
|
var targetObjects = new UnityEngine.Object[] {AssetDatabase.LoadAssetAtPath<Texture>(AssetDatabase.GUIDToAssetPath(guidTargetTexture))};
|
|
sa.Add(targetObjects);
|
|
string saPath = $"{TempPath}/{name}.spriteAtlas";
|
|
AssetDatabase.CreateAsset(sa, saPath);
|
|
AssetDatabase.Refresh();
|
|
return AssetDatabase.AssetPathToGUID(saPath);
|
|
}
|
|
|
|
bool DeleteSpriteAtlas(string name)
|
|
{
|
|
string assetPath = $"{TempPath}/{name}.spriteAtlas";
|
|
return AssetDatabase.DeleteAsset(assetPath);
|
|
}
|
|
|
|
static string CreateSpriteTexture(string name, int size, bool includesSource)
|
|
{
|
|
string guid = CreateTexture(name, size);
|
|
string texturePath = AssetDatabase.GUIDToAssetPath(guid);
|
|
TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GUIDToAssetPath(guid));
|
|
importer.textureType = TextureImporterType.Sprite; // creates a sprite subobject
|
|
importer.spriteImportMode = SpriteImportMode.Single;
|
|
importer.SaveAndReimport();
|
|
return guid;
|
|
}
|
|
|
|
bool DeleteTexture(string name)
|
|
{
|
|
string assetPath = $"{TempPath}/{name}.png";
|
|
return AssetDatabase.DeleteAsset(assetPath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a component to Prefab that references assetToReference
|
|
/// </summary>
|
|
/// <param name="prefabGUID"></param>
|
|
/// <param name="assetToReferenceGUID"></param>
|
|
void MakePefabReference(string prefabGUID, string assetToReferenceGUID)
|
|
{
|
|
GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(prefabGUID));
|
|
UnityEngine.Object target = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(AssetDatabase.GUIDToAssetPath(assetToReferenceGUID));
|
|
prefab.AddComponent<TestBehaviourWithReference>().Reference = target;
|
|
}
|
|
|
|
AddressableAssetGroup CreateGroup(string name)
|
|
{
|
|
return Settings.CreateGroup(name, false, false, false, null, typeof(BundledAssetGroupSchema));
|
|
}
|
|
|
|
void PrintText(BuildLayout layout)
|
|
{
|
|
MemoryStream stream = new MemoryStream();
|
|
BuildLayoutPrinter.WriteBundleLayout(stream, layout);
|
|
string report = Encoding.ASCII.GetString(stream.ToArray());
|
|
Debug.Log(report);
|
|
}
|
|
|
|
internal BuildLayout BuildAndExtractLayout()
|
|
{
|
|
try
|
|
{
|
|
BuildLayout layout = null;
|
|
BuildLayoutGenerationTask.s_LayoutCompleteCallback = (x, y) => layout = y;
|
|
Settings.BuildPlayerContentImpl();
|
|
return layout;
|
|
}
|
|
finally
|
|
{
|
|
BuildLayoutGenerationTask.s_LayoutCompleteCallback = null;
|
|
}
|
|
}
|
|
|
|
class WebExtractSession : IDisposable
|
|
{
|
|
public string DataDirectory;
|
|
public string[] Files;
|
|
|
|
public WebExtractSession(string filePath)
|
|
{
|
|
DataDirectory = filePath + "_data";
|
|
if (Directory.Exists(DataDirectory))
|
|
throw new Exception("Bundle data directory already exists");
|
|
|
|
var baseDir = Path.GetDirectoryName(EditorApplication.applicationPath);
|
|
var webExtractFiles = Directory.GetFiles(baseDir, "WebExtract*", SearchOption.AllDirectories);
|
|
string webExtractPath = webExtractFiles[0];
|
|
|
|
Assert.IsTrue(File.Exists(filePath), "Param filePath does not point to an existing file.");
|
|
|
|
var process = new System.Diagnostics.Process
|
|
{
|
|
StartInfo =
|
|
{
|
|
FileName = webExtractPath,
|
|
Arguments = string.Format(@"""{0}""", filePath),
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true
|
|
}
|
|
};
|
|
process.Start();
|
|
|
|
var output = process.StandardOutput.ReadToEnd();
|
|
process.WaitForExit();
|
|
|
|
var exitCode = process.ExitCode;
|
|
process.Close();
|
|
|
|
Assert.AreEqual(0, exitCode);
|
|
Files = Directory.GetFiles(DataDirectory);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Directory.Delete(DataDirectory, true);
|
|
}
|
|
}
|
|
|
|
internal void AssertEditorBundleDetailsMatchPhysicalBundle(string bundlePath, BuildLayout.Bundle bundle)
|
|
{
|
|
Assert.AreEqual(new FileInfo(bundlePath).Length, bundle.FileSize);
|
|
using (var wes = new WebExtractSession(bundlePath))
|
|
{
|
|
Assert.AreEqual(bundle.Files.Sum(x => x.SubFiles.Count), wes.Files.Length);
|
|
foreach (BuildLayout.SubFile sf in bundle.Files.SelectMany(x => x.SubFiles))
|
|
{
|
|
string filename = Path.Combine(wes.DataDirectory, sf.Name);
|
|
Assert.AreEqual(sf.Size, new FileInfo(filename).Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBundleReferencesAnotherBundle_ExternalReferenceExists()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
AddressableAssetGroup group2 = null;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
group = CreateGroup("Group1");
|
|
string prefabGUID = CreateAddressablePrefab("p1", group);
|
|
group2 = CreateGroup("Group2");
|
|
string g2p1GUID = CreateAddressablePrefab("g2p1", group2);
|
|
MakePefabReference(prefabGUID, g2p1GUID);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
CollectionAssert.Contains(layout.Groups[0].Bundles[0].Dependencies, layout.Groups[1].Bundles[0]);
|
|
Assert.AreEqual(layout.Groups[0].Bundles[0].Files[0].Assets[0].ExternallyReferencedAssets[0], layout.Groups[1].Bundles[0].Files[0].Assets[0]);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (group2 != null)
|
|
Settings.RemoveGroup(group2);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
DeletePrefab("g2p1");
|
|
}
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void WhenAssetImplicitlyPulledIntoBundle_ImplicitEntryAndReferencesCreated()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
group = CreateGroup("Group1");
|
|
string prefabGUID = CreateAddressablePrefab("p1", group);
|
|
string aGUID = CreatePrefabAsset("p2");
|
|
MakePefabReference(prefabGUID, aGUID);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
BuildLayout.DataFromOtherAsset oa = layout.Groups[0].Bundles[0].Files[0].OtherAssets.First(x => x.AssetPath.Contains("p2.prefab"));
|
|
Assert.AreEqual(aGUID, oa.AssetGuid);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
DeletePrefab("p2");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBundleContainsMultipleFiles_FilesAndSizesMatchArchiveContent()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
string scenePath = $"{TempPath}/scene.unity";
|
|
AddressableAssetGroup groupScenes = null;
|
|
AddressableAssetGroup textureGroup = null;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
groupScenes = CreateGroup("SceneGroup");
|
|
textureGroup = CreateGroup("TextureGroup");
|
|
|
|
Scene scene1 = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
new GameObject().AddComponent<TestBehaviourWithReference>();
|
|
EditorSceneManager.SaveScene(scene1, scenePath);
|
|
Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(scenePath), groupScenes);
|
|
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
|
|
CreateAddressableTexture("t1", textureGroup, 256);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
BundledAssetGroupSchema schema = Settings.groups.First(x => x.HasSchema<BundledAssetGroupSchema>()).GetSchema<BundledAssetGroupSchema>();
|
|
string path = schema.BuildPath.GetValue(Settings);
|
|
foreach (BuildLayout.Bundle bundle in layout.Groups.SelectMany(x => x.Bundles))
|
|
AssertEditorBundleDetailsMatchPhysicalBundle(Path.Combine(path, bundle.Name), bundle);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (groupScenes != null)
|
|
Settings.RemoveGroup(groupScenes);
|
|
if (textureGroup != null)
|
|
Settings.RemoveGroup(textureGroup);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
AssetDatabase.DeleteAsset(scenePath);
|
|
DeleteTexture("t1");
|
|
}
|
|
}
|
|
|
|
// Even though slim writes is true, the system will enable it if it needs to generate a build layout report
|
|
[Test]
|
|
public void WhenSlimWriteResultsIsTrue_LayoutStillGenerated()
|
|
{
|
|
ProjectConfigData.ReportFileFormat fileFormat = ProjectConfigData.ReportFileFormat.TXT;
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(fileFormat);
|
|
AddressableAssetGroup group = null;
|
|
bool prevSlim = ScriptableBuildPipeline.slimWriteResults;
|
|
ProjectConfigData.ReportFileFormat prevFileFormat = ProjectConfigData.BuildLayoutReportFileFormat;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
ScriptableBuildPipeline.slimWriteResults = true;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = fileFormat;
|
|
group = CreateGroup("Group1");
|
|
CreateAddressablePrefab("p1", group);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildAndExtractLayout();
|
|
|
|
FileAssert.Exists(layoutFilePath);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
ScriptableBuildPipeline.slimWriteResults = prevSlim;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = prevFileFormat;
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBuildLayoutIsDisabled_BuildLayoutIsNotGenerated()
|
|
{
|
|
ProjectConfigData.ReportFileFormat fileFormat = ProjectConfigData.ReportFileFormat.TXT;
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(fileFormat);
|
|
AddressableAssetGroup group = null;
|
|
bool prevGenerateBuildLayout = ProjectConfigData.GenerateBuildLayout;
|
|
ProjectConfigData.ReportFileFormat prevFileFormat = ProjectConfigData.BuildLayoutReportFileFormat;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
ProjectConfigData.GenerateBuildLayout = false;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = fileFormat;
|
|
group = CreateGroup("Group1");
|
|
CreateAddressablePrefab("p1", group);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildAndExtractLayout();
|
|
|
|
// Test
|
|
FileAssert.DoesNotExist(layoutFilePath);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
ProjectConfigData.GenerateBuildLayout = prevGenerateBuildLayout;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = prevFileFormat;
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[TestCase(ProjectConfigData.ReportFileFormat.TXT)]
|
|
[TestCase(ProjectConfigData.ReportFileFormat.JSON)]
|
|
public void WhenBuildLayoutIsEnabled_BuildLayoutIsGenerated(ProjectConfigData.ReportFileFormat format)
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(format);
|
|
AddressableAssetGroup group = null;
|
|
bool prevGenerateBuildLayout = ProjectConfigData.GenerateBuildLayout;
|
|
ProjectConfigData.ReportFileFormat prevFileFormat = ProjectConfigData.BuildLayoutReportFileFormat;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
ProjectConfigData.GenerateBuildLayout = true;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = format;
|
|
group = CreateGroup("Group1");
|
|
CreateAddressablePrefab("p1", group);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildAndExtractLayout();
|
|
|
|
// Test
|
|
FileAssert.Exists(layoutFilePath);
|
|
if (format == ProjectConfigData.ReportFileFormat.JSON)
|
|
{
|
|
string text = File.ReadAllText(layoutFilePath);
|
|
var layout = JsonUtility.FromJson<BuildLayout>(text);
|
|
Assert.IsNotNull(layout);
|
|
}
|
|
}
|
|
finally // cleanup
|
|
{
|
|
ProjectConfigData.GenerateBuildLayout = prevGenerateBuildLayout;
|
|
ProjectConfigData.BuildLayoutReportFileFormat = prevFileFormat;
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenAssetHasStreamedData_IsReportedCorrectly()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
group = CreateGroup("Group1");
|
|
CreateAddressableTexture("t1", group, 256);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
Assert.IsTrue(layout.Groups[0].Bundles[0].Files[0].Assets[0].StreamedSize != 0);
|
|
BuildLayout.SubFile f = layout.Groups[0].Bundles[0].Files[0].SubFiles.First(x => x.Name.EndsWith(".resS"));
|
|
Assert.IsFalse(f.IsSerializedFile);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeleteTexture("t1");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenAllContentsOfAnAssetAreStripped_ExplicitAssetHasNoObjects()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
string assetPath = $"{TempPath}/testpreset.preset";
|
|
|
|
try
|
|
{
|
|
// setup
|
|
Material obj = new Material(Shader.Find("Transparent/Diffuse"));
|
|
Preset myPreset = new Preset(obj);
|
|
AssetDatabase.CreateAsset(myPreset, assetPath);
|
|
GameObject.DestroyImmediate(obj);
|
|
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
|
|
string guid = AssetDatabase.AssetPathToGUID(assetPath);
|
|
group = CreateGroup("Group1");
|
|
MakeAddressable(group, guid);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
Assert.AreEqual(0, layout.Groups[0].Bundles[0].Files[0].Assets[0].SerializedSize);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
AssetDatabase.DeleteAsset(assetPath);
|
|
}
|
|
}
|
|
|
|
class SpritePackerScope : IDisposable
|
|
{
|
|
SpritePackerMode m_PrevMode;
|
|
|
|
public SpritePackerScope(SpritePackerMode mode)
|
|
{
|
|
m_PrevMode = EditorSettings.spritePackerMode;
|
|
EditorSettings.spritePackerMode = mode;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
EditorSettings.spritePackerMode = m_PrevMode;
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenReferencedObjectIdentifiedWithFilename_ObjectRepresentedInDataFromOtherAssets()
|
|
{
|
|
using (new SpritePackerScope(SpritePackerMode.BuildTimeOnlyAtlas))
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
BuildCache.PurgeCache(false);
|
|
group = CreateGroup("Group1");
|
|
string textureGUID = CreateSpriteTexture("spritetexture", 256, false);
|
|
MakeAddressable(group, CreateSpriteAtlas("atlas", textureGUID));
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
BuildLayout.DataFromOtherAsset otherAssets = layout.Groups[0].Bundles[0].Files[0].Assets[0].InternalReferencedOtherAssets[0];
|
|
Assert.AreEqual(2, layout.Groups[0].Bundles[0].Files[0].Assets[0].InternalReferencedOtherAssets.Count);
|
|
CollectionAssert.Contains(otherAssets.ReferencingAssets, layout.Groups[0].Bundles[0].Files[0].Assets[0]);
|
|
}
|
|
finally // cleanup
|
|
{
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeleteSpriteAtlas("atlas");
|
|
DeleteTexture("spritetexture");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBuildRemoteCatalogIsDisabled_BuildLayoutContainsCatalogHash()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
bool prevBuildRemoteCatalog = Settings.BuildRemoteCatalog;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
group = CreateGroup("Group1");
|
|
CreateAddressablePrefab("p1", group);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
Assert.IsFalse(string.IsNullOrEmpty(layout.AddressablesRuntimeSettings.CatalogHash), "Catalog Hash was not correctly written to the Layout");
|
|
Assert.AreEqual(32, layout.AddressablesRuntimeSettings.CatalogHash.Length, "Catalog Hash was not correctly written to the Layout, incorrect size for hash");
|
|
Assert.AreEqual(32, layout.BuildResultHash.Length, "Build is expected to have a result hash for the build");
|
|
}
|
|
finally // cleanup
|
|
{
|
|
Settings.BuildRemoteCatalog = prevBuildRemoteCatalog;
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeletePrefab("p1");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WhenBuildContainsMonoScripts_LayoutDoesNotHaveReferencesToMonoScriptAssets()
|
|
{
|
|
string layoutFilePath = BuildLayoutGenerationTask.GetLayoutFilePathForFormat(ProjectConfigData.BuildLayoutReportFileFormat);
|
|
AddressableAssetGroup group = null;
|
|
bool prevBuildRemoteCatalog = Settings.BuildRemoteCatalog;
|
|
|
|
try
|
|
{
|
|
// setup
|
|
group = CreateGroup("Group1");
|
|
CreateAddressableScriptableObject("so1", group);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
BuildLayout layout = BuildAndExtractLayout();
|
|
|
|
// Test
|
|
foreach (BuildLayout.ExplicitAsset explicitAsset in BuildLayoutHelpers.EnumerateAssets(layout))
|
|
{
|
|
foreach (var referencedAsset in explicitAsset.InternalReferencedExplicitAssets)
|
|
{
|
|
Assert.IsNotNull(referencedAsset, "Referenced Asset was null, this was likely a stripped MonoScript");
|
|
Assert.IsTrue(!referencedAsset.AssetPath.EndsWith(".cs") && referencedAsset.AssetPath.EndsWith(".dll"));
|
|
}
|
|
foreach (var referencedAsset in explicitAsset.ExternallyReferencedAssets)
|
|
{
|
|
Assert.IsNotNull(referencedAsset, "Referenced Asset was null, this was likely a stripped MonoScript");
|
|
Assert.IsTrue(!referencedAsset.AssetPath.EndsWith(".cs") && referencedAsset.AssetPath.EndsWith(".dll"));
|
|
}
|
|
foreach (var referencedAsset in explicitAsset.InternalReferencedOtherAssets)
|
|
{
|
|
Assert.IsNotNull(referencedAsset, "Referenced Asset was null, this was likely a stripped MonoScript");
|
|
Assert.IsTrue(!referencedAsset.AssetPath.EndsWith(".cs") && referencedAsset.AssetPath.EndsWith(".dll"));
|
|
}
|
|
}
|
|
}
|
|
finally // cleanup
|
|
{
|
|
Settings.BuildRemoteCatalog = prevBuildRemoteCatalog;
|
|
if (group != null)
|
|
Settings.RemoveGroup(group);
|
|
if (File.Exists(layoutFilePath))
|
|
File.Delete(layoutFilePath);
|
|
DeleteScriptableObject("so1");
|
|
}
|
|
}
|
|
}
|