Beispiel #1
0
        public void TestGenerateAssemblyFile_WithDirectory_DllIsGeneratedOnSpecifiedDirectory()
        {
            var name      = new AssemblyName(MethodBase.GetCurrentMethod().Name);
            var target    = new SerializerGenerator(typeof(GeneratorTestObject), name);
            var directory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            target.GenerateAssemblyFile(directory);
            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);

            try
            {
                TestOnWorkerAppDomain(
                    Path.Combine(directory, name.Name + ".dll"),
                    PackerCompatibilityOptions.Classic,
                    new byte[] { ( byte )'A' },
                    new byte[] { MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'A' },
                    TestType.GeneratorTestObject
                    );
            }
            finally
            {
                Directory.Delete(directory, true);
            }
        }
Beispiel #2
0
        public void TestGenerateAssemblyFile_WithMethod_OptionsAreAsSpecified()
        {
            var name   = new AssemblyName(MethodBase.GetCurrentMethod().Name);
            var target = new SerializerGenerator(typeof(GeneratorTestObject), name);

            target.Method = SerializationMethod.Map;
            var filePath = Path.GetFullPath("." + Path.DirectorySeparatorChar + name.Name + ".dll");

            target.GenerateAssemblyFile();
            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);

            try
            {
                TestOnWorkerAppDomain(
                    filePath,
                    PackerCompatibilityOptions.Classic,
                    new byte[] { ( byte )'A' },
                    new byte[] { MessagePackCode.MinimumFixedMap + 1, MessagePackCode.MinimumFixedRaw + 3, ( byte )'V', ( byte )'a', ( byte )'l',
                                 MessagePackCode.MinimumFixedRaw + 1, ( byte )'A' },
                    TestType.GeneratorTestObject
                    );
            }
            finally
            {
                File.Delete(filePath);
            }
        }
Beispiel #3
0
        public void TestGenerateAssembly_WithPackerOption_OptionsAreAsSpecified()
        {
            var name     = new AssemblyName(MethodBase.GetCurrentMethod().Name);
            var filePath = Path.GetFullPath("." + Path.DirectorySeparatorChar + name.Name + ".dll");
            var result   =
                SerializerGenerator.GenerateAssembly(
                    new SerializerAssemblyGenerationConfiguration {
                AssemblyName = name
            },
                    typeof(GeneratorTestObject)
                    );

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(result, Is.EqualTo(filePath));

            try
            {
                TestOnWorkerAppDomain(
                    filePath,
                    PackerCompatibilityOptions.None,
                    new byte[] { ( byte )'A' },
                    new byte[] { MessagePackCode.MinimumFixedArray + 1, MessagePackCode.Bin8, 1, ( byte )'A' },
                    TestType.GeneratorTestObject
                    );
            }
            finally
            {
                File.Delete(filePath);
            }
        }
