/// <summary>
/// Generates source codes which implement auto-generated serializer types for specified types with specified configuration.
/// </summary>
/// <param name="configuration">The <see cref="SerializerCodeGenerationConfiguration"/> which holds optional settings. Specifying <c>null</c> means using default settings.</param>
/// <param name="targetTypes">The target types where serializer types to be generated.</param>
/// <returns>A <see cref="SerializerCodeGenerationResult"/> collection which correspond to codes generated to <paramref name="targetTypes"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="targetTypes"/> is <c>null</c>.</exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">Failed to generate a serializer because of <paramref name="targetTypes"/>.</exception>
/// <remarks>
/// Serializer types for dependent types which are refered from specified <paramref name="targetTypes"/> are NOT generated.
/// This method just generate serializer types for specified types.
/// </remarks>
public static IEnumerable <SerializerCodeGenerationResult> GenerateSerializerSourceCodes(SerializerCodeGenerationConfiguration configuration, IEnumerable <Type> targetTypes)
{
return(new SerializerCodesGenerationLogic().Generate(targetTypes, configuration ?? new SerializerCodeGenerationConfiguration()));
}
/// <summary>
/// Generates source codes which implement auto-generated serializer types for specified types with specified configuration.
/// </summary>
/// <param name="configuration">The <see cref="SerializerCodeGenerationConfiguration"/> which holds optional settings. Specifying <c>null</c> means using default settings.</param>
/// <param name="targetTypes">The target types where serializer types to be generated.</param>
/// <returns>A file path collection which correspond to codes generated to <paramref name="targetTypes"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="targetTypes"/> is <c>null</c>.</exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">Failed to generate a serializer because of <paramref name="targetTypes"/>.</exception>
/// <remarks>
/// Serializer types for dependent types which are refered from specified <paramref name="targetTypes"/> are NOT generated.
/// This method just generate serializer types for specified types.
/// </remarks>
public static IEnumerable <string> GenerateCode(SerializerCodeGenerationConfiguration configuration, IEnumerable <Type> targetTypes)
{
return(GenerateSerializerSourceCodes(configuration, targetTypes).Select(r => r.FilePath));
}
/// <summary>
/// Generates source codes which implement auto-generated serializer types for specified types with specified configuration.
/// </summary>
/// <param name="configuration">The <see cref="SerializerCodeGenerationConfiguration"/> which holds optional settings. Specifying <c>null</c> means using default settings.</param>
/// <param name="targetTypes">The target types where serializer types to be generated.</param>
/// <returns>A <see cref="SerializerCodeGenerationResult"/> collection which correspond to codes generated to <paramref name="targetTypes"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="targetTypes"/> is <c>null</c>.</exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">Failed to generate a serializer because of <paramref name="targetTypes"/>.</exception>
/// <remarks>
/// Serializer types for dependent types which are refered from specified <paramref name="targetTypes"/> are NOT generated.
/// This method just generate serializer types for specified types.
/// </remarks>
public static IEnumerable <SerializerCodeGenerationResult> GenerateSerializerSourceCodes(SerializerCodeGenerationConfiguration configuration, params Type[] targetTypes)
{
return(GenerateSerializerSourceCodes(configuration, targetTypes as IEnumerable <Type>));
}
/// <summary>
/// Generates source codes which implement auto-generated serializer types for specified types with specified configuration.
/// </summary>
/// <param name="configuration">The <see cref="SerializerCodeGenerationConfiguration"/> which holds optional settings. Specifying <c>null</c> means using default settings.</param>
/// <param name="targetTypes">The target types where serializer types to be generated.</param>
/// <returns>The file path for generated single module assembly file.</returns>
/// <exception cref="ArgumentNullException"><paramref name="targetTypes"/> is <c>null</c>.</exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">Failed to generate a serializer because of <paramref name="targetTypes"/>.</exception>
/// <remarks>
/// Serializer types for dependent types which are refered from specified <paramref name="targetTypes"/> are NOT generated.
/// This method just generate serializer types for specified types.
/// </remarks>
public static IEnumerable <string> GenerateCode(SerializerCodeGenerationConfiguration configuration, params Type[] targetTypes)
{
return(GenerateCode(configuration, targetTypes as IEnumerable <Type>));
}
/// <summary>
/// Generates source codes which implement auto-generated serializer types for specified types with specified configuration.
/// </summary>
/// <param name="configuration">The <see cref="SerializerCodeGenerationConfiguration"/> which holds optional settings. Specifying <c>null</c> means using default settings.</param>
/// <param name="targetTypes">The target types where serializer types to be generated.</param>
/// <returns>The file path for generated single module assembly file.</returns>
/// <exception cref="ArgumentNullException"><paramref name="targetTypes"/> is <c>null</c>.</exception>
/// <exception cref="System.Runtime.Serialization.SerializationException">Failed to generate a serializer because of <paramref name="targetTypes"/>.</exception>
/// <remarks>
/// Serializer types for dependent types which are refered from specified <paramref name="targetTypes"/> are NOT generated.
/// This method just generate serializer types for specified types.
/// </remarks>
public static IEnumerable <string> GenerateCode(SerializerCodeGenerationConfiguration configuration, IEnumerable <Type> targetTypes)
{
return(new SerializerCodesGenerationLogic().Generate(targetTypes, configuration ?? new SerializerCodeGenerationConfiguration()));
}
private static void GenerateSerializers(
IList<string> sourceFilePathes,
string[] referenceAssemblies,
bool sourceFileIsAssembly,
string includingPattern,
string excludingPattern,
bool treatWarningsAsErrors,
int warningLevel,
SerializerCodeGenerationConfiguration configuration
)
{
if ( sourceFilePathes == null || sourceFilePathes.Count == 0 )
{
throw new ArgumentException( "Source files or a source assembly is required." );
}
var generator = new SerializerCodeGenerator( configuration );
IEnumerable<string> result;
if ( !sourceFileIsAssembly )
{
result =
generator.GenerateSerializers(
new SerializerTargetCompiler
{
TreatWarningsAsErrors = treatWarningsAsErrors,
WarningLevel = warningLevel
}.CompileTargetTypeAssembly(
sourceFilePathes,
referenceAssemblies ?? new string[ 0 ]
),
includingPattern,
excludingPattern
);
}
else
{
result =
generator.GenerateSerializers(
sourceFilePathes[ 0 ],
includingPattern,
excludingPattern
);
}
foreach ( var outputFilePath in result )
{
Console.WriteLine( outputFilePath );
}
}
private static int Execute( IEnumerable<string> args )
{
Action? action = null;
var sourceProjectPath = default( string );
var outputDirectoryPath = default( string );
var overwrite = false;
var sourceFileIsAssembly = false;
var referenceAssemblies = new List<string>();
var includingPattern = default( string );
var excludingPattern = default( string );
var treatWarningsAsErrors = false;
var warningLevel = 4;
var configuration = new SerializerCodeGenerationConfiguration();
var options =
new OptionSet( Localize )
{
{
"?|h|help", "Show this help message.",
_ => action = Action.ShowHelp
},
{
"l|library", "[required] Copy MsgPack source as assets library tree.",
_ => action = action != null ? Action.ShowHelp : Action.BuildAssetLibrary
},
{
"s|serializer", "[required] Generate serializer sources as assets tree.",
_ => action = action != null ? Action.ShowHelp : Action.GenerateSerializers
},
{
"p|project=", "[library, optional] Specify MsgPack.Unity3D.csproj path. Default is './src/MsgPack.Unity3D/MsgPack.Unity3D.csproj'.",
value => sourceProjectPath = value
},
{
"o|out=", "[all, optional] Specify the root directory of the output file tree. Default is './Assets/MsgPack' for 'library', './Assets/MsgPackSerializers/' for 'serializer'.",
value => outputDirectoryPath = value
},
{
"w|overwrite", "[library, optional] Overwrite existent source file (you have to clean output directory in advance by default.)",
_ => overwrite = true
},
{
"a|assembly", "[serializer, optional] Specify source file is assembly file which contains all serialization target types instead of C# source code files.",
_ => sourceFileIsAssembly = true
},
{
"n|namespace=", "[serializer, optional] Specify namespace for generated serializer types.",
value => configuration.Namespace = value
},
{
"internal", "[serializer, optional] Specify generated source code will be internal to MsgPack library itself. This option is required if you import MsgPack sources instead of an assembly to your Assets.",
_ => configuration.IsInternalToMsgPackLibrary = true
},
{
"method=", "[serializer, optional] Specify serialization method for generated serializers. Valid value is Array or Map. Default is 'Array'.",
(SerializationMethod value) => configuration.SerializationMethod = value
},
{
"indent=", "[serializer, optional] Specify indent string for generated serializers. Default is a horizontal tab charactor (U+0009).",
value => configuration.CodeIndentString = value
},
{
"r|references=", "[serializer, optional] Specify reference assemblies' file pathes (delimited by comma) to compile serialization target type source codes. './MsgPack.dll' will be added automatically when it exists.",
value => referenceAssemblies.AddRange( value.Split( new []{','}, StringSplitOptions.RemoveEmptyEntries).Select( token => token.Trim() ))
},
{
"includes=", "[serializer, optional] Specify additional regular expression to filter in serialization target types. This filter is used for type full name including its namespace.",
value => includingPattern = value
},
{
"excludes=", "[serializer, optional] Specify additional regular expression to filter in serialization target types. This filter is used for type full name including its namespace.",
value => excludingPattern = value
},
{
"treatWarningsAsErrors", "[serializer, optional] Specify to generate error for compiler warnings for serialization target types.",
_ => treatWarningsAsErrors = true
},
{
"warningLevel=", "[serializer, optional] Specify compiler warning level for serialization target types. Default is '4'.",
(int value) => warningLevel = value
}
};
var sourceFilePathes = options.Parse( args );
switch ( action.GetValueOrDefault() )
{
case Action.BuildAssetLibrary:
{
BuildAssetLibrary( sourceProjectPath, outputDirectoryPath, overwrite );
return 0;
}
case Action.GenerateSerializers:
{
configuration.OutputDirectory = outputDirectoryPath;
if ( File.Exists( "./MsgPack.dll" ) )
{
referenceAssemblies.Add( "./MsgPack.dll" );
}
GenerateSerializers(
sourceFilePathes,
referenceAssemblies.Distinct( PathEqualityComparer.Instance ).ToArray(),
sourceFileIsAssembly,
includingPattern,
excludingPattern,
treatWarningsAsErrors,
warningLevel,
configuration
);
return 0;
}
default:
{
ShowHelp( options );
return 1;
}
}
}
private static int Execute( IEnumerable<string> args )
{
Action? action = null;
var sourceProjectPath = default( string );
var outputDirectoryPath = default( string );
var overwrite = false;
var sourceFileIsAssembly = false;
var referenceAssemblies = new List<string>();
var includingPattern = default( string );
var excludingPattern = default( string );
var treatWarningsAsErrors = false;
var warningLevel = 4;
var configuration =
new SerializerCodeGenerationConfiguration
{
PreferReflectionBasedSerializer = true,
IsRecursive = true
};
var options =
new OptionSet( Localize )
{
{
"?|h|help", "Show this help message.",
_ => action = Action.ShowHelp
},
{
"l|library", "[required] Copy MsgPack source as assets library tree.",
_ => action = action != null ? Action.ShowHelp : Action.BuildAssetLibrary
},
{
"s|serializer", "[required] Generate serializer sources as assets tree.",
_ => action = action != null ? Action.ShowHelp : Action.GenerateSerializers
},
{
"p|project=", "[library, optional] Specify MsgPack.Unity3D.csproj path. Default is './src/MsgPack.Unity3D/MsgPack.Unity3D.csproj'.",
value => sourceProjectPath = value
},
{
"o|out=", "[all, optional] Specify the root directory of the output file tree. Default is './Assets/MsgPack' for 'library', './Assets/MsgPackSerializers/' for 'serializer'.",
value => outputDirectoryPath = value
},
{
"w|overwrite", "[library, optional] Overwrite existent source file (you have to clean output directory in advance by default.)",
_ => overwrite = true
},
{
"a|assembly", "[serializer, optional] Specify source file is assembly file which contains all serialization target types instead of C# source code files.",
_ => sourceFileIsAssembly = true
},
{
"n|namespace=", "[serializer, optional] Specify namespace for generated serializer types.",
value => configuration.Namespace = value
},
{
"internal", "[serializer, optional] Specify generated source code will be internal to MsgPack library itself. This option is required if you import MsgPack sources instead of an assembly to your Assets.",
_ => configuration.IsInternalToMsgPackLibrary = true
},
{
"method=", "[serializer, optional] Specify serialization method for generated serializers. Valid value is Array or Map. Default is 'Array'.",
(SerializationMethod value) => configuration.SerializationMethod = value
},
{
"enum-method=", "[serializer, optional] Specify enum serialization method for generated enum serializers. Valid value is ByName or ByUnderlyingType. Default is 'ByName'.",
(EnumSerializationMethod value) => configuration.EnumSerializationMethod = value
},
{
"singular", "[serializer, optional] Specify avoid recursive serializer generation for target type(s).",
_ => configuration.PreferReflectionBasedSerializer = false
},
{
"avoid-reflection-based", "[serializer, optional] Specify avoid built-in reflection based serializer and generates alternative serializers.",
_ => configuration.PreferReflectionBasedSerializer = false
},
{
"prohibit-non-collection-enumerable-types", "[serializer, optional] Specify prevent serializer generation for types which implemnent IEnumerable but do not have add for backward compatibility.",
_ => configuration.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false
},
{
"ignore-packability-for-collection", "[serializer, optional] Specify generate normal collection serializer logic for types which implemnent IEnumerable and IPackable/IUnpackble/IAsyncPackable/IAsyncUnpackable for backward compatiblity.",
_ => configuration.CompatibilityOptions.IgnorePackabilityForCollection = false
},
{
"one-bound-data-member-order", "[serializer, optional] Specify generating serializers use 1-based DataMemberAttribute.order instead of 0-based for compatibility of some other serialization libraries.",
_ => configuration.CompatibilityOptions.OneBoundDataMemberOrder = false
},
{
"classic-packer", "[serializer, optional] Specify that packer does not emit new bin, str8, and ext types.",
_ => configuration.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.Classic
},
{
"with-async", "[serializer, optional] Specify generating async methods on serializers. This option causes compilation error for legacy environments including Unity.",
_ => configuration.WithAsync = true
},
{
"indent=", "[serializer, optional] Specify indent string for generated serializers. Default is a horizontal tab charactor (U+0009).",
value => configuration.CodeIndentString = value
},
{
"r|references=", "[serializer, optional] Specify reference assemblies' file pathes (delimited by comma) to compile serialization target type source codes. './MsgPack.dll' will be added automatically when it exists.",
value => referenceAssemblies.AddRange( value.Split( new []{','}, StringSplitOptions.RemoveEmptyEntries).Select( token => token.Trim() ))
},
{
"includes=", "[serializer, optional] Specify additional regular expression to filter in serialization target types. This filter is used for type full name including its namespace.",
value => includingPattern = value
},
{
"excludes=", "[serializer, optional] Specify additional regular expression to filter in serialization target types. This filter is used for type full name including its namespace.",
value => excludingPattern = value
},
{
"treat-warning-as-errors|treatWarningsAsErrors", "[serializer, optional] Specify to generate error for compiler warnings for serialization target types.",
_ => treatWarningsAsErrors = true
},
{
"warning-level|warningLevel=", "[serializer, optional] Specify compiler warning level for serialization target types. Default is '4'.",
( int value ) => warningLevel = value
},
{
"suppress-debugger-non-user-code-attr", "[serializer, optional] Specify supressing DebuggerNonUserCodeAttribute in the output code to enable debugger stepping.",
_ => configuration.SuppressDebuggerNonUserCodeAttribute = true
}
};
var sourceFilePathes = options.Parse( args );
switch ( action.GetValueOrDefault() )
{
case Action.BuildAssetLibrary:
{
BuildAssetLibrary( sourceProjectPath, outputDirectoryPath, overwrite );
return 0;
}
case Action.GenerateSerializers:
{
configuration.OutputDirectory = outputDirectoryPath;
if ( File.Exists( "./MsgPack.dll" ) )
{
referenceAssemblies.Add( "./MsgPack.dll" );
}
GenerateSerializers(
sourceFilePathes,
referenceAssemblies.Distinct( PathEqualityComparer.Instance ).ToArray(),
sourceFileIsAssembly,
includingPattern,
excludingPattern,
treatWarningsAsErrors,
warningLevel,
configuration
);
return 0;
}
default:
{
ShowHelp( options );
return 1;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializerCodeGenerator"/> class.
/// </summary>
/// <param name="configuration">The configuration object.</param>
public SerializerCodeGenerator( SerializerCodeGenerationConfiguration configuration )
{
this._configuration = configuration ?? new SerializerCodeGenerationConfiguration();
}
public void TestGenerateSerializerSourceCodes_ElementTypes_Generated()
{
var configuration = new SerializerCodeGenerationConfiguration { IsRecursive = true, PreferReflectionBasedSerializer = false };
var resultCS =
SerializerGenerator.GenerateSerializerSourceCodes(
configuration,
typeof( List<GeneratorTestObject> ),
typeof( AnotherGeneratorTestObject[] )
).ToArray();
try
{
// Assert is not polluted.
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( AnotherGeneratorTestObject ) ), Is.False );
Assert.That( resultCS.Length, Is.EqualTo( 2 ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( GeneratorTestObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( AnotherGeneratorTestObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
}
finally
{
foreach ( var result in resultCS )
{
File.Delete( result.FilePath );
}
}
}
public void TestGenerateSerializerSourceCodes_WithBuiltInSupportedTypes_Ignored()
{
var configuration = new SerializerCodeGenerationConfiguration { IsRecursive = true, PreferReflectionBasedSerializer = false };
var resultCS =
SerializerGenerator.GenerateSerializerSourceCodes(
configuration,
typeof( int ),
typeof( string ),
typeof( DateTime ),
typeof( List<int> ),
typeof( int[] )
).ToArray();
try
{
Assert.That( resultCS.Length, Is.EqualTo( 0 ) );
}
finally
{
foreach ( var result in resultCS )
{
File.Delete( result.FilePath );
}
}
}
private static void TestGenerateSerializerSourceCodesCore( string @namespace )
{
var configuration = new SerializerCodeGenerationConfiguration { IsRecursive = false, Namespace = @namespace };
var resultCS =
SerializerGenerator.GenerateSerializerSourceCodes(
configuration,
typeof( GeneratorTestObject ),
typeof( AnotherGeneratorTestObject )
).ToArray();
try
{
// Assert is not polluted.
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( AnotherGeneratorTestObject ) ), Is.False );
Assert.That( resultCS.Length, Is.EqualTo( 2 ) );
var one = resultCS.SingleOrDefault( r => r.TargetType == typeof( GeneratorTestObject ) );
Assert.That( one, Is.Not.Null, String.Join( ", ", resultCS.Select( r => r.TargetType.FullName ).ToArray() ) );
Assert.That(
one.FilePath,
Is.EqualTo(
Path.GetFullPath(
String.Join(
Path.DirectorySeparatorChar.ToString(),
new[] { "." }
.Concat( configuration.Namespace.Split( Type.Delimiter ) )
.Concat(
new[] { "MsgPack_Serialization_GeneratorTestObjectSerializer.cs" }
).ToArray()
)
)
)
);
Assert.That(
one.SerializerTypeName,
Is.EqualTo( "MsgPack_Serialization_GeneratorTestObjectSerializer" )
);
Assert.That(
one.SerializerTypeNamespace,
Is.EqualTo( configuration.Namespace )
);
Assert.That(
one.SerializerTypeFullName,
Is.EqualTo(
( configuration.Namespace.Length > 0 ? configuration.Namespace + "." : String.Empty ) +
"MsgPack_Serialization_GeneratorTestObjectSerializer"
)
);
var another = resultCS.SingleOrDefault( r => r.TargetType == typeof( AnotherGeneratorTestObject ) );
Assert.That( another, Is.Not.Null, String.Join( ", ", resultCS.Select( r => r.TargetType.FullName ).ToArray() ) );
Assert.That(
another.FilePath,
Is.EqualTo(
Path.GetFullPath(
String.Join(
Path.DirectorySeparatorChar.ToString(),
new[] { "." }
.Concat( configuration.Namespace.Split( Type.Delimiter ) )
.Concat(
new[] { "MsgPack_Serialization_AnotherGeneratorTestObjectSerializer.cs" }
).ToArray()
)
)
)
);
Assert.That(
another.SerializerTypeName,
Is.EqualTo( "MsgPack_Serialization_AnotherGeneratorTestObjectSerializer" )
);
Assert.That(
another.SerializerTypeNamespace,
Is.EqualTo( configuration.Namespace )
);
Assert.That(
another.SerializerTypeFullName,
Is.EqualTo(
( configuration.Namespace.Length > 0 ? configuration.Namespace + "." : String.Empty ) +
"MsgPack_Serialization_AnotherGeneratorTestObjectSerializer"
)
);
}
finally
{
foreach ( var result in resultCS )
{
File.Delete( result.FilePath );
}
}
}
public void TestGenerateSerializerSourceCodes_MemberIsPrimitive_WithNullable_GeneratedWithNullable()
{
var configuration = new SerializerCodeGenerationConfiguration { IsRecursive = true, PreferReflectionBasedSerializer = false, WithNullableSerializers = true };
var resultCS =
SerializerGenerator.GenerateSerializerSourceCodes(
configuration,
typeof( WithPrimitive )
).ToArray();
try
{
// Assert is not polluted.
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( WithPrimitive ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( int? ) ), Is.False );
Assert.That( resultCS.Length, Is.EqualTo( 2 ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( WithPrimitive ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( int? ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
AssertValidCode( resultCS );
}
finally
{
foreach ( var result in resultCS )
{
File.Delete( result.FilePath );
}
}
}
public void TestGenerateSerializerSourceCodes_MemberTypesOfElementTypesNested_ValueType_WithoutNullable_GeneratedWithoutNullable()
{
var configuration = new SerializerCodeGenerationConfiguration { IsRecursive = true, PreferReflectionBasedSerializer = false };
Assert.That( configuration.WithNullableSerializers, Is.False );
var resultCS =
SerializerGenerator.GenerateSerializerSourceCodes(
configuration,
typeof( HoldsRootElementTypeValueObject )
).ToArray();
try
{
// Assert is not polluted.
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( HoldsRootElementTypeValueObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( RootGeneratorTestValueObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( AnotherRootGeneratorTestValueObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestValueObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestValueObject? ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( AnotherGeneratorTestValueObject ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( TestType ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( TestEnumType ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( TestType? ) ), Is.False );
Assert.That( SerializationContext.Default.ContainsSerializer( typeof( TestEnumType? ) ), Is.False );
Assert.That( resultCS.Length, Is.EqualTo( 7 ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( HoldsRootElementTypeValueObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( RootGeneratorTestValueObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( AnotherRootGeneratorTestValueObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( GeneratorTestValueObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( AnotherGeneratorTestValueObject ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( TestType ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.Any( r => r.TargetType == typeof( TestEnumType ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.All( r => r.TargetType != typeof( TestType? ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
Assert.That( resultCS.All( r => r.TargetType != typeof( TestEnumType? ) ), String.Join( ", ", resultCS.Select( r => r.TargetType.GetFullName() ).ToArray() ) );
AssertValidCode( resultCS );
}
finally
{
foreach ( var result in resultCS )
{
File.Delete( result.FilePath );
}
}
}
