public static void unrealtypedetails_has_the_correct_field_details_list_name_upon_creation()
{
var capitalisedName = "CapitalisedName";
var fieldDefinitionRaw = GenerateFieldDefinition("test", "1", new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = "float"
});
var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[] { fieldDefinitionRaw });
var packageDetails = GeneratePackageDetails();
var fieldDetails = new List <UnrealFieldDetails>();
fieldDetails.Add(new UnrealFieldDetails(fieldDefinitionRaw, new UnrealBuiltInTypeReference(fieldDefinitionRaw.singularType)));
var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, fieldDetails, packageDetails);
Assert.That(typeDetails.FieldDetailsList.Count() == 1, "The wrong number of field details were created during the creation of an unreal type details object");
Assert.That(typeDetails.FieldDetailsList.FirstOrDefault((fieldDetail) =>
{
return(fieldDetail.CapitalisedName == "Test" &&
fieldDetail.LowercaseName == "test" &&
fieldDetail.TypeReference.UnrealType == "float");
}) != null, "The generated field detail for the unreal type detail did not contain the correct data");
}
private List <UnrealTypeDetails> ProcessTypes(ICollection <SchemaFileRaw> schemaFiles)
{
var allTypeDefinitions = schemaFiles.SelectMany(schemaFile => schemaFile.typeDefinitions);
qualifiedNameToTypeDefinition = allTypeDefinitions.ToDictionary(typeDefinition => typeDefinition.qualifiedName, typeDefinition => typeDefinition);
var unrealTypes = new List <UnrealTypeDetails>();
foreach (var schemaFile in schemaFiles)
{
var packageDetails = unrealPackageDetails[schemaFile.canonicalName];
foreach (var typeDefinition in schemaFile.typeDefinitions)
{
var capitalisedTypeName = resolvedTypeToCapitalisedNames[typeDefinition];
var unrealType = new UnrealTypeDetails(typeDefinition, capitalisedTypeName, new List <UnrealFieldDetails>(), packageDetails);
unrealTypes.Add(unrealType);
typeDefinitionToUnrealType.Add(typeDefinition, unrealType);
}
}
ProcessFieldDetails(schemaFiles);
return(unrealTypes);
}
public static void run_executes_the_expected_file_operations_when_running_an_unrealtypejob()
{
var mockFileSystem = GenerateMockFileSystem();
mockFileSystem.GetFileInfoMock = (path) =>
{
var file = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1));
file.ExistsMock = () => { return(false); };
return(file);
};
mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>()); };
var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen");
var unrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails);
var typeJob = new UnrealTypeJob(unrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), Path.Combine("OutputDir", "test"), mockFileSystem);
var jobRunner = new JobRunner(mockFileSystem);
jobRunner.Run(new List <ICodegenJob>()
{
typeJob
}, new List <string>()
{
OutputDirectory
});
Assert.That(mockFileSystem.DirectoryExistsCallCount == 2);
Assert.That(mockFileSystem.WriteToFileCallCount == 2);
Assert.That(mockFileSystem.WrittenFiles.Count == 2);
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.h")));
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.cpp")));
}
public static void unrealcommanddetails_has_the_correct_unreal_command_delegate_name_upon_creation()
{
var capitalisedName = "CapitalisedName";
var qualifiedOwnerName = "improbable.codegen.Test";
var captialisedOwnerName = "improbable.codegen.OwnerComponent";
var commandDefinition = GenerateCommandDefinition("Test",
new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = null,
userType = "DamageResponse"
},
new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = null,
userType = "DamageRequest"
});
var packageDetails = GeneratePackageDetails();
var fieldDefinitionFloat = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = "float"
});
var fieldDefinitionInt32 = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = "int32"
});
var userTypeDefinition = ModelTypeFactory.GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[]
{
fieldDefinitionFloat,
fieldDefinitionInt32
});
var unrealFieldDetails = new List <UnrealFieldDetails>();
unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionFloat, new UnrealBuiltInTypeReference(fieldDefinitionFloat.singularType)));
unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionInt32, new UnrealBuiltInTypeReference(fieldDefinitionInt32.singularType)));
var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", unrealFieldDetails, null);
var requestTypeReference = new UnrealUserTypeReference(unrealTypeDetails);
var responseTypeReference = new UnrealUserTypeReference(unrealTypeDetails);
var commandDetails = new UnrealCommandDetails(commandDefinition, capitalisedName, qualifiedOwnerName, captialisedOwnerName, requestTypeReference, responseTypeReference, packageDetails);
Assert.That(commandDetails.UnrealCommandDelegateName == string.Format("F{0}Command", capitalisedName), "the field UnrealCommandDelegateName did not have the expected value upon creation");
}
public static void unrealtypedetails_has_the_correct_capitalised_qualified_name_upon_creation()
{
var capitalisedName = "CapitalisedName";
var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType");
var packageDetails = GeneratePackageDetails();
var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, new List <UnrealFieldDetails>(), packageDetails);
Assert.That(typeDetails.CapitalisedQualifiedName == Formatting.QualifiedNameToCapitalisedCamelCase(typeDefinition.qualifiedName), "the field CapitalisedQualifiedName did not have the expected value upon creation");
}
public static void unrealtypedetails_has_the_correct_underlying_capitalised_name_upon_creation()
{
var capitalisedName = "CapitalisedName";
var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType");
var packageDetails = GeneratePackageDetails();
var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, new List <UnrealFieldDetails>(), packageDetails);
Assert.That(typeDetails.UnderlyingCapitalisedName == "TestType", "the field UnderlyingCapitalisedName did not have the expected value upon creation");
}
public static void unrealusertypereference_is_initiated_as_expected_when_passed_an_user_type_reference()
{
var fieldDefinitionFloat = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = "float"
});
var fieldDefinitionInt32 = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw
{
sourceReference = new SourceReferenceRaw {
line = "1", column = "1"
},
builtInType = "int32"
});
var userTypeDefinition = ModelTypeFactory.GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[]
{
fieldDefinitionFloat,
fieldDefinitionInt32
});
var unrealFieldDetails = new List <UnrealFieldDetails>();
unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionFloat, new UnrealBuiltInTypeReference(fieldDefinitionFloat.singularType)));
unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionInt32, new UnrealBuiltInTypeReference(fieldDefinitionInt32.singularType)));
var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", unrealFieldDetails, null);
var unrealUserTypeReference = new UnrealUserTypeReference(unrealTypeDetails);
Assert.That(unrealUserTypeReference.UnderlyingCapitalisedName == "ImprobableCodegenTestType");
Assert.That(unrealUserTypeReference.RequiredIncludes.Count == 1);
Assert.That(unrealUserTypeReference.RequiredIncludes.Contains("\"TestType.h\""));
Assert.That(unrealUserTypeReference.UnderlyingQualifiedName == "improbable::codegen::TestType");
Assert.That(unrealUserTypeReference.UnrealType == "UTestType*");
Assert.That(unrealUserTypeReference.AssignUnderlyingValueToUnrealMemberVariable("TestField", "val") == "if (TestField == nullptr) { TestField = NewObject<UTestType>(this); } TestField->Init(val)");
Assert.That(unrealUserTypeReference.ConvertUnderlyingValueToUnrealLocalVariable("val") == "NewObject<UTestType>()->Init(val)");
Assert.That(unrealUserTypeReference.ConvertUnderlyingValueToUnrealMemberVariable("val") == "NewObject<UTestType>(this)->Init(val)");
Assert.That(unrealUserTypeReference.ConvertUnrealValueToSnapshotValue("val") == "val->GetUnderlying()");
Assert.That(unrealUserTypeReference.ConvertUnrealValueToUnderlyingValue("val") == "val->GetUnderlying()");
Assert.That(unrealUserTypeReference.DefaultInitialisationString == "improbable::codegen::TestType(0, 0)");
Assert.That(unrealUserTypeReference.SnapshotType == "improbable::codegen::TestType");
}
public static void run_does_not_clean_output_folders_of_jobs_if_the_output_folder_contains_the_files_to_be_generated()
{
var mockFileSystem = GenerateMockFileSystem();
mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) =>
{
return(new List <IFile>()
{
new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)),
new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1))
});
};
mockFileSystem.GetFileInfoMock = (path) =>
{
var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1));
fileMock.ExistsMock = () => { return(true); };
return(fileMock);
};
var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen");
var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails);
var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem);
var jobRunner = new JobRunner(mockFileSystem);
jobRunner.Run(new List <ICodegenJob>()
{
cleanTypeJob
}, new List <string>()
{
OutputDirectory
});
//This validates that the output folder was not deleted
Assert.That(mockFileSystem.DeleteDirectoryCallCount == 0);
Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1);
//This validates that no codegen jobs were run as they were expected to not be dirty.
Assert.That(mockFileSystem.WriteToFileCallCount == 0);
Assert.That(mockFileSystem.DirectoryExistsCallCount == 0);
Assert.That(mockFileSystem.DirectoryExistsCallCount == 0);
Assert.That(mockFileSystem.WriteToFileCallCount == 0);
Assert.That(cleanTypeJob.IsDirty() == false);
}
public static void unreallisttypereference_is_initiated_as_expected_when_passed_a_list_type_reference_with_an_user_type_as_contained_type()
{
var userTypeDefinition = GenerateTypeDefinition();
var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", new List <UnrealFieldDetails>(), null);
var containedTypeReference = new UnrealUserTypeReference(unrealTypeDetails);
var unrealListTypeReference = new UnrealListTypeReference(containedTypeReference);
Assert.That(unrealListTypeReference.UnderlyingCapitalisedName == "ImprobableCodegenTestType");
Assert.That(unrealListTypeReference.RequiredIncludes.Count == 2);
Assert.That(unrealListTypeReference.RequiredIncludes.Contains("\"TestType.h\""));
Assert.That(unrealListTypeReference.RequiredIncludes.Contains("\"ImprobableCodegenTestTypeList.h\""));
Assert.That(unrealListTypeReference.UnderlyingQualifiedName == "improbable::codegen::TestType");
Assert.That(unrealListTypeReference.UnrealType == "UImprobableCodegenTestTypeList*");
Assert.That(unrealListTypeReference.AssignUnderlyingValueToUnrealMemberVariable("TestField", "val") == "if (TestField == nullptr) { TestField = NewObject<UImprobableCodegenTestTypeList>(this); } TestField->Init(val)");
Assert.That(unrealListTypeReference.ConvertUnderlyingValueToUnrealLocalVariable("val") == "NewObject<UImprobableCodegenTestTypeList>()->Init(val)");
Assert.That(unrealListTypeReference.ConvertUnderlyingValueToUnrealMemberVariable("val") == "NewObject<UImprobableCodegenTestTypeList>(this)->Init(val)");
Assert.That(unrealListTypeReference.ConvertUnrealValueToUnderlyingValue("val") == "val->GetUnderlying()");
}
public UnrealUserTypeReference(UnrealTypeDetails unrealType)
{
ReferenceType = ReferenceType.UserType;
UnderlyingQualifiedName = unrealType.UnderlyingQualifiedName;
UnderlyingCapitalisedName = Formatting.CppQualifiedNameToCapitalisedCamelCase(UnderlyingQualifiedName);
UnrealType = string.Format("U{0}*", unrealType.CapitalisedName);
CapitalisedName = string.Format("{0}", unrealType.CapitalisedName);
RequiredIncludes = new List <string>();
RequiredIncludes.Add(string.Format("\"{0}.h\"", unrealType.CapitalisedName));
ConvertUnderlyingValueToUnrealMemberVariable = (cppValue) =>
{
// Set owning object as new uobject's outer.
return(string.Format("NewObject<U{0}>(this)->Init({1})", unrealType.CapitalisedName, cppValue));
};
AssignUnderlyingValueToUnrealMemberVariable = (capitalizedName, cppValue) =>
{
return(string.Format(@"if ({0} == nullptr) {{ {0} = NewObject<U{1}>(this); }} {0}->Init({2})",
capitalizedName,
unrealType.CapitalisedName,
cppValue));
};
CheckInequality = (capitalizedName, compName) => { return(string.Format("{0} && ({0}->GetUnderlying() != {1})", capitalizedName, compName)); };
ConvertUnderlyingValueToUnrealLocalVariable = (cppValue) =>
{
// Set static instance package as the uobject's outer.
return(string.Format("NewObject<U{0}>()->Init({1})", unrealType.CapitalisedName, cppValue));
};
ConvertUnrealValueToSnapshotValue = (VarName) => { return(string.Format("{0}->GetUnderlying()", VarName)); };
ConvertUnrealValueToUnderlyingValue = (unrealValue) => { return(string.Format("{0}->GetUnderlying()", unrealValue)); };
ArgumentName = UnrealType;
SnapshotType = unrealType.UnderlyingQualifiedName;
UClassName = string.Format("U{0}", unrealType.CapitalisedName);
TypeDetails = unrealType;
DefaultValue = "nullptr";
}
public UnrealTypeJob(UnrealTypeDetails unrealType, HashSet <string> generatedMaps, HashSet <string> generatedOptions, HashSet <string> generatedLists, string outputDirectory, IFileSystem fileSystem)
: base(outputDirectory, fileSystem)
{
InputFiles = new List <string>()
{
unrealType.UnderlyingPackageDetails.SourceSchema
};
OutputFiles = new List <string>();
var headerGenerator = new UnrealTypeHeaderGenerator(unrealType);
var typeHeaderFileName = unrealType.CapitalisedName + headerSuffix;
OutputFiles.Add(typeHeaderFileName);
Content.Add(typeHeaderFileName, headerGenerator.TransformText());
var implementationGenerator = new UnrealTypeImplementationGenerator(unrealType);
var typeImplFileName = unrealType.CapitalisedName + cppSuffix;
OutputFiles.Add(typeImplFileName);
Content.Add(typeImplFileName, implementationGenerator.TransformText());
foreach (var fieldDefinition in unrealType.FieldDetailsList)
{
if (fieldDefinition.IsMap())
{
var mapTypeReference = fieldDefinition.TypeReference as UnrealMapTypeReference;
var filename = string.Format("{0}To{1}Map", mapTypeReference.KeyType.UnderlyingCapitalisedName, mapTypeReference.ValueType.UnderlyingCapitalisedName);
if (generatedMaps.Contains(filename))
{
continue;
}
generatedMaps.Add(filename);
var mapHeaderGenerator = new UnrealMapHeaderGenerator(mapTypeReference);
var mapHeaderFileName = filename + headerSuffix;
OutputFiles.Add(mapHeaderFileName);
Content.Add(mapHeaderFileName, mapHeaderGenerator.TransformText());
var mapImplementationGenerator = new UnrealMapImplementationGenerator(mapTypeReference);
var mapImplFileName = filename + cppSuffix;
OutputFiles.Add(mapImplFileName);
Content.Add(mapImplFileName, mapImplementationGenerator.TransformText());
}
if (fieldDefinition.IsOption())
{
var optionTypeReference = fieldDefinition.TypeReference as UnrealOptionTypeReference;
var filename = string.Format("{0}Option", fieldDefinition.TypeReference.UnderlyingCapitalisedName);
if (generatedOptions.Contains(filename))
{
continue;
}
generatedOptions.Add(filename);
var optionHeaderGenerator = new UnrealOptionHeaderGenerator(optionTypeReference);
var optionHeaderFileName = filename + headerSuffix;
OutputFiles.Add(optionHeaderFileName);
Content.Add(optionHeaderFileName, optionHeaderGenerator.TransformText());
var optionImplementationGenerator = new UnrealOptionImplementationGenerator(optionTypeReference);
var optionImplFileName = filename + cppSuffix;
OutputFiles.Add(optionImplFileName);
Content.Add(optionImplFileName, optionImplementationGenerator.TransformText());
}
if (fieldDefinition.IsList())
{
var listTypeReference = fieldDefinition.TypeReference as UnrealListTypeReference;
var filename = string.Format("{0}List", fieldDefinition.TypeReference.UnderlyingCapitalisedName);
if (generatedLists.Contains(filename))
{
continue;
}
generatedLists.Add(filename);
var listHeaderGenerator = new UnrealListHeaderGenerator(listTypeReference);
var listHeaderFileName = filename + headerSuffix;
OutputFiles.Add(listHeaderFileName);
Content.Add(listHeaderFileName, listHeaderGenerator.TransformText());
var listImplementationGenerator = new UnrealListImplementationGenerator(listTypeReference);
var listImplFileName = filename + cppSuffix;
OutputFiles.Add(listImplFileName);
Content.Add(listImplFileName, listImplementationGenerator.TransformText());
}
}
}
public UnrealTypeHeaderGenerator(UnrealTypeDetails unrealType)
{
this.unrealType = unrealType;
}
public void run_does_clean_if_files_are_present_in_output_folder_that_should_not_be_there()
{
var mockFileSystem = GenerateMockFileSystem();
mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) =>
{
return(new List <IFile>()
{
new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)),
new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1)),
new MockFileWrapper(Path.Combine(path, "Invalid.cpp"), path, new DateTime(1, 1, 1)),
});
};
mockFileSystem.DeleteDirectoryMock = (path) => { };
mockFileSystem.GetFileInfoMock = (path) =>
{
var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1));
bool fileExists = false;
var fileName = Path.GetFileName(path);
if (fileName == "TestType.h" || fileName == "TestType.cpp" || fileName == "Invalid.cpp")
{
fileExists = true;
}
fileMock.ExistsMock = () => { return(fileExists); };
return(fileMock);
};
var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen");
var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails);
var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem);
var dirtyUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("DirtyTestType", "improbable.codegen.DirtyTestType"), "DirtyTestType", new List <UnrealFieldDetails>(), unrealPackageDetails);
var dirtyTypeJob = new UnrealTypeJob(dirtyUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem);
var jobRunner = new JobRunner(mockFileSystem);
jobRunner.Run(new List <ICodegenJob>()
{
cleanTypeJob, dirtyTypeJob
}, new List <string>()
{
OutputDirectory
});
//Validate that the folder check was correct
Assert.That(mockFileSystem.DeleteDirectoryCallCount == 1);
Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1);
//Validate that the correct jobs were run and expected files were written
Assert.That(mockFileSystem.GetFileInfoCallCount == 4);
Assert.That(mockFileSystem.DirectoryExistsCallCount == 4);
Assert.That(mockFileSystem.WriteToFileCallCount == 4);
Assert.That(mockFileSystem.WrittenFiles.Count == 4);
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.h")));
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.cpp")));
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.h")));
Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.cpp")));
Assert.That(cleanTypeJob.IsDirty());
Assert.That(dirtyTypeJob.IsDirty());
}
public UnrealTypeImplementationGenerator(UnrealTypeDetails unrealType)
{
this.unrealType = unrealType;
}