Beispiel #4
0
        public void TestGenerateCode_WithDefault_CSFileGeneratedOnAppBase()
        {
            var filePathCS =
                Path.GetFullPath(
                    String.Join(
                        Path.DirectorySeparatorChar.ToString(),
                        new []
            {
                ".",
                "MsgPack",
                "Serialization",
                "GeneratedSerializers",
                IdentifierUtility.EscapeTypeName(typeof(GeneratorTestObject)) + "Serializer.cs"
            }
                        )
                    );
            var resultCS =
                SerializerGenerator.GenerateCode(
                    typeof(GeneratorTestObject)
                    );

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(resultCS.Single(), Is.EqualTo(filePathCS));
            var linesCS = File.ReadAllLines(filePathCS);

            // BracingStyle, IndentString
            Assert.That(!linesCS.Any(l => Regex.IsMatch(l, @"^\t+if.+\{\s*$")));
            // Nemespace
            Assert.That(linesCS.Any(l => Regex.IsMatch(l, @"^\s*namespace\s+MsgPack\.Serialization\.GeneratedSerializers\s+")));
            // Array
            Assert.That(linesCS.Any(l => Regex.IsMatch(l, @"\.PackArrayHeader")));
        }
        // To test generated serializers, enable this test and run, then copy bin/Debug/MsgPack contents to project's Serialization/GeneratedSerializers/ directory.
        //[Test]
        public void GenerateFiles()
        {
            // Note: if you face to PathTooLongException here, specify OutputDirectory of bellow object initializers.

            SerializerGenerator.GenerateCode(
                new SerializerCodeGenerationConfiguration
            {
                Namespace           = "MsgPack.Serialization.GeneratedSerializers.ArrayBased",
                SerializationMethod = SerializationMethod.Array,
                //OutputDirectory = "\\temp-gen",
                IsInternalToMsgPackLibrary = true                         // because of InternalsVisibleTo
            },
                PreGeneratedSerializerActivator.KnownTypes
                );
            SerializerGenerator.GenerateCode(
                new SerializerCodeGenerationConfiguration
            {
                Namespace           = "MsgPack.Serialization.GeneratedSerializers.MapBased",
                SerializationMethod = SerializationMethod.Map,
                //OutputDirectory = "\\temp-gen",
                IsInternalToMsgPackLibrary = true                         // because of InternalsVisibleTo
            },
                PreGeneratedSerializerActivator.KnownTypes
                );
        }
        public void TestComplexType_ChildGeneratorsAreContainedAutomatically()
        {
            var name      = new AssemblyName(MethodBase.GetCurrentMethod().Name);
            var target    = new SerializerGenerator(typeof(RootGeneratorTestObject), name);
            var directory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            target.GenerateAssemblyFile(directory);
            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(RootGeneratorTestObject)), Is.False);

            try
            {
                TestOnWorkerAppDomain(
                    Path.Combine(directory, "." + Path.DirectorySeparatorChar + name.Name + ".dll"),
                    PackerCompatibilityOptions.Classic,
                    new byte[] { ( byte )'A' },
                    new byte[]
                {
                    MessagePackCode.MinimumFixedArray + 2,
                    MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'A',
                    MessagePackCode.NilValue
                },
                    TestType.RootGeneratorTestObject
                    );
            }
            finally
            {
                Directory.Delete(directory, true);
            }
        }
        // To test generated serializers, enable this test and run, then copy bin/Debug/MsgPack contents to project's Serialization/GeneratedSerializers/ directory.
        //[Test]
        public void GenerateFiles()
        {
            // Note: if you face to PathTooLongException here, specify OutputDirectory of bellow object initializers.

            SerializerGenerator.GenerateCode(
                new SerializerCodeGenerationConfiguration
            {
                Namespace = "MsgPack.Serialization.GeneratedSerializers",
#if NETFX_35
                OutputDirectory = "\\temp-gen35",
#else
                OutputDirectory = "\\temp-gen",
#endif
                IsInternalToMsgPackLibrary = true                         // because of InternalsVisibleTo
            },
                PreGeneratedSerializerActivator.KnownTypes
                );
        }
Beispiel #8
0
 // To test generated serializers, enable this test and run, then copy bin/Debug/MsgPack contents to project's Serialization/GeneratedSerializers/ directory.
 // [Test]
 public void GenerateFiles()
 {
     SerializerGenerator.GenerateCode(
         new SerializerCodeGenerationConfiguration
     {
         Namespace           = "MsgPack.Serialization.GeneratedSerializers.ArrayBased",
         SerializationMethod = SerializationMethod.Array
     },
         PreGeneratedSerializerActivator.KnownTypes
         );
     SerializerGenerator.GenerateCode(
         new SerializerCodeGenerationConfiguration
     {
         Namespace           = "MsgPack.Serialization.GeneratedSerializers.MapBased",
         SerializationMethod = SerializationMethod.Map
     },
         PreGeneratedSerializerActivator.KnownTypes
         );
 }
Beispiel #9
0
        public void TestGenerateCode_ComplexType_MultipleTypes()
        {
            var filePathCS1 =
                Path.GetFullPath(
                    String.Join(
                        Path.DirectorySeparatorChar.ToString(),
                        new []
            {
                ".",
                "MsgPack",
                "Serialization",
                "GeneratedSerializers",
                IdentifierUtility.EscapeTypeName(typeof(GeneratorTestObject)) + "Serializer.cs"
            }
                        )
                    );
            var filePathCS2 =
                Path.GetFullPath(
                    String.Join(
                        Path.DirectorySeparatorChar.ToString(),
                        new []
            {
                ".",
                "MsgPack",
                "Serialization",
                "GeneratedSerializers",
                IdentifierUtility.EscapeTypeName(typeof(AnotherGeneratorTestObject)) + "Serializer.cs"
            }
                        )
                    );
            var resultCS =
                SerializerGenerator.GenerateCode(
                    typeof(GeneratorTestObject),
                    typeof(AnotherGeneratorTestObject)
                    ).ToArray();

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(AnotherGeneratorTestObject)), Is.False);
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(RootGeneratorTestObject)), Is.False);
            Assert.That(resultCS.Length, Is.EqualTo(2));
            Assert.That(resultCS, Contains.Item(filePathCS1).And.Contains(filePathCS2));
        }
