/// <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 ); } } }