public void TestCDOModification()
{
var tester = new UAsset(Path.Combine("TestManyAssets", "Astroneer", "Augment_BroadBrush.uasset"), UE4Version.VER_UE4_23);
Assert.IsTrue(tester.VerifyBinaryEquality());
NormalExport cdoExport = null;
foreach (Export testExport in tester.Exports)
{
if (testExport.ObjectFlags.HasFlag(EObjectFlags.RF_ClassDefaultObject))
{
cdoExport = (NormalExport)testExport;
break;
}
}
Assert.IsNotNull(cdoExport);
cdoExport["PickupActor"] = new ObjectPropertyData()
{
Value = FPackageIndex.FromRawIndex(0)
};
Assert.IsTrue(cdoExport["PickupActor"] is ObjectPropertyData);
Assert.IsTrue(((ObjectPropertyData)cdoExport["PickupActor"]).Value.Index == 0);
}
public void TestUnknownProperties()
{
var tester = new UAsset(Path.Combine("TestUnknownProperties", "BP_DetPack_Charge.uasset"), UE4Version.VER_UE4_25);
Assert.IsTrue(tester.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester));
// Check that only the expected unknown properties are present
Dictionary <string, bool> newUnknownProperties = new Dictionary <string, bool>();
newUnknownProperties.Add("GarbagePropty", false);
newUnknownProperties.Add("EvenMoreGarbageTestingPropertyy", false);
foreach (Export testExport in tester.Exports)
{
if (testExport is NormalExport normalTestExport)
{
foreach (PropertyData prop in normalTestExport.Data)
{
if (prop is UnknownPropertyData unknownProp)
{
string serializingType = unknownProp?.SerializingPropertyType?.Value?.Value;
Assert.AreNotEqual(serializingType, null);
Assert.IsTrue(newUnknownProperties.ContainsKey(serializingType));
newUnknownProperties[serializingType] = true;
}
}
}
}
foreach (KeyValuePair <string, bool> entry in newUnknownProperties)
{
Assert.IsTrue(entry.Value);
}
}
public void TestCustomProperty()
{
var tester = new UAsset(Path.Combine("TestCustomProperty", "AlternateStartActor.uasset"), UE4Version.VER_UE4_23);
Assert.IsTrue(tester.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester));
// Make sure that there are no unknown properties, and that there is at least one CoolProperty with a value of 72
bool hasCoolProperty = false;
foreach (Export testExport in tester.Exports)
{
if (testExport is NormalExport normalTestExport)
{
foreach (PropertyData prop in normalTestExport.Data)
{
Assert.IsFalse(prop is UnknownPropertyData);
if (prop is CoolPropertyData coolProp)
{
hasCoolProperty = true;
Assert.IsTrue(coolProp.Value == 72);
}
}
}
}
Assert.IsTrue(hasCoolProperty);
}
public void TestImproperNameMapHashes()
{
var tester = new UAsset(Path.Combine("TestImproperNameMapHashes", "OC_Gatling_DamageB_B.uasset"), UE4Version.VER_UE4_25);
Assert.IsTrue(tester.VerifyBinaryEquality());
Dictionary <string, bool> testingEntries = new Dictionary <string, bool>();
testingEntries["/Game/WeaponsNTools/GatlingGun/Overclocks/OC_BonusesAndPenalties/OC_Bonus_MovmentBonus_150p"] = false;
testingEntries["/Game/WeaponsNTools/GatlingGun/Overclocks/OC_BonusesAndPenalties/OC_Bonus_MovmentBonus_150p.OC_Bonus_MovmentBonus_150p"] = false;
foreach (KeyValuePair <FString, uint> overrideHashes in tester.OverrideNameMapHashes)
{
if (testingEntries.ContainsKey(overrideHashes.Key.Value))
{
Assert.IsTrue(overrideHashes.Value == 0);
testingEntries[overrideHashes.Key.Value] = true;
}
}
foreach (KeyValuePair <string, bool> testingEntry in testingEntries)
{
Assert.IsTrue(testingEntry.Value);
}
}
public void TestCustomSerializationStructsInMap()
{
var tester = new UAsset(Path.Combine("TestCustomSerializationStructsInMap", "wtf.uasset"), UE4Version.VER_UE4_25);
Assert.IsTrue(tester.VerifyBinaryEquality());
// Get the map property in export 2
Export exportTwo = FPackageIndex.FromRawIndex(2).ToExport(tester);
Assert.IsTrue(exportTwo is NormalExport);
NormalExport exportTwoNormal = (NormalExport)exportTwo;
var mapPropertyName = FName.FromString("KekWait");
MapPropertyData testMap = exportTwoNormal[mapPropertyName] as MapPropertyData;
Assert.IsNotNull(testMap);
Assert.IsTrue(testMap == exportTwoNormal[mapPropertyName.Value.Value]);
// Get the first entry of the map
StructPropertyData entryKey = testMap?.Value?.Keys?.ElementAt(0) as StructPropertyData;
StructPropertyData entryValue = testMap?.Value?[0] as StructPropertyData;
Assert.IsNotNull(entryKey?.Value?[0]);
Assert.IsNotNull(entryValue?.Value?[0]);
// Check that the properties are correct
Assert.IsTrue(entryKey.Value[0] is VectorPropertyData);
Assert.IsTrue(entryValue.Value[0] is LinearColorPropertyData);
}
public void TestDataTables()
{
var tester = new UAsset(Path.Combine("TestDatatables", "PB_DT_RandomizerRoomCheck.uasset"), UE4Version.VER_UE4_18);
Assert.IsTrue(tester.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester));
Assert.IsTrue(tester.Exports.Count == 1);
var ourDataTableExport = tester.Exports[0] as DataTableExport;
var ourTable = ourDataTableExport?.Table;
Assert.IsNotNull(ourTable);
// Check out the first entry to make sure it's parsing alright, and flip all the flags for later testing
StructPropertyData firstEntry = ourTable.Data[0];
bool didFindTestName = false;
for (int i = 0; i < firstEntry.Value.Count; i++)
{
var propData = firstEntry.Value[i];
Debug.WriteLine(i + ": " + propData.Name + ", " + propData.PropertyType);
if (propData.Name == new FName("AcceleratorANDDoubleJump"))
{
didFindTestName = true;
}
if (propData is BoolPropertyData boolProp)
{
boolProp.Value = !boolProp.Value;
}
}
Assert.IsTrue(didFindTestName);
// Save the modified table
tester.Write(Path.Combine("TestDatatables", "MODIFIED.uasset"));
// Load the modified table back in and make sure we're good
var tester2 = new UAsset(Path.Combine("TestDatatables", "MODIFIED.uasset"), UE4Version.VER_UE4_18);
Assert.IsTrue(tester2.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester2));
Assert.IsTrue(tester2.Exports.Count == 1);
// Flip the flags back to what they originally were
firstEntry = (tester2.Exports[0] as DataTableExport)?.Table?.Data?[0];
Assert.IsNotNull(firstEntry);
for (int i = 0; i < firstEntry.Value.Count; i++)
{
if (firstEntry.Value[i] is BoolPropertyData boolProp)
{
boolProp.Value = !boolProp.Value;
}
}
// Save and check that it's binary equal to what we originally had
tester2.Write(tester2.FilePath);
Assert.IsTrue(File.ReadAllBytes(Path.Combine("TestDatatables", "PB_DT_RandomizerRoomCheck.uasset")).SequenceEqual(File.ReadAllBytes(Path.Combine("TestDatatables", "MODIFIED.uasset"))));
}
private void TestManyAssetsSubsection(string game, UE4Version version)
{
string[] allTestingAssets = GetAllTestAssets(Path.Combine("TestManyAssets", game));
foreach (string assetPath in allTestingAssets)
{
Debug.WriteLine(assetPath);
var tester = new UAsset(assetPath, version);
Assert.IsTrue(tester.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester));
}
}
private void TestJsonOnFile(string file, UE4Version version)
{
Debug.WriteLine(file);
var tester = new UAsset(Path.Combine("TestJson", file), version);
Assert.IsTrue(tester.VerifyBinaryEquality());
Assert.IsTrue(CheckAllExportsParsedCorrectly(tester));
string jsonSerializedAsset = tester.SerializeJson();
File.WriteAllText(Path.Combine("TestJson", "raw.json"), jsonSerializedAsset);
var tester2 = UAsset.DeserializeJson(File.ReadAllText(Path.Combine("TestJson", "raw.json")));
tester2.Write(Path.Combine("TestJson", "MODIFIED.uasset"));
// For the assets we're testing binary equality is maintained and can be used as a metric of success, but binary equality is not guaranteed for most assets
Assert.IsTrue(File.ReadAllBytes(Path.Combine("TestJson", file)).SequenceEqual(File.ReadAllBytes(Path.Combine("TestJson", "MODIFIED.uasset"))));
}