Beispiel #10
0
        public void TestGenerateAssembly_ComplexType_MultipleTypes()
        {
            var name      = new AssemblyName(MethodBase.GetCurrentMethod().Name);
            var directory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            var filePath  = Path.Combine(directory, name.Name + ".dll");
            var result    =
                SerializerGenerator.GenerateAssembly(
                    new SerializerAssemblyGenerationConfiguration {
                AssemblyName = name, OutputDirectory = directory
            },
                    typeof(GeneratorTestObject),
                    typeof(AnotherGeneratorTestObject)
                    );

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(AnotherGeneratorTestObject)), Is.False);
            Assert.That(result, Is.EqualTo(filePath));

            try
            {
                TestOnWorkerAppDomainForMultiple(
                    filePath,
                    PackerCompatibilityOptions.Classic,
                    new byte[] { ( byte )'A' },
                    new byte[]
                {
                    MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'A',
                },
                    new byte[] { ( byte )'B' },
                    new byte[]
                {
                    MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'B',
                }
                    );
            }
            finally
            {
                Directory.Delete(directory, true);
            }
        }
Beispiel #11
0
        public void Issue145()
        {
            var results =
                SerializerGenerator.GenerateSerializerSourceCodes(
                    new SerializerCodeGenerationConfiguration
            {
                EnumSerializationMethod         = EnumSerializationMethod.ByUnderlyingValue,
                IsRecursive                     = true,
                OutputDirectory                 = Path.GetTempPath(),
                WithNullableSerializers         = false,
                PreferReflectionBasedSerializer = true,
                SerializationMethod             = SerializationMethod.Array
            },
                    typeof(Issue145Class)
                    ).ToArray();

            foreach (var result in results)
            {
                File.Delete(result.FilePath);
            }
        }
 // To test generated serializers, enable this test and run, then copy bin/Debug/MsgPack contents to project's Serialization/GeneratedSerializers/ directory.
 // [Test]
 public void GenerateFiles()
 {
     SerializerGenerator.GenerateCode(
         new SerializerCodeGenerationConfiguration
     {
         Namespace                  = "MsgPack.Serialization.GeneratedSerializers.ArrayBased",
         SerializationMethod        = SerializationMethod.Array,
         IsInternalToMsgPackLibrary = true                         // because of InternalsVisibleTo
     },
         PreGeneratedSerializerActivator.KnownTypes
         );
     SerializerGenerator.GenerateCode(
         new SerializerCodeGenerationConfiguration
     {
         Namespace                  = "MsgPack.Serialization.GeneratedSerializers.MapBased",
         SerializationMethod        = SerializationMethod.Map,
         IsInternalToMsgPackLibrary = true                         // because of InternalsVisibleTo
     },
         PreGeneratedSerializerActivator.KnownTypes
         );
 }
		public void TestGenerateAssemblyFile_WithDirectory_DllIsGeneratedOnSpecifiedDirectory()
		{
			var name = new AssemblyName( MethodBase.GetCurrentMethod().Name );
			var target = new SerializerGenerator( typeof( GeneratorTestObject ), name );
			var directory = Path.Combine( Path.GetTempPath(), Guid.NewGuid().ToString() );
			target.GenerateAssemblyFile( directory );
			// Assert is not polluted.
			Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestObject ) ), Is.False );

			try
			{
				TestOnWorkerAppDomain(
					Path.Combine( directory, name.Name + ".dll" ),
					PackerCompatibilityOptions.Classic,
					new byte[] { ( byte )'A' },
					new byte[] { MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'A' },
					TestType.GeneratorTestObject
				);
			}
			finally
			{
				Directory.Delete( directory, true );
			}
		}
		public void TestGenerateAssemblyFile_WithDefault_DllIsGeneratedOnAppBase()
		{
			var name = new AssemblyName( MethodBase.GetCurrentMethod().Name );
			var target = new SerializerGenerator( typeof( GeneratorTestObject ), name );
			var filePath = Path.GetFullPath( "." + Path.DirectorySeparatorChar + name.Name + ".dll" );
			target.GenerateAssemblyFile();
			// Assert is not polluted.
			Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestObject ) ), Is.False );

			try
			{
				TestOnWorkerAppDomain(
					filePath,
					PackerCompatibilityOptions.Classic,
					new byte[] { ( byte )'A' },
					new byte[] { MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte )'A' },
					TestType.GeneratorTestObject
				);
			}
			finally
			{
				File.Delete( filePath );
			}
		}
		public void TestGenerateAssemblyFile_ComplexType_MultipleTypes()
		{
			var name = new AssemblyName( MethodBase.GetCurrentMethod().Name );
			var target = new SerializerGenerator( name );
			target.TargetTypes.Add( typeof( GeneratorTestObject ) );
			target.TargetTypes.Add( typeof( AnotherGeneratorTestObject ) );
			var directory = Path.Combine( Path.GetTempPath(), Guid.NewGuid().ToString() );
			target.GenerateAssemblyFile( directory );
			// Assert is not polluted.
			Assert.That( SerializationContext.Default.ContainsSerializer( typeof( GeneratorTestObject ) ), Is.False );
			Assert.That( SerializationContext.Default.ContainsSerializer( typeof( AnotherGeneratorTestObject ) ), Is.False );

			try
			{
				TestOnWorkerAppDomainForMultiple(
					Path.Combine( directory, "." + Path.DirectorySeparatorChar + name.Name + ".dll" ),
					PackerCompatibilityOptions.Classic,
					new byte[] { ( byte )'A' },
					new byte[]
					{
						MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte ) 'A',
					},
					new byte[] { ( byte )'B' },
					new byte[]
					{
						MessagePackCode.MinimumFixedArray + 1, MessagePackCode.MinimumFixedRaw + 1, ( byte ) 'B',
					}
				);
			}
			finally
			{
				Directory.Delete( directory, true );
			}
		}
Beispiel #16
0
        public void TestGeneratCode_WithOptions_OptionsAreValid()
        {
            var directory  = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            var filePathCS =
                String.Join(
                    Path.DirectorySeparatorChar.ToString(),
                    new []
            {
                directory,
                "Test",
                IdentifierUtility.EscapeTypeName(typeof(GeneratorTestObject)) + "Serializer.cs"
            }
                    );
            var resultCS =
                SerializerGenerator.GenerateCode(
                    new SerializerCodeGenerationConfiguration
            {
                CodeIndentString    = "\t",
                Namespace           = "Test",
                SerializationMethod = SerializationMethod.Map,
                OutputDirectory     = directory,
            },
                    typeof(GeneratorTestObject)
                    );

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(resultCS.Single(), Is.EqualTo(filePathCS));
            Console.WriteLine(File.ReadAllText(filePathCS));
            var linesCS = File.ReadAllLines(filePathCS);

            // BracingStyle, IndentString
            Assert.That(linesCS.Any(l => Regex.IsMatch(l, @"^\t+[^\{\s]+.+\{\s*$")));
            // Nemespace
            Assert.That(linesCS.Any(l => Regex.IsMatch(l, @"^\s*namespace\s+Test\s+")));
            // Map
            Assert.That(linesCS.Any(l => Regex.IsMatch(l, @"\.PackMapHeader")));

            // Language
            var filePathVB =
                String.Join(
                    Path.DirectorySeparatorChar.ToString(),
                    new []
            {
                directory,
                "MsgPack",
                "Serialization",
                "GeneratedSerializers",
                IdentifierUtility.EscapeTypeName(typeof(GeneratorTestObject)) + "Serializer.vb"
            }
                    );
            var resultVB =
                SerializerGenerator.GenerateCode(
                    new SerializerCodeGenerationConfiguration
            {
                Language        = "VB",
                OutputDirectory = directory,
            },
                    typeof(GeneratorTestObject)
                    );

            // Assert is not polluted.
            Assert.That(SerializationContext.Default.ContainsSerializer(typeof(GeneratorTestObject)), Is.False);
            Assert.That(resultVB.Single(), Is.EqualTo(filePathVB));
            var linesVB = File.ReadAllLines(filePathVB);

            // CheckVB
            Assert.That(linesVB.Any(l => Regex.IsMatch(l, @"^\s*End Sub\s*$")));
        }