diff --git a/MsgPack.Windows.sln b/MsgPack.Windows.sln index 69cd979e9..84077c7dd 100644 --- a/MsgPack.Windows.sln +++ b/MsgPack.Windows.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 14 -VisualStudioVersion = 14.0.25123.0 +VisualStudioVersion = 14.0.25420.1 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "common", "common", "{60EC42E9-D79B-4ADF-8F80-4DCD580061FD}" ProjectSection(SolutionItems) = preProject @@ -56,6 +56,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.UnitTest.Uwp", "tes EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.UnitTest.Uwp.Aot", "test\MsgPack.UnitTest.Uwp.Aot\MsgPack.UnitTest.Uwp.Aot.csproj", "{E4CA9866-6234-49D4-8CDF-1F3A21EFD138}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.Core", "src\MsgPack.Core\MsgPack.Core.csproj", "{08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.Serialization", "src\MsgPack.Serialization\MsgPack.Serialization.csproj", "{153CED68-9905-4B1F-9790-F463840895E2}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution CodeAnalysis|Any CPU = CodeAnalysis|Any CPU @@ -377,7 +381,8 @@ Global {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|Any CPU.Build.0 = Release|Any CPU {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|ARM.ActiveCfg = Release|ARM {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|ARM.Build.0 = Release|ARM - {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|Mixed Platforms.ActiveCfg = Release|x86 + {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|Mixed Platforms.Build.0 = Release|Any CPU {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|x64.ActiveCfg = Release|x64 {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|x64.Build.0 = Release|x64 {9D65A105-FB03-40DB-9185-8C695B8EE8D6}.Release|x86.ActiveCfg = Release|x86 @@ -524,6 +529,86 @@ Global {E4CA9866-6234-49D4-8CDF-1F3A21EFD138}.Release|x86.ActiveCfg = Release|x86 {E4CA9866-6234-49D4-8CDF-1F3A21EFD138}.Release|x86.Build.0 = Release|x86 {E4CA9866-6234-49D4-8CDF-1F3A21EFD138}.Release|x86.Deploy.0 = Release|x86 + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|ARM.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|ARM.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x64.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x64.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x86.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x86.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x86.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|ARM.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|ARM.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x64.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x64.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x86.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x86.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -548,5 +633,7 @@ Global {A1B322FC-AA39-4894-AFA8-AB427A3FBA09} = {BFCE0B36-F21B-4EB1-919E-C486E70C8BEA} {0F930636-458B-401F-9EAF-F4F05E93BCC9} = {7D06945C-638C-4973-B0B6-D0D667FA318F} {E4CA9866-6234-49D4-8CDF-1F3A21EFD138} = {09C98E72-44F7-4469-B82A-DFA3053652E6} + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F} = {BFCE0B36-F21B-4EB1-919E-C486E70C8BEA} + {153CED68-9905-4B1F-9790-F463840895E2} = {BFCE0B36-F21B-4EB1-919E-C486E70C8BEA} EndGlobalSection EndGlobal diff --git a/MsgPack.nuspec b/MsgPack.nuspec index 714be6825..052c95491 100644 --- a/MsgPack.nuspec +++ b/MsgPack.nuspec @@ -19,6 +19,7 @@ This package provides MessagePack serialization/deserialization APIs. This pacak + diff --git a/MsgPack.sln b/MsgPack.sln index 2f81409d1..3458f3bb4 100644 --- a/MsgPack.sln +++ b/MsgPack.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 14 -VisualStudioVersion = 14.0.25123.0 +VisualStudioVersion = 14.0.25420.1 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "common", "common", "{60EC42E9-D79B-4ADF-8F80-4DCD580061FD}" ProjectSection(SolutionItems) = preProject @@ -42,6 +42,22 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".NET45", ".NET45", "{3E9C77 EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.Net45", "src\MsgPack.Net45\MsgPack.Net45.csproj", "{9C7B55A6-AF7F-4D26-AB5B-297B7FF25B6D}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".NETStandard", ".NETStandard", "{7ED37CCB-869D-4FAC-80F5-3A13B2386B1D}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.CodeGeneration.Core", "src\MsgPack.CodeGeneration.Core\MsgPack.CodeGeneration.Core.csproj", "{EFE532EA-77C8-4877-96C2-E79FD101B2AB}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.Core", "src\MsgPack.Core\MsgPack.Core.csproj", "{08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.Serialization", "src\MsgPack.Serialization\MsgPack.Serialization.csproj", "{153CED68-9905-4B1F-9790-F463840895E2}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.CodeGeneration.CSharp", "src\MsgPack.CodeGeneration.CSharp\MsgPack.CodeGeneration.CSharp.csproj", "{B10240C1-BB07-47A3-B056-CE52B5194D86}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.CodeGeneration.VisualBasic", "src\MsgPack.CodeGeneration.VisualBasic\MsgPack.CodeGeneration.VisualBasic.csproj", "{A88D64DB-DE14-4B77-80D8-B765F45EBB8B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MsgPack.UnitTest.CodeTree", "test\MsgPack.UnitTest.CodeTree\MsgPack.UnitTest.CodeTree.csproj", "{D5A4E386-E418-4407-916E-A65092B78693}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CoreCLR", "CoreCLR", "{F7CD1D27-1441-4C2F-AB17-6FF8803460EC}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution CodeAnalysis|Any CPU = CodeAnalysis|Any CPU @@ -234,6 +250,245 @@ Global {9C7B55A6-AF7F-4D26-AB5B-297B7FF25B6D}.Release|Mixed Platforms.Build.0 = Release|Any CPU {9C7B55A6-AF7F-4D26-AB5B-297B7FF25B6D}.Release|x64.ActiveCfg = Release|Any CPU {9C7B55A6-AF7F-4D26-AB5B-297B7FF25B6D}.Release|x86.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|ARM.ActiveCfg = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|ARM.Build.0 = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|x64.ActiveCfg = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|x64.Build.0 = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|x86.ActiveCfg = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Debug|x86.Build.0 = Debug|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|x64.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.PerformanceTest|x86.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|Any CPU.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|ARM.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|ARM.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|x64.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|x64.Build.0 = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|x86.ActiveCfg = Release|Any CPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB}.Release|x86.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|ARM.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|ARM.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x64.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x64.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x86.ActiveCfg = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Debug|x86.Build.0 = Debug|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.PerformanceTest|x86.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Any CPU.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|ARM.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|ARM.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x64.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x64.Build.0 = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x86.ActiveCfg = Release|Any CPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F}.Release|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|ARM.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|ARM.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x64.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x64.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x86.ActiveCfg = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Debug|x86.Build.0 = Debug|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.PerformanceTest|x86.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Any CPU.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|ARM.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|ARM.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x64.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x64.Build.0 = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x86.ActiveCfg = Release|Any CPU + {153CED68-9905-4B1F-9790-F463840895E2}.Release|x86.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|ARM.ActiveCfg = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|ARM.Build.0 = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|x64.ActiveCfg = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|x64.Build.0 = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|x86.ActiveCfg = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Debug|x86.Build.0 = Debug|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|x64.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.PerformanceTest|x86.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|Any CPU.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|ARM.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|ARM.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|x64.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|x64.Build.0 = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|x86.ActiveCfg = Release|Any CPU + {B10240C1-BB07-47A3-B056-CE52B5194D86}.Release|x86.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|ARM.ActiveCfg = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|ARM.Build.0 = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|x64.ActiveCfg = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|x64.Build.0 = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|x86.ActiveCfg = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Debug|x86.Build.0 = Debug|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|x64.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.PerformanceTest|x86.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|Any CPU.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|ARM.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|ARM.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|x64.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|x64.Build.0 = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|x86.ActiveCfg = Release|Any CPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B}.Release|x86.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|Any CPU.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|Any CPU.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|ARM.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|ARM.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|Mixed Platforms.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|Mixed Platforms.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|x64.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|x64.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|x86.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.CodeAnalysis|x86.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|ARM.ActiveCfg = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|ARM.Build.0 = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|x64.ActiveCfg = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|x64.Build.0 = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|x86.ActiveCfg = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Debug|x86.Build.0 = Debug|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|Any CPU.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|Any CPU.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|ARM.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|ARM.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|Mixed Platforms.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|Mixed Platforms.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|x64.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|x64.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|x86.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.PerformanceTest|x86.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|Any CPU.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|ARM.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|ARM.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|x64.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|x64.Build.0 = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|x86.ActiveCfg = Release|Any CPU + {D5A4E386-E418-4407-916E-A65092B78693}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -250,5 +505,13 @@ Global {EACF1BF1-CB21-4D62-942C-3488F60B8D70} = {87A17015-9338-431E-B338-57BDA03984C1} {3E9C7751-EE97-4820-BFEF-BA5F532A45C9} = {1BD5D488-707E-4030-8AE8-80D93D04963F} {9C7B55A6-AF7F-4D26-AB5B-297B7FF25B6D} = {3E9C7751-EE97-4820-BFEF-BA5F532A45C9} + {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} = {1BD5D488-707E-4030-8AE8-80D93D04963F} + {EFE532EA-77C8-4877-96C2-E79FD101B2AB} = {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F} = {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} + {153CED68-9905-4B1F-9790-F463840895E2} = {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} + {B10240C1-BB07-47A3-B056-CE52B5194D86} = {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B} = {7ED37CCB-869D-4FAC-80F5-3A13B2386B1D} + {D5A4E386-E418-4407-916E-A65092B78693} = {F7CD1D27-1441-4C2F-AB17-6FF8803460EC} + {F7CD1D27-1441-4C2F-AB17-6FF8803460EC} = {87A17015-9338-431E-B338-57BDA03984C1} EndGlobalSection EndGlobal diff --git a/Sync.Test.xml b/Sync.Test.xml index d830280f5..743e7e2c3 100644 --- a/Sync.Test.xml +++ b/Sync.Test.xml @@ -35,6 +35,7 @@ + @@ -116,9 +117,11 @@ + + @@ -150,6 +153,7 @@ + @@ -191,6 +195,7 @@ + diff --git a/Sync.xml b/Sync.xml index 793e65bbb..202e753d5 100644 --- a/Sync.xml +++ b/Sync.xml @@ -52,6 +52,7 @@ + @@ -59,7 +60,7 @@ - + diff --git a/src/MsgPack.CodeGeneration.CSharp/MsgPack.CodeGeneration.CSharp.csproj b/src/MsgPack.CodeGeneration.CSharp/MsgPack.CodeGeneration.CSharp.csproj new file mode 100644 index 000000000..81f10ebb7 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/MsgPack.CodeGeneration.CSharp.csproj @@ -0,0 +1,90 @@ + + + + + 14.0 + Debug + AnyCPU + {B10240C1-BB07-47A3-B056-CE52B5194D86} + Library + Properties + MsgPack + MsgPack.CodeGeneration.CSharp + ja-JP + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;NETSTANDARD1_3;CSHARP + prompt + 4 + bin\Debug\MsgPack.CodeGeneration.CSharp.XML + + + pdbonly + true + bin\Release\ + TRACE;NETSTANDARD1_3;CSHARP + prompt + 4 + bin\Release\MsgPack.CodeGeneration.CSharp.XML + + + true + + + ..\MsgPack.snk + + + + + MsgPack.snk + + + + + + Properties\CommonAssemblyInfo.cs + + + + + + + + + + + + + + + + {efe532ea-77c8-4877-96c2-e79fd101b2ab} + MsgPack.CodeGeneration.Core + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization + + + + + \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Properties/AssemblyInfo.cs b/src/MsgPack.CodeGeneration.CSharp/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..9ad48e5b2 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Properties/AssemblyInfo.cs @@ -0,0 +1,34 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: AssemblyTitle( "MessagePack for CLI(.NET/Mono)" )] +[assembly: AssemblyDescription( "MessagePack for CLI(.NET/Mono) C# code generator library." )] + +[assembly: AssemblyFileVersion( "0.7.2259.1047" )] + +#if DEBUG || PERFORMANCE_TEST +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.CodeTree, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +#endif + + diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeGenerators/CSharpCodeTreeBasedSerializerCodeGenerator.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeGenerators/CSharpCodeTreeBasedSerializerCodeGenerator.cs new file mode 100644 index 000000000..6e8db240d --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeGenerators/CSharpCodeTreeBasedSerializerCodeGenerator.cs @@ -0,0 +1,55 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +using MsgPack.Serialization.CodeTreeSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + /// + /// Provides front-end for Roslyn Code Analyzer based, portable C# serializer source code generator. + /// + /// + /// You must call in advance to use Roslyn Code Analyzer based C# source code generation. + /// If you miss it, Code DOM based legacy generator is used in desktop .NET Framework build (including Mono), or failed on other (.NET Core, etc.) based build. + /// + public static class CSharpCodeTreeBasedSerializerCodeGenerator + { + // based on in root web.config. + private static readonly string[] LanguageIdentifiers = + new[] { "C#", "CSharp", "CS" }; + + // TODO: VisualBasic are vb;vbs;visualbasic;vbscript + + /// + /// Configures C# generator and enables in . + /// + public static void Configure() + { + CodeTreeSerializerCodeGeneratorFactory.EnsureInitialized(); + CodeTreeSerializerCodeGeneratorFactory.RegisterFactory( + LanguageIdentifiers, + ( context, configuration ) => new CodeTreeContext( context, configuration, "cs" ), + context => type => new CSharpCodeTreeSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) + ); + } + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeConstruct.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeConstruct.cs new file mode 100644 index 000000000..5080b66f9 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeConstruct.cs @@ -0,0 +1,85 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Globalization; + +#if CSHARP +using Microsoft.CodeAnalysis.CSharp.Syntax; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using VariableDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.LocalDeclarationStatementSyntax; +#endif + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal abstract class CodeTreeConstruct : ICodeConstruct + { + public TypeDefinition ContextType { get; } + + public virtual bool IsExpression => false; + + public virtual bool IsStatement => false; + + protected CodeTreeConstruct( TypeDefinition contextType ) + { + this.ContextType = contextType; + } + + public virtual ParameterSyntax AsParameter() + { + throw new InvalidOperationException( + String.Format( CultureInfo.CurrentCulture, "Cannot get '{0}' as parameter declaration.", this ) + ); + } + + public virtual ExpressionSyntax AsExpression() + { + throw new InvalidOperationException( + String.Format( CultureInfo.CurrentCulture, "Cannot get '{0}' as expression.", this ) + ); + } + + public virtual IEnumerable AsStatements() + { + throw new InvalidOperationException( + String.Format( CultureInfo.CurrentCulture, "Cannot get '{0}' as statements.", this ) + ); + } + + public static CodeTreeConstruct Expression( TypeDefinition contextType, ExpressionSyntax expression ) + => new ExpressionCodeTreeConstruct( contextType, expression ); + + public static CodeTreeConstruct Statement( StatementSyntax statement ) + => new StatementCodeTreeConstruct( new[] { statement } ); + + public static CodeTreeConstruct Statement( IEnumerable statements ) + => new StatementCodeTreeConstruct( statements ); + + public static CodeTreeConstruct Variable( TypeDefinition contextType, VariableDeclarationSyntax syntax ) + => new VariableCodeTreeConstruct( contextType, syntax ); + + public static CodeTreeConstruct Parameter( TypeDefinition contextType, IdentifierNameSyntax syntax ) + => new ParameterCodeTreeConstruct( contextType, syntax ); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeContext.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeContext.cs new file mode 100644 index 000000000..dc0eda2c4 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeContext.cs @@ -0,0 +1,908 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.Diagnostics; +#if NETSTANDARD1_3 +using Contract = MsgPack.MPContract; +#else +using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_3 +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +using Microsoft.CodeAnalysis; +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using CodeTreeSerializerBuilder = MsgPack.Serialization.CodeTreeSerializers.CSharpCodeTreeSerializerBuilder; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; +using CodeTreeSerializerBuilder = MsgPack.Serialization.CodeTreeSerializers.VisualBasicCodeTreeSerializerBuilder; +#endif + +using MsgPack.Serialization.AbstractSerializers; +using static MsgPack.Serialization.CodeTreeSerializers.Syntax; +using static MsgPack.Serialization.CodeTreeSerializers.SyntaxCompatibilities; + +#if VISUAL_BASIC +using AttributeArgumentSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ArgumentSyntax; +using ClassDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ClassStatementSyntax; +using ConstructorDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.SubNewStatementSyntax; +using MemberDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.DeclarationStatementSyntax; +using TypeDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.TypeBlockSyntax; +using UsingDirectiveSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ImportsStatementSyntax; +#endif // VISUAL_BASIC + +#warning Fix Samuel Cragg spreading + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal class CodeTreeContext : SerializerGenerationContext, ISerializerCodeGenerationContext + { +#if VISUAL_BASIC + + private static ModifiedIdentifierSyntax Identifier( string identifier ) => ModifiedIdentifier( identifier ); + +#endif // VISUAL_BASIC + + private static readonly ParameterSyntax MessagePackObjectParameterSyntax = Parameter( Identifier( "messagePackObject" ) ).WithType( MessagePackObjectTypeSyntax ); + + private static readonly ParameterSyntax InitialCapacityParameterSyntax = Parameter( Identifier( "initialCapacity" ) ).WithType( Int32TypeSyntax ); + + private static readonly ParameterSyntax CancellationTokenParameterSyntax = Parameter( Identifier( "cancellationToken" ) ).WithType( CancellationTokenTypeSyntax ); + + private static readonly SyntaxList KnownUsingDirectives = + new SyntaxList().Add( + UsingDirective( IdentifierName( "System" ) ) + ).Add( + UsingDirective( IdentifierName( "System.Collections.Generic" ) ) + ).Add( + UsingDirective( IdentifierName( "System.Threading" ) ) + ).Add( + UsingDirective( IdentifierName( "System.Threading.Tasks" ) ) + ).Add( + UsingDirective( IdentifierName( "MsgPack" ) ).WithLeadingTrivia( BlankLine ) + ).Add( + UsingDirective( IdentifierName( "MsgPack.Serialization" ) ) + ); + + private static readonly SyntaxList StandardTypeAttributes = + new SyntaxList().Add( + AttributeList().AddAttributes( + Attribute( +#if CSHARP + IdentifierName( typeof( GeneratedCodeAttribute ).FullName ), + AttributeArgumentList( +#elif VISUAL_BASIC + Syntax.ToTypeSyntax( typeof( GeneratedCodeAttribute ) ) + ).WithArgumentList( + ArgumentList( +#endif + new SeparatedSyntaxList().Add( + AttributeArgument( + LiteralExpression( SyntaxKind.StringLiteralExpression, Literal( typeof( CodeTreeSerializerBuilder ).FullName ) ) + ) + ).Add( + AttributeArgument( + LiteralExpression( SyntaxKind.StringLiteralExpression, Literal( typeof( CodeTreeSerializerBuilder ).GetAssembly().GetName().Version.ToString() ) ) + ) + ) + ) + ) + ) + ); + + private static readonly AttributeListSyntax DebuggerNonUserCodeAttributeSyntax = + AttributeList().AddAttributes( + Attribute( + IdentifierName( typeof( DebuggerNonUserCodeAttribute ).FullName ) + ) + ); + +#if CSHARP + private static readonly ClassDeclarationSyntax UnpackingContextTypeTemplate = + ClassDeclaration( SerializerBuilderHelper.UnpackingContextTypeName ); +#elif VISUAL_BASIC + private static readonly ClassBlockSyntax UnpackingContextTypeTemplate = + ClassBlock( ClassDeclaration( SerializerBuilderHelper.UnpackingContextTypeName ) ); +#endif + + private static readonly ConstructorDeclarationSyntax UnpackingContextConstructorTemplate = + ConstructorDeclaration( SerializerBuilderHelper.UnpackingContextTypeName, PublicKeyword ); + + private static readonly CodeTreeConstruct SingletonPacker = CodeTreeConstruct.Parameter( typeof( Packer ), IdentifierName( "packer" ) ); + + private static readonly CodeTreeConstruct SingletonUnpacker = CodeTreeConstruct.Parameter( typeof( Unpacker ), IdentifierName( "unpacker" ) ); + + private static readonly CodeTreeConstruct SingletonIndexOfItem = CodeTreeConstruct.Parameter( typeof( int ), IdentifierName( "indexOfItem" ) ); + + private static readonly CodeTreeConstruct SingletonItemsCount = CodeTreeConstruct.Parameter( typeof( int ), IdentifierName( "itemsCount" ) ); + + private static readonly CodeTreeConstruct SingletonInitialCapacity = CodeTreeConstruct.Parameter( typeof( int ), IdentifierName( "initialCapacity" ) ); + + + private readonly Dictionary _dependentSerializers; + + private readonly Dictionary _cachedTargetFields; + + private readonly Dictionary _cachedPropertyAccessors; + + private readonly Dictionary _declaringTypes; + + private readonly SerializerCodeGenerationConfiguration _configuration; + + private readonly string _extension; + + private Type _targetType; + + private bool IsDictionary => this.KeyToAdd != null; + + private ClassDeclarationSyntaxBuilder _buildingType; + + public string DeclaringTypeName => this._buildingType.Identifier.ValueText; + + private readonly Stack _methodContextStack; + + /// + /// Gets a value indicating whether the generated serializers will be internal to MsgPack library itself. + /// + /// + /// true if the generated serializers are internal to MsgPack library itself; otherwise, false. + /// + /// + /// When you use MsgPack in Unity3D, you can import the library in source code form to your assets. + /// And, you may also import generated serializers together, then the generated serializers and MsgPack library will be same assembly ultimately. + /// It causes compilation error because some of overriding members have accessbility FamilyOrAssembly(protected internal in C#), + /// so the generated source code must have the accessibility when and only when they will be same assembly as MsgPack library itself. + /// + public bool IsInternalToMsgPackLibrary => this._configuration.IsInternalToMsgPackLibrary; + + public CodeTreeContext( SerializationContext context, SerializerCodeGenerationConfiguration configuration, string extension ) + : base( context ) + { + this._configuration = configuration; + this._extension = extension; + this._methodContextStack = new Stack(); + this._dependentSerializers = new Dictionary(); + this._cachedTargetFields = + new Dictionary( FieldInfoEqualityComparer.Instance ); + this._cachedPropertyAccessors = + new Dictionary( MethodBaseEqualityComparer.Instance ); + this._declaringTypes = new Dictionary(); + } + + public string RegisterSerializer( Type targetType, EnumMemberSerializationMethod enumSerializationMethod, DateTimeMemberConversionMethod dateTimeConversionMethod, PolymorphismSchema polymorphismSchema ) + { + var key = new SerializerFieldKey( targetType, enumSerializationMethod, dateTimeConversionMethod, polymorphismSchema ); + + string fieldName; + if ( !this._dependentSerializers.TryGetValue( key, out fieldName ) ) + { + fieldName = "_serializer" + this._dependentSerializers.Count.ToString( CultureInfo.InvariantCulture ); + this._dependentSerializers.Add( key, fieldName ); + this._buildingType.AddMembers( + FieldDeclaration( + GenericName( + "MessagePackSerializer", + ToTypeSyntax( Type.GetTypeFromHandle( key.TypeHandle ) ) + ), + fieldName + ).WithModifiers( PrivateReadOnlyKeyword ) + ); + } + + return fieldName; + } + + public Dictionary GetDependentSerializers() + { + return this._dependentSerializers; + } + + public string RegisterCachedFieldInfo( FieldInfo field ) + { + CachedFieldInfo cachedField; + if ( !this._cachedTargetFields.TryGetValue( field, out cachedField ) ) + { + Contract.Assert( field.DeclaringType != null, "field.DeclaringType != null" ); + + cachedField = + new CachedFieldInfo( + field, + "_field" + field.DeclaringType?.Name.Replace( '`', '_' ) + "_" + field.Name + this._cachedTargetFields.Count.ToString( CultureInfo.InvariantCulture ) + ); + this._cachedTargetFields.Add( field, cachedField ); + this._buildingType.AddMembers( + FieldDeclaration( FieldInfoTypeSyntax, cachedField.StorageFieldName ).WithModifiers( PrivateReadOnlyKeyword ) + ); + } + + return cachedField.StorageFieldName; + } + + protected override FieldDefinition DeclarePrivateFieldCore( string name, TypeDefinition type ) + { + if ( !this._buildingType.ContainsField( name ) ) + { + this._buildingType.AddMembers( + FieldDeclaration( MethodInfoTypeSyntax, name ).WithModifiers( PrivateReadOnlyKeyword ) + ); + } + + return new FieldDefinition( null, name, type ); + } + + public Dictionary GetCachedFieldInfos() + { + return this._cachedTargetFields; + } + + public string RegisterCachedMethodBase( MethodBase method ) + { + CachedMethodBase cachedMethod; + if ( !this._cachedPropertyAccessors.TryGetValue( method, out cachedMethod ) ) + { + Contract.Assert( method.DeclaringType != null, "method.DeclaringType != null" ); + + cachedMethod = + new CachedMethodBase( + method, + "_methodInfo" + method.DeclaringType?.Name.Replace( '`', '_' ) + "_" + method.Name + this._cachedPropertyAccessors.Count.ToString( CultureInfo.InvariantCulture ) + ); + this._cachedPropertyAccessors.Add( method, cachedMethod ); + this._buildingType.AddMembers( + FieldDeclaration( MethodInfoTypeSyntax, cachedMethod.StorageFieldName ).WithModifiers( PrivateReadOnlyKeyword ) + ); + } + + return cachedMethod.StorageFieldName; + } + + public Dictionary GetCachedMethodBases() + { + return this._cachedPropertyAccessors; + } + + /// + /// Gets a unique name of a local variable. + /// + /// The prefix of the variable. + /// A unique name of a local variable. + public override string GetUniqueVariableName( string prefix ) + { + var uniqueVariableSuffixes = this._methodContextStack.Peek().UniqueVariableSuffixes; + int counter; + if ( !uniqueVariableSuffixes.TryGetValue( prefix, out counter ) ) + { + uniqueVariableSuffixes.Add( prefix, 0 ); + return prefix; + } + + uniqueVariableSuffixes[ prefix ] = counter + 1; + + return prefix + counter.ToString( CultureInfo.InvariantCulture ); + } + + /// + /// Resets internal states for new type. + /// + /// Type of the target. + /// Type of base class of the target. + protected override void ResetCore( Type targetType, Type baseClass ) + { + var attributes = StandardTypeAttributes; + + if ( !this._configuration.SuppressDebuggerNonUserCodeAttribute ) + { + attributes = attributes.Add( DebuggerNonUserCodeAttributeSyntax ); + } + + this._targetType = targetType; + this._dependentSerializers.Clear(); + this._cachedTargetFields.Clear(); + this._cachedPropertyAccessors.Clear(); + + this._buildingType = + new ClassDeclarationSyntaxBuilder( + ClassDeclaration( IdentifierUtility.EscapeTypeName( targetType ) + "Serializer" ) + .WithAttributeLists( attributes ) + .WithModifiers( PublicKeyword ) + ).WithBaseList( baseClass ); + this._declaringTypes.Add( targetType, this._buildingType ); + + this.PackToTarget = CodeTreeConstruct.Parameter( targetType, IdentifierName( "objectTree" ) ); + this.NullCheckTarget = this.PackToTarget; + this.UnpackToTarget = CodeTreeConstruct.Parameter( targetType, IdentifierName( "collection" ) ); + this.Packer = SingletonPacker; + this.Unpacker = SingletonUnpacker; + this.IndexOfItem = SingletonIndexOfItem; + this.ItemsCount = SingletonItemsCount; + + var traits = targetType.GetCollectionTraits( CollectionTraitOptions.Full, this.SerializationContext.CompatibilityOptions.AllowNonCollectionEnumerableTypes ); + if ( traits.ElementType != null ) + { + this.CollectionToBeAdded = this.UnpackToTarget; + this.ItemToAdd = CodeTreeConstruct.Parameter( traits.ElementType, IdentifierName( "item" ) ); + + if ( traits.DetailedCollectionType == CollectionDetailedKind.GenericDictionary + || traits.DetailedCollectionType == CollectionDetailedKind.GenericReadOnlyDictionary + ) + { + this.KeyToAdd = CodeTreeConstruct.Parameter( traits.ElementType.GetGenericArguments()[ 0 ], IdentifierName( "key" ) ); + this.ValueToAdd = CodeTreeConstruct.Parameter( traits.ElementType.GetGenericArguments()[ 1 ], IdentifierName( "value" ) ); + } + else + { + this.KeyToAdd = null; + this.ValueToAdd = null; + } + + this.InitialCapacity = SingletonInitialCapacity; + } + } + + public override void BeginMethodOverride( string name ) + { + this._methodContextStack.Push( new MethodContext( name, false, typeof( object ), SerializerBuilderHelper.EmptyParameters ) ); + } + + public override void BeginPrivateMethod( string name, bool isStatic, TypeDefinition returnType, params CodeTreeConstruct[] parameters ) + { + this._methodContextStack.Push( + new MethodContext( + name, + isStatic, + returnType, + parameters + .Select( p => new KeyValuePair( p.AsParameter().GetIdentifierText(), p.ContextType ) ) + .ToArray() + ) + ); + } + + protected override MethodDefinition EndMethodOverrideCore( string name, CodeTreeConstruct body ) + { + + var context = this._methodContextStack.Pop(); +#if DEBUG + Contract.Assert( context.Name == name, "context.Name == name" ); +#endif // DEBUG + if ( body == null ) + { + return null; + } + + SyntaxTokenList modifiers; + TypeSyntax returnType = VoidTypeSyntax; + + var parameters = new SeparatedSyntaxList(); + + switch ( name ) + { + case MethodName.PackToCore: + { + parameters = + parameters.Add( + this.Packer.AsParameter() + ).Add( + this.PackToTarget.AsParameter() + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.UnpackFromCore: + { + parameters = parameters.Add( this.Unpacker.AsParameter() ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.UnpackToCore: + { + returnType = ToTypeSyntax( this._targetType ); + parameters = + parameters.Add( + this.Unpacker.AsParameter() + ).Add( + this.UnpackToTarget.AsParameter() + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.PackUnderlyingValueTo: + { + parameters = + parameters.Add( + this.Packer.AsParameter() + ).Add( + Parameter( Identifier( "enumValue" ) ).WithType( ToTypeSyntax( this._targetType ) ) + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.UnpackFromUnderlyingValue: + { + returnType = ToTypeSyntax( this._targetType ); + parameters = parameters.Add( MessagePackObjectParameterSyntax ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + + break; + } + case MethodName.AddItem: + { + parameters = + parameters.Add( + Parameter( Identifier( "collection" ) ).WithType( ToTypeSyntax( this._targetType ) ) + ); + if ( this.IsDictionary ) + { + parameters = + parameters.Add( + Parameter( Identifier( "key" ) ).WithType( ToTypeSyntax( this.KeyToAdd.ContextType ) ) + ).Add( + Parameter( Identifier( "value" ) ).WithType( ToTypeSyntax( this.ValueToAdd.ContextType ) ) + ); + } + else + { + parameters = + parameters.Add( + Parameter( Identifier( "item" ) ).WithType( ToTypeSyntax( this.ItemToAdd.ContextType ) ) + ); + } + + modifiers = ProtectedOverrideKeyword; + break; + } + case MethodName.CreateInstance: + { + returnType = ToTypeSyntax( this._targetType ); + parameters = parameters.Add( InitialCapacityParameterSyntax ); + modifiers = ProtectedOverrideKeyword; + break; + } + case MethodName.PackToAsyncCore: + { + returnType = TaskTypeSyntax; + parameters = + parameters.Add( + this.Packer.AsParameter() + ).Add( + this.PackToTarget.AsParameter() + ).Add( + CancellationTokenParameterSyntax + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.UnpackFromAsyncCore: + { + returnType = + GenericName( + typeof( Task ).Name, + ToTypeSyntax( this._targetType ) + ); + parameters = + parameters.Add( + this.Unpacker.AsParameter() + ).Add( + CancellationTokenParameterSyntax + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.UnpackToAsyncCore: + { + returnType = TaskTypeSyntax; + parameters = + parameters.Add( + this.Unpacker.AsParameter() + ).Add( + this.UnpackToTarget.AsParameter() + ).Add( + CancellationTokenParameterSyntax + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + case MethodName.PackUnderlyingValueToAsync: + { + returnType = TaskTypeSyntax; + parameters = + parameters.Add( + this.Packer.AsParameter() + ).Add( + Parameter( Identifier( "enumValue" ) ).WithType( ToTypeSyntax( this._targetType ) ) + ).Add( + CancellationTokenParameterSyntax + ); + modifiers = this.IsInternalToMsgPackLibrary ? ProtectedInternalOverrideKeyword : ProtectedOverrideKeyword; + break; + } + default: + { + throw new ArgumentOutOfRangeException( nameof( name ), name ); + } + } + + this._buildingType.AddMembers( + MethodDeclaration( returnType, name ) + .WithModifiers( modifiers ) + .WithParameterList( ParameterList( parameters ) ) + .WithBody( Block( body.AsStatements() ) ) + ); + + return + new MethodDefinition( + context.Name, + null, + null, + context.IsStatic, + context.ReturnType, + context.Parameters.Select( kv => kv.Value ).ToArray() + ); + } + + protected override MethodDefinition EndPrivateMethodCore( string name, CodeTreeConstruct body ) + { + var context = this._methodContextStack.Pop(); +#if DEBUG + Contract.Assert( context.Name == name, "context.Name == name" ); +#endif // DEBUG + if ( body == null ) + { + return null; + } + + this._buildingType.AddMembers( + MethodDeclaration( + context.ReturnType.TryGetRuntimeType() != typeof( void ) + ? ToTypeSyntax( context.ReturnType ) + : VoidTypeSyntax, + context.Name + ).WithModifiers( + context.IsStatic ? PrivateStaticKeyword : PrivateInstanceKeyword + ).WithParameterList( + ParameterList( + new SeparatedSyntaxList().AddRange( + context.Parameters.Select( kv => + Parameter( Identifier( kv.Key ) ).WithType( ToTypeSyntax( kv.Value ) ) + ) + ) + ) + ).WithBody( Block( body.AsStatements() ) ) + ); + + return + new MethodDefinition( + context.Name, + null, + null, + context.IsStatic, + context.ReturnType, + context.Parameters.Select( kv => kv.Value ).ToArray() + ); + } + + // For stack + public void BeginConstructor() + { + this._methodContextStack.Push( new MethodContext( ".ctor", false, typeof( object ), SerializerBuilderHelper.EmptyParameters ) ); + } + + public void EndConstructor() + { + this._methodContextStack.Pop(); + } + + public void AddMember( MemberDeclarationSyntax member ) + { + this._buildingType.AddMembers( member ); + } + + protected override void DefineUnpackingContextCore( + IList> fields, + out TypeDefinition type, + out ConstructorDefinition constructor, + out CodeTreeConstruct parameterInUnpackValueMethods, + out CodeTreeConstruct parameterInSetValueMethods, + out CodeTreeConstruct parameterInCreateObjectFromContext + ) + { + var fieldDeclarations = new SyntaxList(); + var parameters = new SeparatedSyntaxList(); + var statements = new SyntaxList(); + foreach ( var kv in fields ) + { + var fieldTypeSyntax = ToTypeSyntax( kv.Value ); + fieldDeclarations = + fieldDeclarations.Add( + FieldDeclaration( fieldTypeSyntax, kv.Key ).WithModifiers( PublicKeyword ) + ); + + parameters = + parameters.Add( + Parameter( Identifier( kv.Key ) ).WithType( fieldTypeSyntax ) + ); + + statements = + statements.Add( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( kv.Key ) + ), + IdentifierName( kv.Key ) + ) + ); + } + + this._buildingType + .WithMembers( fieldDeclarations ) + .AddMembers( + UnpackingContextTypeTemplate + .AddMembers( + UnpackingContextConstructorTemplate + .WithParameterList( ParameterList( parameters ) ) + .WithBody( Block( statements ) ) + ) + ); + type = TypeDefinition.Object( SerializerBuilderHelper.UnpackingContextTypeName ); + constructor = new ConstructorDefinition( type, fields.Select( kv => kv.Value ).ToArray() ); + DefineUnpackValueMethodArguments( type, out parameterInUnpackValueMethods, out parameterInSetValueMethods, out parameterInCreateObjectFromContext ); + } + + protected override void DefineUnpackingContextWithResultObjectCore( + out TypeDefinition type, + out CodeTreeConstruct parameterInUnpackValueMethods, + out CodeTreeConstruct parameterInSetValueMethods, + out CodeTreeConstruct parameterInCreateObjectFromContext + ) + { + type = TypeDefinition.Object( this._targetType ); + DefineUnpackValueMethodArguments( type, out parameterInUnpackValueMethods, out parameterInSetValueMethods, out parameterInCreateObjectFromContext ); + } + + private static void DefineUnpackValueMethodArguments( TypeDefinition type, out CodeTreeConstruct parameterInUnpackValueMethods, out CodeTreeConstruct parameterInSetValueMethods, out CodeTreeConstruct parameterInCreateObjectFromContext ) + { + parameterInUnpackValueMethods = CodeTreeConstruct.Parameter( type, IdentifierName( "unpackingContext" ) ); + parameterInSetValueMethods = CodeTreeConstruct.Parameter( type, IdentifierName( "unpackingContext" ) ); + parameterInCreateObjectFromContext = CodeTreeConstruct.Parameter( type, IdentifierName( "unpackingContext" ) ); + } + + public override CodeTreeConstruct DefineUnpackedItemParameterInSetValueMethods( TypeDefinition itemType ) + { + return CodeTreeConstruct.Parameter( itemType, IdentifierName( "unpackedValue" ) ); + } + + public IEnumerable Generate() + { +#warning TODO: indentation + + var directory = + Path.Combine( + this._configuration.OutputDirectory, + this._configuration.Namespace.Replace( ReflectionAbstractions.TypeDelimiter, Path.DirectorySeparatorChar ) + ); + Directory.CreateDirectory( directory ); + + var result = new List( this._declaringTypes.Count ); + + foreach ( var kv in this._declaringTypes ) + { + var declaringType = kv.Value.Build(); + var declaringTypeIdentifier = +#if CSHARP + declaringType.Identifier; +#elif VISUAL_BASIC + declaringType.ClassStatement.Identifier; +#endif + var typeFileName = declaringTypeIdentifier.ValueText; + var genericArity = +#if CSHARP + declaringType.TypeParameterList?.Parameters.Count; +#elif VISUAL_BASIC + declaringType.ClassStatement.TypeParameterList?.Parameters.Count; +#endif + if ( genericArity != null ) + { + typeFileName += "`" + genericArity.Value.ToString( "D", CultureInfo.InvariantCulture ); + } + + typeFileName += "." + this._extension; + + var compilationUnit = this.CreateCompilationUnit( declaringType ); + var filePath = Path.Combine( directory, typeFileName ); + result.Add( + new SerializerCodeGenerationResult( + kv.Key, + filePath, + String.IsNullOrEmpty( this._configuration.Namespace ) + ? declaringTypeIdentifier.ValueText + : this._configuration.Namespace + "." + declaringTypeIdentifier.ValueText, + this._configuration.Namespace, + declaringTypeIdentifier.ValueText + ) + ); + + using ( var fileStream = new FileStream( filePath, FileMode.Create, FileAccess.Write, FileShare.Read ) ) + using ( var writer = new StreamWriter( fileStream, Encoding.UTF8 ) ) + { + compilationUnit.WriteTo( writer ); + } + } + + return result; + } + + private CompilationUnitSyntax CreateCompilationUnit( TypeDeclarationSyntax targetType ) + => CompilationUnit() + .WithUsings( KnownUsingDirectives ) + .AddMembers( + NamespaceDeclaration( + IdentifierName( this._configuration.Namespace ) + ).WithLeadingTrivia( BlankLine ) + .WithMembers( +#if CSHARP + new SyntaxList() +#elif VISUAL_BASIC + new SyntaxList() +#endif + .Add( + targetType + ) + ) + ); + + public CompilationUnitSyntax CreateCompilationUnit() + => this.CreateCompilationUnit( this._buildingType.Build() ); + + public struct CachedFieldInfo + { + public readonly string StorageFieldName; + public readonly FieldInfo Target; + + public CachedFieldInfo( FieldInfo target, string storageFieldName ) + { + this.Target = target; + this.StorageFieldName = storageFieldName; + } + } + + public struct CachedMethodBase + { + public readonly string StorageFieldName; + public readonly MethodBase Target; + + public CachedMethodBase( MethodBase target, string storageFieldName ) + { + this.Target = target; + this.StorageFieldName = storageFieldName; + } + } + + private sealed class MethodContext + { + public readonly IDictionary UniqueVariableSuffixes; + + public readonly string Name; + + public readonly bool IsStatic; + + public readonly TypeDefinition ReturnType; + + public readonly KeyValuePair[] Parameters; + + public MethodContext( string name, bool isStatic, TypeDefinition returnType, KeyValuePair[] parameters ) + { + this.Name = name; + this.IsStatic = isStatic; + this.ReturnType = returnType; + this.Parameters = parameters; + this.UniqueVariableSuffixes = new Dictionary(); + } + } + + private sealed class ClassDeclarationSyntaxBuilder + { +#if CSHARP + private ClassDeclarationSyntax _syntax; + + public SyntaxToken Identifier => this._syntax.Identifier; + +#elif VISUAL_BASIC + + private ClassBlockSyntax _syntax; + + public SyntaxToken Identifier => this._syntax.ClassStatement.Identifier; + +#endif + + public ClassDeclarationSyntaxBuilder( ClassDeclarationSyntax syntax ) + { +#if CSHARP + this._syntax = syntax; +#elif VISUAL_BASIC + this._syntax = ClassBlock( syntax ); +#endif + } + + public ClassDeclarationSyntaxBuilder WithBaseList( TypeDefinition baseClass ) + { + this._syntax = +#if CSHARP + this._syntax.WithBaseList( + BaseList( + new SeparatedSyntaxList().Add( + SimpleBaseType( ToTypeSyntax( baseClass ) ) + ) + ) + ); +#elif VISUAL_BASIC + this._syntax.AddInherits( + InheritsStatement( ToTypeSyntax( baseClass ) ) + ); +#endif + return this; + } + + public ClassDeclarationSyntaxBuilder WithMembers( SyntaxList members ) + { +#if CSHARP + this._syntax = this._syntax.WithMembers( members ); +#elif VISUAL_BASIC + this._syntax = this._syntax.WithMembers( new SyntaxList().AddRange( members ) ); +#endif + return this; + } + + // ReSharper disable once UnusedMethodReturnValue.Local + public ClassDeclarationSyntaxBuilder AddMembers( params MemberDeclarationSyntax[] items ) + { + this._syntax = this._syntax.AddMembers( items ); + return this; + } + + public bool ContainsField( string name ) + => this._syntax.Members.OfType() +#if CSHARP + .Any( x => x.Declaration.Variables.Any( v => v.Identifier.ValueText == name ) ); +#elif VISUAL_BASIC + .Any( x => x.Declarators.Any( d => d.Names.Any( n => n.Identifier.ValueText == name ) ) ); +#endif + +#if CSHARP + public ClassDeclarationSyntax Build() => this._syntax; +#elif VISUAL_BASIC + public ClassBlockSyntax Build() => this._syntax; +#endif + } + } +} + diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeSerializerBuilder.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeSerializerBuilder.cs new file mode 100644 index 000000000..05065ce2d --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/CodeTreeSerializerBuilder.cs @@ -0,0 +1,1709 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Diagnostics; +#if NETSTANDARD1_3 +using Contract = MsgPack.MPContract; +#else +using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_3 +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Threading; +using System.Threading.Tasks; + +using Microsoft.CodeAnalysis; + +using MsgPack.Serialization.AbstractSerializers; +using MsgPack.Serialization.CollectionSerializers; +using static MsgPack.Serialization.CodeTreeSerializers.Syntax; +using static MsgPack.Serialization.CodeTreeSerializers.SyntaxCompatibilities; + +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using CompilationFactory = Microsoft.CodeAnalysis.CSharp.CSharpCompilation; +using CompilationOptionsImpl = Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; +using CatchClauseSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.CatchBlockSyntax; +using CompilationFactory = Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation; +using CompilationOptionsImpl = Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions; +using ConstructorInitializerSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionStatementSyntax; +using NamespaceDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.NamespaceBlockSyntax; +#endif + +namespace MsgPack.Serialization.CodeTreeSerializers +{ +#if CSHARP + internal sealed class CSharpCodeTreeSerializerBuilder : +#elif VISUAL_BASIC + internal sealed class VisualBasicCodeTreeSerializerBuilder : +#endif + SerializerBuilder, + ISerializerCodeGenerator + { +#if CSHARP + private const string Extension = "cs"; +#elif VISUAL_BASIC + private const string Extension = "vb"; +#endif + +#if VISUAL_BASIC + + private static ModifiedIdentifierSyntax Identifier( string identifier ) => ModifiedIdentifier( identifier ); + +#endif // VISUAL_BASIC + + private static readonly int ProcessId = GetCurrentProcessId(); + + private static int GetCurrentProcessId() + { + using ( var process = Process.GetCurrentProcess() ) + { + return process.Id; + } + } + + private static readonly ParameterSyntax ContextParameterSyntax = + Parameter( Identifier( "context" ) ) + .WithType( SerializationContextTypeSyntax ); + + private static readonly ParameterListSyntax ContextParameterListSyntax = + ParameterList( + new SeparatedSyntaxList().Add( + ContextParameterSyntax + ) + ); + + private static readonly SimpleNameSyntax ContextArgumentReferenceSyntax = IdentifierName( "context" ); + + private static readonly ArgumentSyntax ContextArgumentSyntax = Argument( ContextArgumentReferenceSyntax ); + + private static readonly SeparatedSyntaxList ContextArgumentListTemplate = + new SeparatedSyntaxList().Add( ContextArgumentSyntax ); + + private static readonly ParameterListSyntax ContextAndEnumSerializationMethodParameterListSyntax = + ContextParameterListSyntax.AddParameters( + Parameter( Identifier( "enumSerializationMethod" ) ) + .WithType( ToTypeSyntax( typeof( EnumSerializationMethod ) ) ) + ); + + private static readonly ConstructorInitializerSyntax ContextAndEnumSerializationMethodConstructorInitializerSyntax = + BaseConstructorInitializer( + ArgumentList( + // ReSharper disable once ImpureMethodCallOnReadonlyValueField + ContextArgumentListTemplate.Add( + Argument( + IdentifierName( "enumSerializationMethod" ) + ) + ) + ) + ); + + private static readonly SimpleNameSyntax EnumSerializationMethodTypeIdentifierSyntax = IdentifierName( typeof( EnumSerializationMethod ).FullName ); + + private static readonly SimpleNameSyntax RestoreSchemaMethodIdentifierSyntax = IdentifierName( MethodName.RestoreSchema ); + + private static readonly SimpleNameSyntax SerializerCapabilitiesTypeIdentifierSyntax = IdentifierName( typeof( SerializerCapabilities ).FullName ); + + private static readonly ExpressionSyntax SerializerCapabilitiesNoneSyntax = + SimpleMemberAccessExpression( + SerializerCapabilitiesTypeIdentifierSyntax, + IdentifierName( "None" ) + ); + + private static readonly InvocationExpressionSyntax EnumMessagePackSerializerHelpersDetermineEnumSerializationMethodMethodTemplate = + InvocationExpression( + SimpleMemberAccessExpression( + ToTypeSyntax( typeof( EnumMessagePackSerializerHelpers ) ), + IdentifierName( nameof( EnumMessagePackSerializerHelpers.DetermineEnumSerializationMethod ) ) + ) + ); + + private static readonly InvocationExpressionSyntax DateTimeMessagePackSerializerHelpersDetermineDateTimeConversionMethodTemplate = + InvocationExpression( + SimpleMemberAccessExpression( + ToTypeSyntax( typeof( DateTimeMessagePackSerializerHelpers ) ), + IdentifierName( nameof( DateTimeMessagePackSerializerHelpers.DetermineDateTimeConversionMethod ) ) + ) + ); + + private static readonly SimpleNameSyntax DateTimeMemberConversionMethodIdentifierSyntax = IdentifierName( typeof( DateTimeMemberConversionMethod ).FullName ); + + private static readonly InvocationExpressionSyntax ReflectionHelpersGetFieldMethodTemplate = + InvocationExpression( + SimpleMemberAccessExpression( + ToTypeSyntax( typeof( ReflectionHelpers ) ), + IdentifierName( nameof( ReflectionHelpers.GetField ) ) + ) + ); + + private static readonly InvocationExpressionSyntax ReflectionHelpersGetMethodMethodTemplate = + InvocationExpression( + SimpleMemberAccessExpression( + ToTypeSyntax( typeof( ReflectionHelpers ) ), + IdentifierName( nameof( ReflectionHelpers.GetMethod ) ) + ) + ); + +#if CSHARP + + private static readonly ArrayCreationExpressionSyntax TypeArrayCreationTemplate = + ArrayCreationExpression( ArrayType( ToTypeSyntax( TypeDefinition.TypeType ) ) ); + + private static ArrayCreationExpressionSyntax TypeArrayCreation( IEnumerable typeExpresions ) => + TypeArrayCreationTemplate.WithInitializer( + InitializerExpression( + SyntaxKind.ArrayInitializerExpression, + new SeparatedSyntaxList().AddRange( typeExpresions ) + ) + ); + +#elif VISUAL_BASIC + + private static readonly ArrayCreationExpressionSyntax TypeArrayCreationTemplate = + ArrayCreationExpression( ToTypeSyntax( TypeDefinition.TypeType ), CollectionInitializer() ); + + private static ArrayCreationExpressionSyntax TypeArrayCreation( IEnumerable typeExpressions ) => + TypeArrayCreationTemplate.AddInitializerInitializers( typeExpressions.ToArray() ); + +#endif + + private static readonly SyntaxList EmptyCatches = new SyntaxList(); + + + private readonly TypeDefinition _thisType; + +#if CSHARP + public CSharpCodeTreeSerializerBuilder( +#elif VISUAL_BASIC + public VisualBasicCodeTreeSerializerBuilder( +#endif + Type targetType, + CollectionTraits collectionTraits + ) + : base( targetType, collectionTraits ) + { + this._thisType = typeof( MessagePackSerializer<> ).MakeGenericType( this.TargetType ); + } + + protected override CodeTreeConstruct MakeNullLiteral( CodeTreeContext context, TypeDefinition contextType ) + => CodeTreeConstruct.Expression( contextType, NullLiteralSyntax ); + + private static CodeTreeConstruct MakeTinyNumberLiteral( TypeDefinition contextType, int value ) + => CodeTreeConstruct.Expression( + contextType, + CastExpression( + ToTypeSyntax( contextType ), + LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( value ) ) + ) + ); + + protected override CodeTreeConstruct MakeByteLiteral( CodeTreeContext context, byte constant ) + => MakeTinyNumberLiteral( TypeDefinition.ByteType, constant ); + + protected override CodeTreeConstruct MakeSByteLiteral( CodeTreeContext context, sbyte constant ) + => MakeTinyNumberLiteral( TypeDefinition.SByteType, constant ); + + protected override CodeTreeConstruct MakeInt16Literal( CodeTreeContext context, short constant ) + => MakeTinyNumberLiteral( TypeDefinition.Int16Type, constant ); + + protected override CodeTreeConstruct MakeUInt16Literal( CodeTreeContext context, ushort constant ) + => MakeTinyNumberLiteral( TypeDefinition.UInt16Type, constant ); + + protected override CodeTreeConstruct MakeInt32Literal( CodeTreeContext context, int constant ) + => CodeTreeConstruct.Expression( TypeDefinition.Int32Type, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeUInt32Literal( CodeTreeContext context, uint constant ) + => CodeTreeConstruct.Expression( TypeDefinition.UInt32Type, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeInt64Literal( CodeTreeContext context, long constant ) + => CodeTreeConstruct.Expression( TypeDefinition.Int64Type, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeUInt64Literal( CodeTreeContext context, ulong constant ) + => CodeTreeConstruct.Expression( TypeDefinition.UInt64Type, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeReal32Literal( CodeTreeContext context, float constant ) + => CodeTreeConstruct.Expression( TypeDefinition.SingleType, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeReal64Literal( CodeTreeContext context, double constant ) + => CodeTreeConstruct.Expression( TypeDefinition.DoubleType, LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeBooleanLiteral( CodeTreeContext context, bool constant ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, LiteralExpression( constant ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, constant ? TrueLiteralExpression( Token( SyntaxKind.TrueKeyword ) ) : FalseLiteralExpression( Token( SyntaxKind.FalseKeyword ) ) ); +#endif + + protected override CodeTreeConstruct MakeCharLiteral( CodeTreeContext context, char constant ) + => CodeTreeConstruct.Expression( TypeDefinition.CharType, LiteralExpression( SyntaxKind.CharacterLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeStringLiteral( CodeTreeContext context, string constant ) + => CodeTreeConstruct.Expression( TypeDefinition.StringType, LiteralExpression( SyntaxKind.StringLiteralExpression, Literal( constant ) ) ); + + protected override CodeTreeConstruct MakeEnumLiteral( CodeTreeContext context, TypeDefinition type, object constant ) + { + var asString = constant.ToString(); + if ( ( '0' <= asString[ 0 ] && asString[ 0 ] <= '9' ) || asString.Contains( ',' ) ) + { + // Unrepresentable numeric or combined flags + return + CodeTreeConstruct.Expression( + type, + CastExpression( + ToTypeSyntax( type ), + // Only support integrals. + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal( UInt64.Parse( ( ( Enum )constant ).ToString( "D" ), CultureInfo.InvariantCulture ) ) + ) + ) + ); + } + else + { + return + CodeTreeConstruct.Expression( + type, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName( type.TypeName ), + Token( SyntaxKind.DotToken ), + IdentifierName( asString ) + ) + ); + } + } + + protected override CodeTreeConstruct MakeDefaultLiteral( CodeTreeContext context, TypeDefinition type ) +#if CSHARP + => CodeTreeConstruct.Expression( type, DefaultExpression( ToTypeSyntax( type ) ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( type, NothingLiteralExpression( Token( SyntaxKind.NothingKeyword ) ) ); +#endif + + protected override CodeTreeConstruct EmitThisReferenceExpression( CodeTreeContext context ) + => CodeTreeConstruct.Expression( this._thisType, ThisExpression() ); + + protected override CodeTreeConstruct EmitBoxExpression( CodeTreeContext context, TypeDefinition valueType, CodeTreeConstruct value ) + => CodeTreeConstruct.Expression( TypeDefinition.ObjectType, CastExpression( ObjectTypeSyntax, value.AsExpression() ) ); + + protected override CodeTreeConstruct EmitUnboxAnyExpression( CodeTreeContext context, TypeDefinition targetType, CodeTreeConstruct value ) + => CodeTreeConstruct.Expression( targetType, CastExpression( ToTypeSyntax( targetType ), value.AsExpression() ) ); + + protected override CodeTreeConstruct EmitNotExpression( CodeTreeContext context, CodeTreeConstruct booleanExpression ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, PrefixUnaryExpression( SyntaxKind.LogicalNotExpression, booleanExpression.AsExpression() ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, NotExpression( booleanExpression.AsExpression() ) ); +#endif + + protected override CodeTreeConstruct EmitEqualsExpression( CodeTreeContext context, CodeTreeConstruct left, CodeTreeConstruct right ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, BinaryExpression( SyntaxKind.EqualsExpression, left.AsExpression(), right.AsExpression() ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, EqualsExpression( left.AsExpression(), right.AsExpression() ) ); +#endif + + protected override CodeTreeConstruct EmitGreaterThanExpression( CodeTreeContext context, CodeTreeConstruct left, CodeTreeConstruct right ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, BinaryExpression( SyntaxKind.GreaterThanExpression, left.AsExpression(), right.AsExpression() ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, GreaterThanExpression( left.AsExpression(), right.AsExpression() ) ); +#endif + + protected override CodeTreeConstruct EmitLessThanExpression( CodeTreeContext context, CodeTreeConstruct left, CodeTreeConstruct right ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, BinaryExpression( SyntaxKind.LessThanExpression, left.AsExpression(), right.AsExpression() ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Expression( TypeDefinition.BooleanType, LessThanExpression( left.AsExpression(), right.AsExpression() ) ); +#endif + + protected override CodeTreeConstruct EmitIncrement( CodeTreeContext context, CodeTreeConstruct int32Value ) +#if CSHARP + => CodeTreeConstruct.Expression( TypeDefinition.Int32Type, PostfixUnaryExpression( SyntaxKind.PostIncrementExpression, int32Value.AsExpression() ) ); +#elif VISUAL_BASIC + => CodeTreeConstruct.Statement( AddAssignmentStatement( int32Value.AsExpression(), NumericLiteralExpression( Literal( 1 ) ) ) ); +#endif + + protected override CodeTreeConstruct EmitTypeOfExpression( CodeTreeContext context, TypeDefinition type ) + => CodeTreeConstruct.Expression( TypeDefinition.TypeType, TypeOfExpression( ToTypeSyntax( type ) ) ); + + protected override CodeTreeConstruct EmitMethodOfExpression( CodeTreeContext context, MethodBase method ) + => CodeTreeConstruct.Expression( + TypeDefinition.MethodBaseType, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + Token( SyntaxKind.DotToken ), + IdentifierName( + context.RegisterCachedMethodBase( + method + ) + ) + ) + ); + + protected override CodeTreeConstruct EmitFieldOfExpression( CodeTreeContext context, FieldInfo field ) + => CodeTreeConstruct.Expression( + TypeDefinition.FieldInfoType, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + Token( SyntaxKind.DotToken ), + IdentifierName( + context.RegisterCachedFieldInfo( + field + ) + ) + ) + ); + + protected override CodeTreeConstruct EmitThrowStatement( CodeTreeContext context, CodeTreeConstruct exception ) + => CodeTreeConstruct.Statement( ThrowStatement( exception.AsExpression() ) ); + + protected override CodeTreeConstruct EmitSequentialStatements( CodeTreeContext context, TypeDefinition contextType, IEnumerable statements ) + { +#if DEBUG + statements = statements.ToArray(); + Contract.Assert( statements.All( c => c.IsStatement ), $"[{String.Join( ", ", statements.Select( ( c, i ) => new { c, i } ).Where( x => !x.c.IsStatement ).Select( x => $"[{x.i}]{x.c}" ) )}]" ); +#endif + return CodeTreeConstruct.Statement( statements.SelectMany( s => s.AsStatements() ) ); + } + + protected override CodeTreeConstruct DeclareLocal( CodeTreeContext context, TypeDefinition type, string name ) + { +#if DEBUG + Contract.Assert( !name.Contains( "." ) ); +#endif + return + CodeTreeConstruct.Variable( + type, + VariableDeclaration( + ToTypeSyntax( type ), + new SeparatedSyntaxList().Add( VariableDeclarator( context.GetUniqueVariableName( name ) ) ) + ) + ); + } + + protected override CodeTreeConstruct ReferArgument( CodeTreeContext context, TypeDefinition type, string name, int index ) + { +#if DEBUG + Contract.Assert( !name.Contains( "." ) ); +#endif + return CodeTreeConstruct.Parameter( type, IdentifierName( name ) ); + } + + protected override CodeTreeConstruct EmitCreateNewObjectExpression( CodeTreeContext context, CodeTreeConstruct variable, ConstructorDefinition constructor, params CodeTreeConstruct[] arguments ) + { +#if DEBUG + Contract.Assert( constructor != null ); + Contract.Assert( constructor.DeclaringType != null ); + Contract.Assert( arguments.All( c => c.IsExpression ), String.Join( ",", arguments.Select( c => c.ToString() ).ToArray() ) ); +#endif + return + CodeTreeConstruct.Expression( + constructor.DeclaringType, + ObjectCreationExpression( + ToTypeSyntax( constructor.DeclaringType ) + ).AddArgumentListArguments( + arguments.Select( a => Argument( a.AsExpression() ) ).ToArray() + ) + ); + } + + protected override CodeTreeConstruct EmitMakeRef( CodeTreeContext context, CodeTreeConstruct target ) + => CodeTreeConstruct.Expression( target.ContextType, MakeRefExpression( target.AsExpression() ) ); + + protected override CodeTreeConstruct EmitInvokeVoidMethod( CodeTreeContext context, CodeTreeConstruct instance, MethodDefinition method, params CodeTreeConstruct[] arguments ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( instance != null || method.DeclaringType != null ); + arguments = arguments.Where( a => a != null ).ToArray(); + Contract.Assert( arguments.All( c => c.IsExpression ), String.Join( ",", arguments.Select( c => c.ToString() ).ToArray() ) ); +#endif + return + CodeTreeConstruct.Statement( + ExpressionStatement( + CreateMethodInvocation( method, instance, arguments ) + ) + ); + } + + protected override CodeTreeConstruct EmitInvokeMethodExpression( CodeTreeContext context, CodeTreeConstruct instance, MethodDefinition method, IEnumerable arguments ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( instance != null || method.DeclaringType != null ); + arguments = arguments.Where( a => a != null ).ToArray(); + Contract.Assert( arguments.All( c => c.IsExpression ), String.Join( ",", arguments.Select( c => c.ToString() ).ToArray() ) ); +#endif + return + CodeTreeConstruct.Expression( + method.ReturnType, + CreateMethodInvocation( method, instance, arguments ) + ); + } + + + private static ExpressionSyntax CreateMethodInvocation( MethodDefinition method, CodeTreeConstruct instance, IEnumerable arguments ) + { + ExpressionSyntax target; + var methodName = method.MethodName; + + if ( method.Interface != null ) + { + // Explicit interface impl. +#if DEBUG + Contract.Assert( instance != null, "instance != null" ); + Contract.Assert( method.TryGetRuntimeMethod() != null, "method.TryGetRuntimeMethod() != null" ); + Contract.Assert( !method.TryGetRuntimeMethod().GetIsPublic(), method.TryGetRuntimeMethod() + " is non public" ); +#endif // DEBUG + target = + CastExpression( + // Generics is not supported yet. + ToTypeSyntax( method.Interface ), + instance.AsExpression() + ); + methodName = method.MethodName.Substring( method.MethodName.LastIndexOf( '.' ) + 1 ); + } + else + { + target = + instance == null + ? IdentifierName( method.DeclaringType.TypeName ) + : instance.AsExpression(); + } + + return + InvocationExpression( + SimpleMemberAccessExpression( + target, + ( method.TryGetRuntimeMethod() != null && method.TryGetRuntimeMethod().IsGenericMethod ) + ? GenericName( + methodName, + method.TryGetRuntimeMethod().GetGenericArguments().Select( t => ToTypeSyntax( t ) ) + ) : IdentifierName( methodName ) as SimpleNameSyntax + ), + ArgumentList( + new SeparatedSyntaxList().AddRange( arguments.Select( a => Argument( a.AsExpression() ) ) ) + ) + ); + } + + protected override CodeTreeConstruct EmitInvokeDelegateExpression( CodeTreeContext context, TypeDefinition delegateReturnType, CodeTreeConstruct @delegate, params CodeTreeConstruct[] arguments ) + { +#if DEBUG + Contract.Assert( @delegate.IsExpression ); + Contract.Assert( + @delegate.ContextType.TypeName.StartsWith( "System.Action" ) + || @delegate.ContextType.TypeName.StartsWith( "System.Func" ) + ); + arguments = arguments.Where( a => a != null ).ToArray(); + Contract.Assert( arguments.All( c => c.IsExpression ), String.Join( ",", arguments.Select( c => c.ToString() ).ToArray() ) ); +#endif + return + CodeTreeConstruct.Expression( + delegateReturnType, + InvocationExpression( + @delegate.AsExpression(), + ArgumentList( new SeparatedSyntaxList().AddRange( arguments.Select( a => Argument( a.AsExpression() ) ) ) ) + ) + ); + } + protected override CodeTreeConstruct EmitGetPropertyExpression( CodeTreeContext context, CodeTreeConstruct instance, PropertyInfo property ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( property.DeclaringType != null ); +#endif + return + CodeTreeConstruct.Expression( + property.PropertyType, + SimpleMemberAccessExpression( + instance == null + ? ToTypeSyntax( property.DeclaringType ) + : instance.AsExpression(), + IdentifierName( property.Name ) + ) + ); + } + + protected override CodeTreeConstruct EmitGetFieldExpression( CodeTreeContext context, CodeTreeConstruct instance, FieldDefinition field ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( instance != null || field.DeclaringType != null ); +#endif + return + CodeTreeConstruct.Expression( + field.FieldType, + SimpleMemberAccessExpression( + instance == null + ? ToTypeSyntax( field.DeclaringType ) + : instance.AsExpression(), + IdentifierName( field.FieldName ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "3", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitSetProperty( CodeTreeContext context, CodeTreeConstruct instance, PropertyInfo property, CodeTreeConstruct value ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( property.DeclaringType != null ); + Contract.Assert( value.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + instance == null + ? ToTypeSyntax( property.DeclaringType ) + : instance.AsExpression(), + IdentifierName( property.Name ) + ), + value.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "4", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "5", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitSetIndexedProperty( CodeTreeContext context, CodeTreeConstruct instance, TypeDefinition declaringType, string proeprtyName, CodeTreeConstruct key, CodeTreeConstruct value ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( instance != null || declaringType.HasRuntimeTypeFully() ); + Contract.Assert( key.IsExpression ); + Contract.Assert( value.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + ElementAccessExpression( + instance == null + ? ToTypeSyntax( declaringType.ResolveRuntimeType() ) + : instance.AsExpression() + ).AddArgumentListArguments( + Argument( key.AsExpression() ) + ), + value.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "3", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitSetField( CodeTreeContext context, CodeTreeConstruct instance, FieldDefinition field, CodeTreeConstruct value ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( instance != null || field.DeclaringType != null ); + Contract.Assert( value.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + instance == null + ? ToTypeSyntax( field.DeclaringType ) + : instance.AsExpression(), + IdentifierName( field.FieldName ) + ), + value.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "4", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitSetField( CodeTreeContext context, CodeTreeConstruct instance, TypeDefinition nestedType, string fieldName, CodeTreeConstruct value ) + { +#if DEBUG + Contract.Assert( instance == null || instance.IsExpression ); + Contract.Assert( value.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + instance == null + ? ToTypeSyntax( nestedType ) + : instance.AsExpression(), + IdentifierName( fieldName ) + ), + value.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitLoadVariableExpression( CodeTreeContext context, CodeTreeConstruct variable ) + => CodeTreeConstruct.Expression( variable.ContextType, variable.AsExpression() ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitStoreVariableStatement( CodeTreeContext context, CodeTreeConstruct variable, CodeTreeConstruct value ) + { +#if DEBUG + Contract.Assert( variable.IsExpression ); + Contract.Assert( value.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + variable.AsExpression(), + value.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitTryFinally( CodeTreeContext context, CodeTreeConstruct tryStatement, CodeTreeConstruct finallyStatement ) + { +#if DEBUG + Contract.Assert( tryStatement.IsStatement ); + Contract.Assert( finallyStatement.IsStatement ); +#endif + return + CodeTreeConstruct.Statement( + TryStatement( + Block( + tryStatement.AsStatements() + ), + EmptyCatches, + FinallyClause( + Block( + finallyStatement.AsStatements() + ) + ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitCreateNewArrayExpression( CodeTreeContext context, TypeDefinition elementType, int length ) + => CodeTreeConstruct.Expression( + TypeDefinition.Array( elementType ), + SZArrayCreationExpression( + ToTypeSyntax( elementType ), + LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( length ) ) + ) + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitCreateNewArrayExpression( CodeTreeContext context, TypeDefinition elementType, int length, IEnumerable initialElements ) + { +#if DEBUG + initialElements = initialElements.ToArray(); + Contract.Assert( initialElements.All( i => i.IsExpression ) ); +#endif + return + CodeTreeConstruct.Expression( + TypeDefinition.Array( elementType ), + SZArrayCreationExpression( + ToTypeSyntax( elementType ), + LiteralExpression( SyntaxKind.NumericLiteralExpression, Literal( length ) ), + initialElements.Select( i => i.AsExpression() ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitGetArrayElementExpression( CodeTreeContext context, CodeTreeConstruct array, CodeTreeConstruct index ) + => CodeTreeConstruct.Expression( + array.ContextType.ElementType, + ElementAccessExpression( array.AsExpression() ) + .WithExpression( index.AsExpression() ) + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "3", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitSetArrayElementStatement( CodeTreeContext context, CodeTreeConstruct array, CodeTreeConstruct index, CodeTreeConstruct value ) + => CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + ElementAccessExpression( + array.AsExpression() + ).WithExpression( + index.AsExpression() + ), + value.AsExpression() + ) + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitGetSerializerExpression( CodeTreeContext context, Type targetType, SerializingMember? memberInfo, PolymorphismSchema itemsSchema ) + => CodeTreeConstruct.Expression( + typeof( MessagePackSerializer<> ).MakeGenericType( targetType ), + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( + context.RegisterSerializer( + targetType, + memberInfo?.GetEnumMemberSerializationMethod() ?? EnumMemberSerializationMethod.Default, + memberInfo?.GetDateTimeMemberConversionMethod() ?? DateTimeMemberConversionMethod.Default, + itemsSchema ?? PolymorphismSchema.Create( targetType, memberInfo ) + ) + ) + ) + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitGetActionsExpression( CodeTreeContext context, ActionType actionType, bool isAsync ) + { + TypeDefinition type; + string name; + switch ( actionType ) + { + case ActionType.PackToArray: + { + type = + isAsync ? typeof( IList<> ).MakeGenericType( typeof( Func<,,,> ).MakeGenericType( typeof( Packer ), this.TargetType, typeof( CancellationToken ), typeof( Task ) ) ) : + typeof( IList<> ).MakeGenericType( typeof( Action<,> ).MakeGenericType( typeof( Packer ), this.TargetType ) ); + name = FieldName.PackOperationList; + break; + } + case ActionType.PackToMap: + { + type = + isAsync ? typeof( IDictionary<,> ).MakeGenericType( typeof( string ), typeof( Func<,,,> ).MakeGenericType( typeof( Packer ), this.TargetType, typeof( CancellationToken ), typeof( Task ) ) ) : + typeof( IDictionary<,> ).MakeGenericType( typeof( string ), typeof( Action<,> ).MakeGenericType( typeof( Packer ), this.TargetType ) ); + name = FieldName.PackOperationTable; + break; + } + case ActionType.IsNull: + { + type = typeof( IDictionary<,> ).MakeGenericType( typeof( string ), typeof( Func<,> ).MakeGenericType( this.TargetType, typeof( bool ) ) ); + name = FieldName.NullCheckersTable; + break; + } + case ActionType.UnpackFromArray: + { + type = + TypeDefinition.GenericReferenceType( + typeof( IList<> ), + isAsync ? + TypeDefinition.GenericReferenceType( + typeof( Func<,,,,,> ), + typeof( Unpacker ), + context.UnpackingContextType ?? this.TargetType, + typeof( int ), + typeof( int ), + typeof( CancellationToken ), + typeof( Task ) + ) : + TypeDefinition.GenericReferenceType( + typeof( Action<,,,> ), + typeof( Unpacker ), + context.UnpackingContextType ?? this.TargetType, + typeof( int ), + typeof( int ) + ) + ); + name = FieldName.UnpackOperationList; + break; + } + case ActionType.UnpackFromMap: + { + type = + TypeDefinition.GenericReferenceType( + typeof( IDictionary<,> ), + typeof( string ), + isAsync ? + TypeDefinition.GenericReferenceType( + typeof( Func<,,,,,> ), + typeof( Unpacker ), + context.UnpackingContextType ?? this.TargetType, + typeof( int ), + typeof( int ), + typeof( CancellationToken ), + typeof( Task ) + ) : + TypeDefinition.GenericReferenceType( + typeof( Action<,,,> ), + typeof( Unpacker ), + context.UnpackingContextType ?? this.TargetType, + typeof( int ), + typeof( int ) + ) + ); + name = FieldName.UnpackOperationTable; + break; + } + case ActionType.UnpackTo: + { + type = + isAsync ? typeof( Func<,,,,> ).MakeGenericType( typeof( Unpacker ), this.TargetType, typeof( int ), typeof( CancellationToken ), typeof( Task ) ) : + typeof( Action<,,> ).MakeGenericType( typeof( Unpacker ), this.TargetType, typeof( int ) ); + name = FieldName.UnpackTo; + break; + } + default: + { + throw new ArgumentOutOfRangeException( nameof( actionType ) ); + } + } + + if ( isAsync ) + { + name += "Async"; + } + + var field = context.DeclarePrivateField( name, type ); + + return + CodeTreeConstruct.Expression( + type, + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( field.FieldName ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitGetMemberNamesExpression( CodeTreeContext context ) + { + var field = context.DeclarePrivateField( FieldName.MemberNames, typeof( IList ) ); + + return + CodeTreeConstruct.Expression( + typeof( IList ), + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( field.FieldName ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitFinishFieldInitializationStatement( CodeTreeContext context, string name, CodeTreeConstruct value ) + => CodeTreeConstruct.Statement( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( name ) + ), + value.AsExpression() + ) + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitConditionalExpression( CodeTreeContext context, CodeTreeConstruct conditionExpression, CodeTreeConstruct thenExpression, CodeTreeConstruct elseExpression ) + { +#if DEBUG + Contract.Assert( + elseExpression == null + || thenExpression.ContextType.TryGetRuntimeType() == typeof( void ) + || ( thenExpression.ContextType.TryGetRuntimeType() == elseExpression.ContextType.TryGetRuntimeType() ), + thenExpression.ContextType + " != " + ( elseExpression == null ? "(null)" : elseExpression.ContextType.TypeName ) + ); + Contract.Assert( conditionExpression.IsExpression ); + Contract.Assert( + elseExpression == null + || thenExpression.ContextType.TryGetRuntimeType() == typeof( void ) + || ( thenExpression.ContextType.TryGetRuntimeType() == elseExpression.ContextType.TryGetRuntimeType() + && thenExpression.IsExpression == elseExpression.IsExpression ) + ); + +#endif + + return + elseExpression == null + ? CodeTreeConstruct.Statement( + IfStatement( + conditionExpression.AsExpression(), + Block( thenExpression.AsStatements() ) + ) + ) : thenExpression.ContextType.TryGetRuntimeType() == typeof( void ) || thenExpression.IsStatement + ? CodeTreeConstruct.Statement( + IfElseStatement( + conditionExpression.AsExpression(), + thenExpression.AsStatements(), + elseExpression.AsStatements() + ) + ) + : CodeTreeConstruct.Expression( + thenExpression.ContextType, + ConditionalExpression( + conditionExpression.AsExpression(), + thenExpression.AsExpression(), + elseExpression.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "3", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitAndConditionalExpression( CodeTreeContext context, IList conditionExpressions, CodeTreeConstruct thenExpression, CodeTreeConstruct elseExpression ) + { +#if DEBUG + Contract.Assert( conditionExpressions.All( c => c.IsExpression ) ); + Contract.Assert( thenExpression.IsStatement ); + Contract.Assert( elseExpression.IsStatement ); +#endif + + return + CodeTreeConstruct.Statement( + IfElseStatement( + conditionExpressions + .Select( c => c.AsExpression() ) + .Aggregate( ( l, r ) => + AndAlsoExpression( l, r ) + ), + thenExpression.AsStatements(), + elseExpression.AsStatements() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitRetrunStatement( CodeTreeContext context, CodeTreeConstruct expression ) + { +#if DEBUG + Contract.Assert( expression.IsExpression ); +#endif + return + CodeTreeConstruct.Statement( + ReturnStatement( + expression.AsExpression() + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "3", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitForEachLoop( CodeTreeContext context, CollectionTraits collectionTraits, CodeTreeConstruct collection, Func loopBodyEmitter ) + { +#if DEBUG + Contract.Assert( collection.IsExpression ); +#endif + + var currentName = context.GetUniqueVariableName( "current" ); + var current = this.DeclareLocal( context, collectionTraits.ElementType, currentName ); + return + CodeTreeConstruct.Statement( + ForEachStatement( + ToTypeSyntax( collectionTraits.ElementType ), + currentName, + collection.AsExpression(), + Block( + loopBodyEmitter( current ).AsStatements() + ) + ) + ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitEnumFromUnderlyingCastExpression( + CodeTreeContext context, + Type enumType, + CodeTreeConstruct underlyingValue + ) => CodeTreeConstruct.Expression( enumType, CastExpression( ToTypeSyntax( enumType ), underlyingValue.AsExpression() ) ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitEnumToUnderlyingCastExpression( + CodeTreeContext context, + Type underlyingType, + CodeTreeConstruct enumValue + ) => CodeTreeConstruct.Expression( underlyingType, CastExpression( ToTypeSyntax( underlyingType ), enumValue.AsExpression() ) ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override CodeTreeConstruct EmitNewPrivateMethodDelegateExpression( CodeTreeContext context, MethodDefinition method ) + { + var delegateBaseType = SerializerBuilderHelper.FindDelegateType( method.ReturnType, method.ParameterTypes ); + + var delegateType = + ( method.ReturnType.TryGetRuntimeType() == typeof( void ) && method.ParameterTypes.Length == 0 ) + ? delegateBaseType + : TypeDefinition.GenericReferenceType( + delegateBaseType, + method.ReturnType.TryGetRuntimeType() == typeof( void ) + ? method.ParameterTypes + : method.ParameterTypes.Concat( new[] { method.ReturnType } ).ToArray() + ); + + return + CodeTreeConstruct.Expression( + delegateType, + ObjectCreationExpression( + ToTypeSyntax( delegateType ) + ).AddArgumentListArguments( + Argument( + SimpleMemberAccessExpression( + method.IsStatic ? IdentifierName( context.DeclaringTypeName ) : ThisExpression() as ExpressionSyntax, + IdentifierName( method.MethodName ) + ) + ) + ) + ); + } + + /// + /// Builds the serializer code using specified code generation context. + /// + /// + /// The which holds configuration and stores generated code constructs. + /// + /// The substitution type if is abstract type. null when is not abstract type. + /// The schema which contains schema for collection items, dictionary keys, or tuple items. This value must not be null. + /// + /// is null. + /// + /// + /// This class does not support code generation. + /// + public void BuildSerializerCode( ISerializerCodeGenerationContext context, Type concreteType, PolymorphismSchema itemSchema ) + { + if ( context == null ) + { + throw new ArgumentNullException( nameof( context ) ); + } + + var asCodeTreeContext = context as CodeTreeContext; + if ( asCodeTreeContext == null ) + { + throw new ArgumentException( + "'context' was not created with CreateGenerationContextForCodeGeneration method.", + nameof( context ) + ); + } + + asCodeTreeContext.Reset( this.TargetType, this.BaseClass ); + + if ( !this.TargetType.GetIsEnum() ) + { + SerializationTarget targetInfo; + this.BuildSerializer( asCodeTreeContext, concreteType, itemSchema, out targetInfo ); + this.Finish( + asCodeTreeContext, + targetInfo, + false, + targetInfo == null + ? default( SerializerCapabilities? ) + : this.CollectionTraits.CollectionType == CollectionKind.NotCollection + ? targetInfo.GetCapabilitiesForObject() + : targetInfo.GetCapabilitiesForCollection( this.CollectionTraits ) + ); + } + else + { + this.BuildEnumSerializer( asCodeTreeContext ); + this.Finish( asCodeTreeContext, null, true, ( SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) ); + } + } + + protected override Func CreateSerializerConstructor( CodeTreeContext codeGenerationContext, SerializationTarget targetInfo, PolymorphismSchema schema, SerializerCapabilities? capabilities ) + { + this.Finish( codeGenerationContext, targetInfo, false, capabilities ); + var targetType = PrepareSerializerConstructorCreation( codeGenerationContext ); + + return targetType.CreateConstructorDelegate(); + } + + protected override Func CreateEnumSerializerConstructor( CodeTreeContext codeGenerationContext ) + { + this.Finish( codeGenerationContext, null, true, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ); + var targetType = PrepareSerializerConstructorCreation( codeGenerationContext ); + + return targetType.CreateConstructorDelegate(); + } + + private static Type PrepareSerializerConstructorCreation( CodeTreeContext codeGenerationContext ) + { + if ( !SerializerDebugging.OnTheFlyCodeGenerationEnabled ) + { + throw new NotSupportedException(); + } + + CompilationUnitSyntax cu = codeGenerationContext.CreateCompilationUnit(); + + if ( SerializerDebugging.DumpEnabled ) + { + SerializerDebugging.TraceEmitEvent( "Compile {0}", codeGenerationContext.DeclaringTypeName ); + cu.WriteTo( SerializerDebugging.ILTraceWriter ); + SerializerDebugging.FlushTraceData(); + } + + var assemblyName = $"CodeAssembly{DateTime.Now:yyyyMMddHHmmssfff}{ProcessId}{Environment.CurrentManagedThreadId}"; + + var compilation = + CompilationFactory.Create( + assemblyName, + new[] { cu.SyntaxTree }, + SerializerDebugging.CodeSerializerDependentAssemblies.Select( x => MetadataReference.CreateFromFile( x ) ), + new CompilationOptionsImpl( + OutputKind.DynamicallyLinkedLibrary +#if !DEBUG || PERFORMANCE_TEST + , optimizationLevel: OptimizationLevel.Release +#endif // !DEBUG || PERFORMANCE_TEST + ) + ); + var outputPath = Path.Combine( Path.GetTempPath(), assemblyName + "." + Extension ); + + var result = compilation.Emit( outputPath ); + if ( !result.Success ) + { + if ( SerializerDebugging.TraceEnabled && !SerializerDebugging.DumpEnabled ) + { + cu.WriteTo( SerializerDebugging.ILTraceWriter ); + SerializerDebugging.FlushTraceData(); + } + + throw new System.Runtime.Serialization.SerializationException( + String.Format( + CultureInfo.CurrentCulture, + "Failed to compile assembly. Details:{0}{1}", + Environment.NewLine, + BuildCompilationError( result.Diagnostics ) + ) + ); + } +#if DEBUG + // Check warning except ambigious type reference. + var warnings = + result.Diagnostics.Where( e => e.Id != "CS0436" ).ToArray(); + Contract.Assert( !warnings.Any(), BuildCompilationError( result.Diagnostics ) ); +#endif + + if ( SerializerDebugging.TraceEnabled ) + { + SerializerDebugging.TraceEmitEvent( "Build assembly '{0}' from dom.", outputPath ); + } + + SerializerDebugging.AddCompiledCodeDomAssembly( outputPath ); + + var rootNamespace = + cu.SyntaxTree.GetCompilationUnitRoot().ChildNodesAndTokens() + .First( x => x.AsNode() is NamespaceDeclarationSyntax ).ChildNodesAndTokens() + .First( x => x.AsNode() is QualifiedNameSyntax ).ToString(); + + var assembly = SerializerDebugging.LoadAssembly( outputPath ); + var targetType = + assembly.ExportedTypes + .SingleOrDefault( + t => + t.Namespace == rootNamespace + && t.Name == codeGenerationContext.DeclaringTypeName + ); + + Contract.Assert( + targetType != null, + rootNamespace + " not in:" + + String.Join( + Environment.NewLine, + assembly.ExportedTypes + .Select( t => t.FullName ).ToArray() + ) + ); + + return targetType; + } + + private static string BuildCompilationError( IEnumerable diagnostics ) + => String.Join( + Environment.NewLine, + diagnostics + .Select( + ( error, i ) => + String.Format( + CultureInfo.InvariantCulture, + "[{0}]{1}:{2}:({3}):{4}", + i, + error.Severity, + error.Id, + error.Location, + error + ) + ).ToArray() + ); + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "CodeDOM" )] + private void Finish( CodeTreeContext context, SerializationTarget targetInfo, bool isEnum, SerializerCapabilities? capabilities ) + { + var publicConstructorTemplate = + ConstructorDeclaration( + context.DeclaringTypeName, + SyntaxTokenList.Create( Token( SyntaxKind.PublicKeyword ) ) + ); + + // ctor + if ( isEnum ) + { + // .ctor(SerializationContext context) : base(context, EnumSerializationMethod.Xxx) + context.AddMember( + publicConstructorTemplate.WithParameterList( + ContextParameterListSyntax + ).WithInitializer( + BaseConstructorInitializer( + ArgumentList( + ContextArgumentListTemplate.Add( + Argument( + SimpleMemberAccessExpression( + EnumSerializationMethodTypeIdentifierSyntax, + IdentifierName( + EnumMessagePackSerializerHelpers.DetermineEnumSerializationMethod( + context.SerializationContext, + this.TargetType, + EnumMemberSerializationMethod.Default + ).ToString() + ) + ) + ) + ) + ) + ) + ) + ); + + // .ctor(SerializationContext context, EnumSerializationMethod enumSerializationMethod) : base(context, enumSerializationMethod) + context.AddMember( + publicConstructorTemplate.WithParameterList( + ContextAndEnumSerializationMethodParameterListSyntax + ).WithInitializer( + ContextAndEnumSerializationMethodConstructorInitializerSyntax + ) + ); + } + else + { + // not enum + + context.BeginConstructor(); + try + { + var statements = this.BuildDependentSerializersInitialization( context ); + statements = BuildCachedFieldInfosInitialization( context, statements ); + statements = BuildCachedMethodInfosInitialization( context, statements ); + + if ( targetInfo != null && this.CollectionTraits.CollectionType == CollectionKind.NotCollection ) + { + // For object only. + if ( !typeof( IPackable ).IsAssignableFrom( this.TargetType ) + || !typeof( IAsyncPackable ).IsAssignableFrom( this.TargetType ) + ) + { + statements = this.BuildPackOperationDelegatesInitialization( context, targetInfo, statements ); + } + + if ( targetInfo.CanDeserialize + && ( !typeof( IUnpackable ).IsAssignableFrom( this.TargetType ) + || !typeof( IAsyncUnpackable ).IsAssignableFrom( this.TargetType ) ) + ) + { + statements = this.BuildUnpackOperationDelegatesInitialization( context, targetInfo, statements ); + } + } + + statements = BuildCachedDelegatesInitialization( context, statements ); + + if ( context.IsUnpackToUsed ) + { + statements = statements.AddRange( this.EmitUnpackToInitialization( context ).AsStatements() ); + } + + context.AddMember( + publicConstructorTemplate.WithParameterList( + ContextParameterListSyntax + ).WithInitializer( + BaseConstructorInitializer( + ArgumentList( + this.BuildBaseConstructorArgs( context, capabilities ) + ) + ) + ).AddBodyStatements( statements.ToArray() ) + ); + } + finally + { + context.EndConstructor(); + } + } // else of isEnum + } + + private static SyntaxList BuildCachedDelegatesInitialization( CodeTreeContext context, SyntaxList statements ) + { + foreach ( var cachedDelegateInfo in context.GetCachedDelegateInfos() ) + { + statements = + statements.Add( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( cachedDelegateInfo.BackingField.FieldName ) + ), + ObjectCreationExpression( + ToTypeSyntax( cachedDelegateInfo.BackingField.FieldType ) + ).AddArgumentListArguments( + Argument( + SimpleMemberAccessExpression( + cachedDelegateInfo.IsThisInstance + ? ThisExpression() as ExpressionSyntax + : ToTypeSyntax( cachedDelegateInfo.TargetMethod.DeclaringType ), + IdentifierName( cachedDelegateInfo.TargetMethod.MethodName ) + ) + ) + ) + ) + ); + } + + return statements; + } + + private SeparatedSyntaxList BuildBaseConstructorArgs( CodeTreeContext context, SerializerCapabilities? capabilities ) + { + var baseConstructorArgs = ContextArgumentListTemplate; + + if ( this.BaseClass.GetTypeInfo().DeclaredConstructors.Where( c => !c.IsPublic && !c.IsStatic ) + .Any( + c => + c.GetParameterTypes() + .SequenceEqual( CollectionSerializerHelpers.CollectionConstructorTypes ) + ) + ) + { + baseConstructorArgs = + baseConstructorArgs.Add( + Argument( + InvocationExpression( + SimpleMemberAccessExpression( + IdentifierName( context.DeclaringTypeName ), + RestoreSchemaMethodIdentifierSyntax + ) + ) + ) + ); + } + + if ( capabilities.HasValue ) + { + var capabilitiesExpression = BuildCapabilitiesExpression( null, capabilities.Value, SerializerCapabilities.PackTo ); + capabilitiesExpression = BuildCapabilitiesExpression( capabilitiesExpression, capabilities.Value, SerializerCapabilities.UnpackFrom ); + capabilitiesExpression = BuildCapabilitiesExpression( capabilitiesExpression, capabilities.Value, SerializerCapabilities.UnpackTo ); + + baseConstructorArgs = + baseConstructorArgs.Add( + Argument( capabilitiesExpression ?? SerializerCapabilitiesNoneSyntax ) + ); + } + + return baseConstructorArgs; + } + + private SyntaxList BuildDependentSerializersInitialization( CodeTreeContext context ) + { + var statements = new SyntaxList(); + + int schemaNumber = -1; + foreach ( var dependentSerializer in context.GetDependentSerializers() ) + { + var targetType = Type.GetTypeFromHandle( dependentSerializer.Key.TypeHandle ); + var targetTypeSyntax = ToTypeSyntax( targetType ); + ExpressionSyntax getSerializerArgument; + + if ( targetType.GetIsEnum() ) + { + getSerializerArgument = + EnumMessagePackSerializerHelpersDetermineEnumSerializationMethodMethodTemplate + .AddArgumentListArguments( + ContextArgumentSyntax, + Argument( TypeOfExpression( targetTypeSyntax ) ), + Argument( + SimpleMemberAccessExpression( + EnumSerializationMethodTypeIdentifierSyntax, + IdentifierName( dependentSerializer.Key.EnumSerializationMethod.ToString() ) + ) + ) + ); + + } + else if ( DateTimeMessagePackSerializerHelpers.IsDateTime( targetType ) ) + { + getSerializerArgument = + DateTimeMessagePackSerializerHelpersDetermineDateTimeConversionMethodTemplate + .AddArgumentListArguments( + ContextArgumentSyntax, + Argument( + SimpleMemberAccessExpression( + DateTimeMemberConversionMethodIdentifierSyntax, + IdentifierName( dependentSerializer.Key.DateTimeConversionMethod.ToString() ) + ) + ) + ); + } + else + { + if ( dependentSerializer.Key.PolymorphismSchema == null ) + { + getSerializerArgument = NullLiteralSyntax; + } + else + { + schemaNumber++; + var variableName = "schema" + schemaNumber; + var schema = this.DeclareLocal( context, typeof( PolymorphismSchema ), variableName ); + statements = + statements + .AddRange( schema.AsStatements() ) + .AddRange( + this.EmitConstructPolymorphismSchema( + context, + schema, + dependentSerializer.Key.PolymorphismSchema + ).SelectMany( st => st.AsStatements() ) + ); + + getSerializerArgument = IdentifierName( variableName ); + } + } + + statements.Add( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( dependentSerializer.Value ) + ), + InvocationExpression( + SimpleMemberAccessExpression( + ContextArgumentReferenceSyntax, + GenericName( "GetSerializer" ) + .AddTypeArgumentListArguments( + targetTypeSyntax + ) + ) + ).AddArgumentListArguments( Argument( getSerializerArgument ) ) + ) + ); + } // foreach ( in context.GetDependentSerializers() ) + + return statements; + } + + private static SyntaxList BuildCachedFieldInfosInitialization( CodeTreeContext context, SyntaxList statements ) + { + foreach ( var cachedFieldInfo in context.GetCachedFieldInfos() ) + { + var fieldInfo = cachedFieldInfo.Value.Target; +#if DEBUG + Contract.Assert( fieldInfo != null, "fieldInfo != null" ); + Contract.Assert( fieldInfo.DeclaringType != null, "fieldInfo.DeclaringType != null" ); +#endif // DEBUG + statements = + statements.Add( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( cachedFieldInfo.Value.StorageFieldName ) + ), + ReflectionHelpersGetFieldMethodTemplate.AddArgumentListArguments( + Argument( TypeOfExpression( ToTypeSyntax( fieldInfo.DeclaringType ) ) ), + Argument( LiteralExpression( SyntaxKind.StringLiteralExpression, Literal( fieldInfo.Name ) ) ) + ) + ) + ); + } // foreach ( in context.GetCachedFieldInfos() ) + + return statements; + } + + private static SyntaxList BuildCachedMethodInfosInitialization( CodeTreeContext context, SyntaxList statements ) + { + foreach ( var cachedMethodBase in context.GetCachedMethodBases() ) + { + var methodBase = cachedMethodBase.Value.Target; + var parameterTypes = methodBase.GetParameterTypes(); + statements = + statements.Add( + SimpleAssignmentStatement( + SimpleMemberAccessExpression( + ThisExpression(), + IdentifierName( cachedMethodBase.Value.StorageFieldName ) + ), + ReflectionHelpersGetMethodMethodTemplate.AddArgumentListArguments( + Argument( TypeOfExpression( ToTypeSyntax( methodBase.DeclaringType ) ) ), + Argument( LiteralExpression( SyntaxKind.StringLiteralExpression, Literal( methodBase.Name ) ) ), + Argument( TypeArrayCreation( parameterTypes.Select( t => TypeOfExpression( ToTypeSyntax( t ) ) ) ) ) + ) + ) + ); + } // foreach ( in context.GetCachedMethodBases() ) + + return statements; + } + + private SyntaxList BuildPackOperationDelegatesInitialization( CodeTreeContext context, SerializationTarget targetInfo, SyntaxList statements ) + { + if ( !typeof( IPackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitPackOperationListInitialization( context, targetInfo, isAsync: false ).AsStatements() + ); + } + + if ( this.WithAsync( context ) && !typeof( IAsyncPackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitPackOperationListInitialization( context, targetInfo, isAsync: true ).AsStatements() + ); + } + + if ( targetInfo.Members.Any( m => m.Member != null ) ) // except Tuple + { + if ( !typeof( IPackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitPackOperationTableInitialization( context, targetInfo, isAsync: false ).AsStatements() + ); + } + + if ( this.WithAsync( context ) && !typeof( IAsyncPackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitPackOperationTableInitialization( context, targetInfo, isAsync: true ).AsStatements() + ); + } + + if ( !SerializerDebugging.UseLegacyNullMapEntryHandling + && ( !typeof( IPackable ).IsAssignableFrom( this.TargetType ) + || ( !typeof( IAsyncPackable ).IsAssignableFrom( this.TargetType ) && this.WithAsync( context ) ) + ) ) + { + statements = + statements.AddRange( + this.EmitPackNullCheckerTableInitialization( context, targetInfo ).AsStatements() + ); + } + } + + return statements; + } + + private SyntaxList BuildUnpackOperationDelegatesInitialization( CodeTreeContext context, SerializationTarget targetInfo, SyntaxList statements ) + { + if ( !typeof( IUnpackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitUnpackOperationListInitialization( context, targetInfo, false ).AsStatements() + ); + } + + if ( this.WithAsync( context ) && !typeof( IAsyncUnpackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitUnpackOperationListInitialization( context, targetInfo, true ).AsStatements() + ); + } + + if ( targetInfo.Members.Any( m => m.Member != null ) ) + { + // Except tuples + if ( !typeof( IUnpackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitUnpackOperationTableInitialization( context, targetInfo, false ).AsStatements() + ); + } + + if ( this.WithAsync( context ) && !typeof( IAsyncUnpackable ).IsAssignableFrom( this.TargetType ) ) + { + statements = + statements.AddRange( + this.EmitUnpackOperationTableInitialization( context, targetInfo, true ).AsStatements() + ); + } + } + + if ( !typeof( IUnpackable ).IsAssignableFrom( this.TargetType ) + || ( !typeof( IAsyncUnpackable ).IsAssignableFrom( this.TargetType ) && this.WithAsync( context ) ) + ) + { + statements = + statements.AddRange( + this.EmitMemberListInitialization( context, targetInfo ).AsStatements() + ); + } + + return statements; + } + + private static ExpressionSyntax BuildCapabilitiesExpression( ExpressionSyntax expression, SerializerCapabilities capabilities, SerializerCapabilities value ) + { + if ( ( capabilities & value ) != 0 ) + { + var capabilityExpression = + SimpleMemberAccessExpression( + SerializerCapabilitiesTypeIdentifierSyntax, + IdentifierName( value.ToString() ) + ); + + if ( expression == null ) + { + return capabilityExpression; + } + else + { + return + OrExpression( + expression, + capabilityExpression + ); + } + } + else + { + return expression; + } + } + + protected override CodeTreeContext CreateCodeGenerationContextForSerializerCreation( SerializationContext context ) + { + var result = new CodeTreeContext( context, new SerializerCodeGenerationConfiguration(), Extension ); + result.Reset( this.TargetType, this.BaseClass ); + return result; + } + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ExpressionCodeTreeConstruct.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ExpressionCodeTreeConstruct.cs new file mode 100644 index 000000000..6ccde976f --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ExpressionCodeTreeConstruct.cs @@ -0,0 +1,54 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; + +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +#endif + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal sealed class ExpressionCodeTreeConstruct : CodeTreeConstruct + { + private readonly ExpressionSyntax _expression; + + public override bool IsExpression => true; + + public ExpressionCodeTreeConstruct( TypeDefinition contextType, ExpressionSyntax expression ) + : base( contextType ) + { + this._expression = expression; + } + + public override ExpressionSyntax AsExpression() => this._expression; + + public override IEnumerable AsStatements() => new StatementSyntax[] { SyntaxFactory.ExpressionStatement( this._expression ) }; + + public override string ToString() => this._expression.ToString(); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ParameterCodeTreeConstruct.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ParameterCodeTreeConstruct.cs new file mode 100644 index 000000000..bcb755ad6 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/ParameterCodeTreeConstruct.cs @@ -0,0 +1,62 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; +#endif + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal sealed class ParameterCodeTreeConstruct : CodeTreeConstruct + { + private readonly IdentifierNameSyntax _identifierName; + private readonly ParameterSyntax _parameter; + + public override bool IsExpression => true; + + public ParameterCodeTreeConstruct( TypeDefinition contextType, IdentifierNameSyntax expression ) + : base( contextType ) + { + this._identifierName = expression; + this._parameter = +#if CSHARP + SyntaxFactory.Parameter( this._identifierName.Identifier ) +#elif VISUAL_BASIC + SyntaxFactory.Parameter( ModifiedIdentifier( this._identifierName.Identifier ) ) +#endif + .WithType( Syntax.ToTypeSyntax( contextType ) ); + } + + public override ParameterSyntax AsParameter() => this._parameter; + + public override ExpressionSyntax AsExpression() => this._identifierName; + + public override string ToString() => this._parameter.ToString(); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/StatementCodeTreeConstruct.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/StatementCodeTreeConstruct.cs new file mode 100644 index 000000000..5a3bdacad --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/StatementCodeTreeConstruct.cs @@ -0,0 +1,49 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Linq; + +#if CSHARP +using Microsoft.CodeAnalysis.CSharp.Syntax; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +#endif + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal sealed class StatementCodeTreeConstruct : CodeTreeConstruct + { + private readonly StatementSyntax[] _statements; + + public override bool IsStatement => true; + + public StatementCodeTreeConstruct( IEnumerable statements ) + : base( typeof( void ) ) + { + this._statements = statements.ToArray(); + } + + public override IEnumerable AsStatements() => this._statements; + + public override string ToString() => $"[{String.Join( ", ", this._statements as IEnumerable )}]"; + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/Syntax.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/Syntax.cs new file mode 100644 index 000000000..f89309841 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/Syntax.cs @@ -0,0 +1,171 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Linq; +using System.Reflection; +using System.Threading; +using System.Threading.Tasks; + +using Microsoft.CodeAnalysis; +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; +#endif + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + /// + /// Known syntax declarations. + /// + internal static class Syntax + { + public static readonly ExpressionSyntax NullLiteralSyntax = +#if CSHARP + LiteralExpression( SyntaxKind.NullLiteralExpression ); +#elif VISUAL_BASIC + NothingLiteralExpression( Token( SyntaxKind.NothingKeyword ) ); +#endif + public static readonly SyntaxTokenList PublicKeyword = + TokenList( Token( SyntaxKind.PublicKeyword ) ); + + public static readonly SyntaxTokenList PrivateInstanceKeyword = + TokenList( Token( SyntaxKind.PrivateKeyword ) ); + + public static readonly SyntaxTokenList PrivateReadOnlyKeyword = + TokenList( Token( SyntaxKind.PrivateKeyword ), Token( SyntaxKind.ReadOnlyKeyword ) ); + + public static readonly SyntaxTokenList PrivateStaticKeyword = +#if CSHARP + TokenList( Token( SyntaxKind.PrivateKeyword ), Token( SyntaxKind.StaticKeyword ) ); +#elif VISUAL_BASIC + TokenList( Token( SyntaxKind.PrivateKeyword ), Token( SyntaxKind.SharedKeyword ) ); +#endif + + public static readonly SyntaxTokenList ProtectedOverrideKeyword = +#if CSHARP + TokenList( Token( SyntaxKind.ProtectedKeyword ), Token( SyntaxKind.OverrideKeyword ) ); +#elif VISUAL_BASIC + TokenList( Token( SyntaxKind.ProtectedKeyword ), Token( SyntaxKind.OverridesKeyword ) ); +#endif + + public static readonly SyntaxTokenList ProtectedInternalOverrideKeyword = +#if CSHARP + TokenList( Token( SyntaxKind.ProtectedKeyword ), Token( SyntaxKind.InternalKeyword ), Token( SyntaxKind.OverrideKeyword ) ); +#elif VISUAL_BASIC + TokenList( Token( SyntaxKind.ProtectedKeyword ), Token( SyntaxKind.AssemblyKeyword ), Token( SyntaxKind.OverridesKeyword ) ); +#endif + + public static readonly TypeSyntax VoidTypeSyntax = +#if CSHARP + PredefinedType( Token( SyntaxKind.VoidKeyword ) ); +#elif VISUAL_BASIC + null; +#endif + + public static readonly TypeSyntax Int32TypeSyntax = +#if CSHARP + PredefinedType( Token( SyntaxKind.IntKeyword ) ); +#elif VISUAL_BASIC + PredefinedType( Token( SyntaxKind.IntegerKeyword ) ); +#endif + + + public static readonly TypeSyntax MessagePackObjectTypeSyntax = IdentifierName( typeof( MessagePackObject ).Name ); + + public static readonly TypeSyntax TaskTypeSyntax = IdentifierName( typeof( Task ).Name ); + + public static readonly TypeSyntax CancellationTokenTypeSyntax = IdentifierName( typeof( CancellationToken ).Name ); + + public static readonly TypeSyntax MethodInfoTypeSyntax = IdentifierName( typeof( MethodInfo ).Name ); + + public static readonly TypeSyntax FieldInfoTypeSyntax = IdentifierName( typeof( FieldInfo ).Name ); + + public static readonly TypeSyntax ObjectTypeSyntax = ToTypeSyntax( TypeDefinition.ObjectType ); + + public static readonly TypeSyntax SerializationContextTypeSyntax = ToTypeSyntax( TypeDefinition.SerializationContextType ); + + public static readonly SyntaxTrivia BlankLine = SyntaxTrivia( SyntaxKind.EndOfLineTrivia, "\r\n" ); + + + private static string GetGenericTypeBaseName( TypeDefinition genericType ) + { + return + genericType.HasRuntimeTypeFully() + ? genericType.ResolveRuntimeType().FullName.Remove( genericType.ResolveRuntimeType().FullName.IndexOf( '`' ) ) + : genericType.TypeName; + } + + public static TypeSyntax ToTypeSyntax( TypeDefinition type ) + { + if ( type.IsArray ) + { + return ArrayType( ToTypeSyntax( type.ElementType ) ); + } + + if ( type.HasRuntimeTypeFully() ) + { + if ( type.GenericArguments.Length == 0 ) + { + return IdentifierName( type.ResolveRuntimeType().FullName ); + } + else + { + return + GenericName( + Identifier( GetGenericTypeBaseName( type ) ), + TypeArgumentList( + new SeparatedSyntaxList().AddRange( + type.GenericArguments.Select( ToTypeSyntax ) + ) + ) + ); + } + } + else + { + if ( type.GenericArguments.Length == 0 ) + { + return IdentifierName( type.TypeName ); + } + else + { + return + GenericName( + Identifier( type.TypeName ), + TypeArgumentList( + new SeparatedSyntaxList().AddRange( + type.GenericArguments.Select( ToTypeSyntax ) + ) + ) + ); + } + } + } + + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs new file mode 100644 index 000000000..3e5f4e32a --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs @@ -0,0 +1,101 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Linq; + +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal static class SyntaxCompatibilities + { + public static BinaryExpressionSyntax AndAlsoExpression( ExpressionSyntax left, ExpressionSyntax right ) => + BinaryExpression( SyntaxKind.LogicalAndExpression, left, right ); + + public static ConstructorInitializerSyntax BaseConstructorInitializer( ArgumentListSyntax argumentList ) => + ConstructorInitializer( SyntaxKind.BaseConstructorInitializer, argumentList ); + + public static ConstructorDeclarationSyntax ConstructorDeclaration( string identifier, SyntaxTokenList accessibility ) => + SyntaxFactory.ConstructorDeclaration( identifier ).WithModifiers( accessibility ); + + public static FieldDeclarationSyntax FieldDeclaration( TypeSyntax type, string identifier ) => + SyntaxFactory.FieldDeclaration( VariableDeclaration( type ).AddVariables( VariableDeclarator( identifier ) ) ); + + public static GenericNameSyntax GenericName( string baseName, params TypeSyntax[] genericArguments ) => + SyntaxFactory.GenericName( baseName ).AddTypeArgumentListArguments( genericArguments ); + + public static GenericNameSyntax GenericName( string baseName, IEnumerable genericArguments ) => + SyntaxFactory.GenericName( baseName ).AddTypeArgumentListArguments( genericArguments.ToArray() ); + + public static IfStatementSyntax IfElseStatement( ExpressionSyntax conditionExpression, IEnumerable thenStatements, IEnumerable elseStatements ) => + IfStatement( + conditionExpression, + Block( + thenStatements + ), + ElseClause( + Block( + elseStatements + ) + ) + ); + + public static BinaryExpressionSyntax OrExpression( ExpressionSyntax left, ExpressionSyntax right ) => + BinaryExpression( SyntaxKind.BitwiseOrExpression, left, right ); + + public static StatementSyntax SimpleAssignmentStatement( ExpressionSyntax left, ExpressionSyntax right ) => + ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, left, right ) ); + + public static MemberAccessExpressionSyntax SimpleMemberAccessExpression( ExpressionSyntax expression, SimpleNameSyntax name ) => + MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, expression, name ); + + public static ArrayCreationExpressionSyntax SZArrayCreationExpression( TypeSyntax elementType, ExpressionSyntax length ) => + SyntaxFactory.ArrayCreationExpression( + ArrayType( + elementType, + new SyntaxList().Add( + ArrayRankSpecifier().AddSizes( length ) + ) + ) + ); + + public static ArrayCreationExpressionSyntax SZArrayCreationExpression( TypeSyntax elementType, ExpressionSyntax length, IEnumerable initializerExpressions ) => + SyntaxFactory.ArrayCreationExpression( + ArrayType( + elementType, + new SyntaxList().Add( + ArrayRankSpecifier().AddSizes( length ) + ) + ), + InitializerExpression( + SyntaxKind.ArrayInitializerExpression, + new SeparatedSyntaxList().AddRange( initializerExpressions ) + ) + ); + + + public static string GetIdentifierText( this ParameterSyntax source ) => source.Identifier.ValueText; + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/VariableCodeTreeConstruct.cs b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/VariableCodeTreeConstruct.cs new file mode 100644 index 000000000..007cc3957 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/Serialization/CodeTreeSerializers/VariableCodeTreeConstruct.cs @@ -0,0 +1,72 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Linq; + +using Microsoft.CodeAnalysis; +#if CSHARP +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +#elif VISUAL_BASIC +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; +using VariableDeclarationSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.LocalDeclarationStatementSyntax; +#endif + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal sealed class VariableCodeTreeConstruct : CodeTreeConstruct + { + private readonly VariableDeclarationSyntax _syntax; + private readonly IdentifierNameSyntax _identifierName; + + public override bool IsExpression => true; + + public override bool IsStatement => true; + + public VariableCodeTreeConstruct( TypeDefinition contextType, VariableDeclarationSyntax syntax ) + : base( contextType ) + { + this._syntax = syntax; +#if CSHARP + this._identifierName = IdentifierName( syntax.Variables.Single().Identifier ); +#elif VISUAL_BASIC + this._identifierName = IdentifierName( syntax.Declarators.Single().Names.Single().Identifier ); +#endif + } + + public override ExpressionSyntax AsExpression() => this._identifierName; + + public override IEnumerable AsStatements() => +#if CSHARP + new StatementSyntax[] { LocalDeclarationStatement( this._syntax ) }; +#elif VISUAL_BASIC + new StatementSyntax[] { LocalDeclarationStatement( this._syntax.Modifiers, this._syntax.Declarators ) }; +#endif + + public override string ToString() => this._identifierName.ToString(); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.CSharp/project.json b/src/MsgPack.CodeGeneration.CSharp/project.json new file mode 100644 index 000000000..b211574e0 --- /dev/null +++ b/src/MsgPack.CodeGeneration.CSharp/project.json @@ -0,0 +1,10 @@ +{ + "supports": {}, + "dependencies": { + "Microsoft.CodeAnalysis.CSharp": "1.3.2", + "System.Diagnostics.Process": "4.1.0" + }, + "frameworks": { + "netstandard1.3": {} + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.Core/MsgPack.CodeGeneration.Core.csproj b/src/MsgPack.CodeGeneration.Core/MsgPack.CodeGeneration.Core.csproj new file mode 100644 index 000000000..fd19158a6 --- /dev/null +++ b/src/MsgPack.CodeGeneration.Core/MsgPack.CodeGeneration.Core.csproj @@ -0,0 +1,103 @@ + + + + + 14.0 + Debug + AnyCPU + {EFE532EA-77C8-4877-96C2-E79FD101B2AB} + Library + Properties + MsgPack + MsgPack.CodeGeneration.Core + ja-JP + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;FEATURE_CONCURRENT;NETSTANDARD1_3 + prompt + 4 + bin\Debug\MsgPack.CodeGeneration.Core.XML + + + pdbonly + true + bin\Release\ + TRACE;FEATURE_CONCURRENT;NETSTANDARD1_3 + prompt + 4 + bin\Release\MsgPack.CodeGeneration.Core.XML + + + true + + + ..\MsgPack.snk + + + + + MsgPack.snk + + + + + + Properties\CommonAssemblyInfo.cs + + + Serialization\AbstractSerializers\ISerializerCodeGenerationContext.cs + + + Serialization\AbstractSerializers\ISerializerCodeGenerator.cs + + + Serialization\CodeGenerators\SerializerCodeGeneratorFactory.cs + + + Serialization\CodeGenerators\SerializerGenerationLogic`1.cs + + + Serialization\SerializerCodeGenerationConfiguration.cs + + + Serialization\SerializerCodeGenerationResult.cs + + + Serialization\SerializerGenerator.cs + + + Validation.cs + + + + + + + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization + + + + + \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.Core/Properties/AssemblyInfo.cs b/src/MsgPack.CodeGeneration.Core/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..f53f63e68 --- /dev/null +++ b/src/MsgPack.CodeGeneration.Core/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: AssemblyTitle( "MessagePack for CLI(.NET/Mono)" )] +[assembly: AssemblyDescription( "MessagePack for CLI(.NET/Mono) code generator core library." )] + +[assembly: AssemblyFileVersion( "0.7.2259.1047" )] + +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.CSharp, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.VisualBasic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] + +#if DEBUG || PERFORMANCE_TEST +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.CodeTree, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +#endif + diff --git a/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerCodeGeneratorFactory.cs b/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerCodeGeneratorFactory.cs new file mode 100644 index 000000000..043d002c8 --- /dev/null +++ b/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerCodeGeneratorFactory.cs @@ -0,0 +1,85 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Concurrent; +using System.Globalization; + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal sealed class CodeTreeSerializerCodeGeneratorFactory : SerializerCodeGeneratorFactory + { + private static readonly string[] GeneratorKeys = + new[] { "roslyn", "codetree", "codeanalyzer" }; + + public static readonly CodeTreeSerializerCodeGeneratorFactory Instance = new CodeTreeSerializerCodeGeneratorFactory(); + + private readonly ConcurrentDictionary _factories = new ConcurrentDictionary( StringComparer.OrdinalIgnoreCase ); + + private CodeTreeSerializerCodeGeneratorFactory() { } + + public static void EnsureInitialized() => SerializerGenerator.RegisterGenerator( GeneratorKeys, Instance ); + + public static void RegisterFactory( + string[] languages, + Func contextFactory, + Func> generatorFactory + ) + { + foreach ( var language in languages ) + { + Instance._factories[ language ] = new Factories( contextFactory, generatorFactory ); + } + } + + internal override SerializerGenerationLogic Create( SerializerCodeGenerationConfiguration configuration ) + { + Factories factories; + if ( !this._factories.TryGetValue( configuration.Language, out factories ) ) + { + throw new InvalidOperationException( + String.Format( + CultureInfo.CurrentCulture, + "Code analyzer based code generator is not registered for language '{0}'", + configuration.Language + ) + ); + } + return new CodeTreeSerializerGenerationLogic( factories.ContextFactory, factories.GeneratorFactory ); + } + + private struct Factories + { + public readonly Func ContextFactory; + public readonly Func> GeneratorFactory; + + public Factories( + Func contextFactory, + Func> generatorFactory + ) + { + this.ContextFactory = contextFactory; + this.GeneratorFactory = generatorFactory; + } + } + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerGenerationLogic.cs b/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerGenerationLogic.cs new file mode 100644 index 000000000..a307bf23c --- /dev/null +++ b/src/MsgPack.CodeGeneration.Core/Serialization/CodeGenerators/CodeTreeSerializerGenerationLogic.cs @@ -0,0 +1,50 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal sealed class CodeTreeSerializerGenerationLogic : SerializerGenerationLogic + { + private readonly Func _contextFactory; + private readonly Func> _generatorFactory; + + public CodeTreeSerializerGenerationLogic( + Func contextFactory, + Func> generatorFactory + ) + { + this._contextFactory = contextFactory; + this._generatorFactory = generatorFactory; + } + + // Just returns random stuff. + protected override EmitterFlavor EmitterFlavor => EmitterFlavor.FieldBased; + + protected override ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, SerializerCodeGenerationConfiguration configuration ) + => this._contextFactory( context, configuration ); + + protected override Func CreateGeneratorFactory( SerializationContext context ) + => this._generatorFactory( context ); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.Core/project.json b/src/MsgPack.CodeGeneration.Core/project.json new file mode 100644 index 000000000..662e36f78 --- /dev/null +++ b/src/MsgPack.CodeGeneration.Core/project.json @@ -0,0 +1,10 @@ +{ + "supports": {}, + "dependencies": { + "System.IO.FileSystem": "4.0.1", + "System.Text.RegularExpressions": "4.1.0" + }, + "frameworks": { + "netstandard1.3": {} + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.VisualBasic/MsgPack.CodeGeneration.VisualBasic.csproj b/src/MsgPack.CodeGeneration.VisualBasic/MsgPack.CodeGeneration.VisualBasic.csproj new file mode 100644 index 000000000..436612b2a --- /dev/null +++ b/src/MsgPack.CodeGeneration.VisualBasic/MsgPack.CodeGeneration.VisualBasic.csproj @@ -0,0 +1,111 @@ + + + + + 14.0 + Debug + AnyCPU + {A88D64DB-DE14-4B77-80D8-B765F45EBB8B} + Library + Properties + MsgPack + MsgPack.CodeGeneration.VisualBasic + ja-JP + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;NETSTANDARD1_3;VISUAL_BASIC + prompt + 4 + bin\Debug\MsgPack.CodeGeneration.VisualBasic.XML + + + pdbonly + true + bin\Release\ + TRACE;NETSTANDARD1_3;VISUAL_BASIC + prompt + 4 + bin\Release\MsgPack.CodeGeneration.VisualBasic.XML + + + true + + + ..\MsgPack.snk + + + + + MsgPack.snk + + + + + + Properties\CommonAssemblyInfo.cs + + + Serialization\CodeTreeSerializers\CodeTreeConstruct.cs + + + Serialization\CodeTreeSerializers\CodeTreeContext.cs + + + Serialization\CodeTreeSerializers\CodeTreeSerializerBuilder.cs + + + Serialization\CodeTreeSerializers\ExpressionCodeTreeConstruct.cs + + + Serialization\CodeTreeSerializers\ParameterCodeTreeConstruct.cs + + + Serialization\CodeTreeSerializers\StatementCodeTreeConstruct.cs + + + Serialization\CodeTreeSerializers\Syntax.cs + + + Serialization\CodeTreeSerializers\VariableCodeTreeConstruct.cs + + + + + + + + {efe532ea-77c8-4877-96c2-e79fd101b2ab} + MsgPack.CodeGeneration.Core + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization + + + + + C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6\Microsoft.VisualC.dll + + + + + \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.VisualBasic/Properties/AssemblyInfo.cs b/src/MsgPack.CodeGeneration.VisualBasic/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..04e311f80 --- /dev/null +++ b/src/MsgPack.CodeGeneration.VisualBasic/Properties/AssemblyInfo.cs @@ -0,0 +1,34 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: AssemblyTitle( "MessagePack for CLI(.NET/Mono)" )] +[assembly: AssemblyDescription( "MessagePack for CLI(.NET/Mono) Visual Basic code generator library." )] + +[assembly: AssemblyFileVersion( "0.7.2259.1047" )] + +#if DEBUG || PERFORMANCE_TEST +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.CodeTree, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +#endif + + diff --git a/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeGenerators/VisualBasicCodeTreeBasedSerializerCodeGenerator.cs b/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeGenerators/VisualBasicCodeTreeBasedSerializerCodeGenerator.cs new file mode 100644 index 000000000..391ccb71c --- /dev/null +++ b/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeGenerators/VisualBasicCodeTreeBasedSerializerCodeGenerator.cs @@ -0,0 +1,53 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +using MsgPack.Serialization.CodeTreeSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + /// + /// Provides front-end for Roslyn Code Analyzer based, portable C# serializer source code generator. + /// + /// + /// You must call in advance to use Roslyn Code Analyzer based C# source code generation. + /// If you miss it, Code DOM based legacy generator is used in desktop .NET Framework build (including Mono), or failed on other (.NET Core, etc.) based build. + /// + public static class VisualBasicCodeTreeBasedSerializerCodeGenerator + { + // based on in root web.config. + private static readonly string[] LanguageIdentifiers = + new[] { "VB", "VBS", "VisualBasic", "VBScript" }; + + /// + /// Configures C# generator and enables in . + /// + public static void Configure() + { + CodeTreeSerializerCodeGeneratorFactory.EnsureInitialized(); + CodeTreeSerializerCodeGeneratorFactory.RegisterFactory( + LanguageIdentifiers, + ( context, configuration ) => new CodeTreeContext( context, configuration, "cs" ), + context => type => new VisualBasicCodeTreeSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) + ); + } + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs b/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs new file mode 100644 index 000000000..14b67502a --- /dev/null +++ b/src/MsgPack.CodeGeneration.VisualBasic/Serialization/CodeTreeSerializers/SyntaxCompatibilities.cs @@ -0,0 +1,152 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Linq; + +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.CodeAnalysis.VisualBasic.Syntax; +using static Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory; + +namespace MsgPack.Serialization.CodeTreeSerializers +{ + internal static class SyntaxCompatibilities + { + public static SimpleArgumentSyntax Argument( ExpressionSyntax expression ) => SimpleArgument( expression ); + + public static SimpleArgumentSyntax AttributeArgument( ExpressionSyntax expression ) => SimpleArgument( expression ); + + public static ExpressionStatementSyntax BaseConstructorInitializer( ArgumentListSyntax argumentList ) => + ExpressionStatement( InvocationExpression( SimpleMemberAccessExpression( MyBaseExpression(), IdentifierName( "New" ) ), argumentList ) ); + + public static SyntaxList Block( IEnumerable statements ) => new SyntaxList().AddRange( statements ); + + public static DirectCastExpressionSyntax CastExpression( TypeSyntax type, ExpressionSyntax expression ) => DirectCastExpression( expression, type ); + + public static ClassStatementSyntax ClassDeclaration( string identifier ) => ClassStatement( identifier ); + + public static InvocationExpressionSyntax ConditionalExpression( ExpressionSyntax conditionExpression, ExpressionSyntax thenExpression, ExpressionSyntax elseExpression ) => + InvocationExpression( + MultiLineFunctionLambdaExpression( + FunctionLambdaHeader(), + EndFunctionStatement() + ).AddStatements( + MultiLineIfBlock( + SyntaxFactory.IfStatement( conditionExpression ) + ).WithStatements( new SyntaxList().Add( ReturnStatement( thenExpression ) ) ) + .WithElseBlock( ElseBlock( new SyntaxList().Add( ReturnStatement( elseExpression ) ) ) ) + ) + ); + + public static InvocationExpressionSyntax ElementAccessExpression( ExpressionSyntax typeOrInstance ) => InvocationExpression( typeOrInstance ); + + public static FinallyBlockSyntax FinallyClause( SyntaxList statements ) => FinallyBlock( statements ); + + public static ForEachBlockSyntax ForEachStatement( TypeSyntax variableType, string variableName, ExpressionSyntax collectionExpression, SyntaxList statements ) => + ForEachBlock( + SyntaxFactory.ForEachStatement( VariableDeclarator( variableName ).WithAsClause( SimpleAsClause( variableType ) ), collectionExpression ) + ).WithStatements( statements ); + + public static MultiLineIfBlockSyntax IfStatement( ExpressionSyntax conditionExpression, IEnumerable thenStatements ) => + MultiLineIfBlock( + SyntaxFactory.IfStatement( conditionExpression ) + ).WithStatements( Block( thenStatements ) ); + + public static MultiLineIfBlockSyntax IfElseStatement( ExpressionSyntax conditionExpression, IEnumerable thenStatements, IEnumerable elseStatements ) => + MultiLineIfBlock( + SyntaxFactory.IfStatement( conditionExpression ) + ).WithStatements( Block( thenStatements ) ) + .WithElseBlock( ElseBlock( Block( elseStatements ) ) ); + + public static ExpressionSyntax MakeRefExpression( ExpressionSyntax expression ) => expression; + + public static ArrayCreationExpressionSyntax SZArrayCreationExpression( TypeSyntax elementType, ExpressionSyntax length ) => + ArrayCreationExpression( + elementType, + CollectionInitializer() + ).AddArrayBoundsArguments( Argument( length ) ); + + public static ArrayCreationExpressionSyntax SZArrayCreationExpression( TypeSyntax elementType, ExpressionSyntax length, IEnumerable initializerExpressions ) => + ArrayCreationExpression( + elementType, + CollectionInitializer( new SeparatedSyntaxList().AddRange( initializerExpressions ) ) + ).AddArrayBoundsArguments( Argument( length ) ); + + public static MeExpressionSyntax ThisExpression() => MeExpression(); + + public static GetTypeExpressionSyntax TypeOfExpression( TypeSyntax type ) => GetTypeExpression( type ); + + public static ImportsStatementSyntax UsingDirective( IdentifierNameSyntax identifier ) => + ImportsStatement( new SeparatedSyntaxList().Add( SimpleImportsClause( identifier ) ) ); + + public static LocalDeclarationStatementSyntax VariableDeclaration( TypeSyntax type, SeparatedSyntaxList variables ) => + LocalDeclarationStatement( TokenList( Token( SyntaxKind.DimKeyword ) ), variables ); + + public static VariableDeclaratorSyntax VariableDeclarator( string identifier ) => + SyntaxFactory.VariableDeclarator( ModifiedIdentifier( identifier ) ); + + public static SubNewStatementSyntax ConstructorDeclaration( string identifier, SyntaxTokenList accessibility ) => + SubNewStatement().WithModifiers( accessibility ); + + public static FieldDeclarationSyntax FieldDeclaration( TypeSyntax type, string identifier ) => + SyntaxFactory.FieldDeclaration( VariableDeclarator( identifier ).WithAsClause( SimpleAsClause( type ) ) ); + + public static GenericNameSyntax GenericName( string baseName, params TypeSyntax[] genericArguments ) => + SyntaxFactory.GenericName( baseName, TypeArgumentList( genericArguments ) ); + + public static GenericNameSyntax GenericName( string baseName, IEnumerable genericArguments ) => + GenericName( baseName, genericArguments.ToArray() ); + + public static MethodStatementSyntax MethodDeclaration( TypeSyntax returnType, string identifier ) => + returnType == null + ? SubStatement( identifier ) + : FunctionStatement( identifier ).WithAsClause( SimpleAsClause( returnType ) ); + + public static NamespaceBlockSyntax NamespaceDeclaration( NameSyntax name ) => + NamespaceBlock( NamespaceStatement( name ) ); + + public static TryBlockSyntax TryStatement( SyntaxList statements, SyntaxList catchBlocks, FinallyBlockSyntax finallyBlock ) => + TryBlock( statements, catchBlocks, finallyBlock ); + + + public static ConstructorBlockSyntax AddBodyStatements( this ConstructorBlockSyntax source, params StatementSyntax[] statements ) => + source.AddStatements( statements ); + + public static string GetIdentifierText( this ParameterSyntax source ) => source.Identifier.Identifier.ValueText; + + public static MethodBlockSyntax WithBody( this MethodStatementSyntax source, SyntaxList statements ) => + ( source.SubOrFunctionKeyword.ValueText == "Sub" ? SubBlock( source ) : FunctionBlock( source ) ) + .WithStatements( statements ); + + public static ConstructorBlockSyntax WithBody( this SubNewStatementSyntax source, SyntaxList statements ) => + ConstructorBlock( source, statements ); + + public static ConstructorBlockSyntax WithInitializer( this SubNewStatementSyntax source, ExpressionStatementSyntax baseInitializer ) => + ConstructorBlock( source, new SyntaxList().Add( baseInitializer ) ); + + public static ParameterSyntax WithType( this ParameterSyntax source, TypeSyntax type ) => + source.WithAsClause( SimpleAsClause( type ) ); + + public static CompilationUnitSyntax WithUsings( this CompilationUnitSyntax source, SyntaxList imports ) => + source.WithImports( imports ); + } +} \ No newline at end of file diff --git a/src/MsgPack.CodeGeneration.VisualBasic/project.json b/src/MsgPack.CodeGeneration.VisualBasic/project.json new file mode 100644 index 000000000..fb4098b95 --- /dev/null +++ b/src/MsgPack.CodeGeneration.VisualBasic/project.json @@ -0,0 +1,10 @@ +{ + "supports": {}, + "dependencies": { + "Microsoft.CodeAnalysis.VisualBasic": "1.3.2", + "System.Diagnostics.Process": "4.1.0" + }, + "frameworks": { + "netstandard1.3": {} + } +} \ No newline at end of file diff --git a/src/MsgPack.Core/BufferedStream.cs b/src/MsgPack.Core/BufferedStream.cs new file mode 100644 index 000000000..50e773e4e --- /dev/null +++ b/src/MsgPack.Core/BufferedStream.cs @@ -0,0 +1,1294 @@ +// This file is based on https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/IO/BufferedStream.cs 814c2882a5c27ac40781bc20d6978708848784eb + +// ReSharper disable ArrangeThisQualifier +// ReSharper disable CheckNamespace +// ReSharper disable InconsistentNaming +// ReSharper disable PossibleNullReferenceException +// ReSharper disable RedundantUsingDirective + +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +/*============================================================ +** +** +** +** +** Purpose: A composable Stream that buffers reads & writes to the underlying stream. +** +** +===========================================================*/ +using System; +using System.Runtime.InteropServices; +using System.Globalization; +#if XAMIOS || XAMDROID || CORE_CLR || NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#if CORE_CLR || NETSTANDARD1_1 +using PureAttribute = MsgPack.PureAttribute; +#endif // CORE_CLR +#else +using System.Diagnostics.Contracts; +#endif // XAMIOS || XAMDROID || CORE_CLR || NETSTANDARD1_1 +using System.Runtime.CompilerServices; +using System.Threading; +using System.Collections.ObjectModel; +using System.Security; +using System.Threading.Tasks; + +namespace System.IO +{ + + /// + /// One of the design goals here is to prevent the buffer from getting in the way and slowing + /// down underlying stream accesses when it is not needed. If you always read & write for sizes + /// greater than the internal buffer size, then this class may not even allocate the internal buffer. + /// See a large comment in Write for the details of the write buffer heuristic. + /// + /// This class buffers reads & writes in a shared buffer. + /// (If you maintained two buffers separately, one operation would always trash the other buffer + /// anyways, so we might as well use one buffer.) + /// The assumption here is you will almost always be doing a series of reads or writes, but rarely + /// alternate between the two of them on the same stream. + /// + /// Class Invariants: + /// The class has one buffer, shared for reading & writing. + /// It can only be used for one or the other at any point in time - not both. + /// The following should be true: + /// 0 implies the read buffer is valid, but we're at the end of the buffer. + /// * _readPos == _readLen == 0 means the read buffer contains garbage. + /// * Either _writePos can be greater than 0, or _readLen & _readPos can be greater than zero, + /// but neither can be greater than zero at the same time. + /// ]]> + /// This class will never cache more bytes than the max specified buffer size. + /// However, it may use a temporary buffer of up to twice the size in order to combine several IO operations on + /// the underlying stream into a single operation. This is because we assume that memory copies are significantly + /// faster than IO operations on the underlying stream (if this was not true, using buffering is never appropriate). + /// The max size of this "shadow" buffer is limited as to not allocate it on the LOH. + /// Shadowing is always transient. Even when using this technique, this class still guarantees that the number of + /// bytes cached (not yet written to the target stream or not yet consumed by the user) is never larger than the + /// actual specified buffer size. + /// + [ComVisible( true )] + internal sealed class BufferedStream : Stream + { + + + private const Int32 _DefaultBufferSize = 4096; + + + private Stream _stream; // Underlying stream. Close sets _stream to null. + + private Byte[] _buffer; // Shared read/write buffer. Alloc on first use. + + private readonly Int32 _bufferSize; // Length of internal buffer (not counting the shadow buffer). + + private Int32 _readPos; // Read pointer within shared buffer. + private Int32 _readLen; // Number of bytes read in buffer from _stream. + private Int32 _writePos; // Write pointer within shared buffer. + + private Task _lastSyncCompletedReadTask; // The last successful Task returned from ReadAsync + // (perf optimization for successive reads of the same size) + + + // ReSharper disable once UnusedMember.Local + // Removing a private default constructor is a breaking change for the DataContractSerializer. + // Because this ctor was here previously we need to keep it around. + private BufferedStream() { } + + + public BufferedStream( Stream stream ) + + : this( stream, _DefaultBufferSize ) + { + } + + + public BufferedStream( Stream stream, Int32 bufferSize ) + { + + if ( stream == null ) + throw new ArgumentNullException( "stream" ); + + if ( bufferSize <= 0 ) + throw new ArgumentOutOfRangeException( "bufferSize", "The value must be positive." ); + + Contract.EndContractBlock(); + + _stream = stream; + _bufferSize = bufferSize; + + // Allocate _buffer on its first use - it will not be used if all reads + // & writes are greater than or equal to buffer size. + + if ( !_stream.CanRead && !_stream.CanWrite ) + __Error.StreamIsClosed(); + } + + + private void EnsureNotClosed() + { + + if ( _stream == null ) + __Error.StreamIsClosed(); + } + + + private void EnsureCanSeek() + { + + Contract.Requires( _stream != null ); + + if ( !_stream.CanSeek ) + __Error.SeekNotSupported(); + } + + + private void EnsureCanRead() + { + + Contract.Requires( _stream != null ); + + if ( !_stream.CanRead ) + __Error.ReadNotSupported(); + } + + + private void EnsureCanWrite() + { + + Contract.Requires( _stream != null ); + + if ( !_stream.CanWrite ) + __Error.WriteNotSupported(); + } + + /// MaxShadowBufferSize is chosed such that shadow buffers are not allocated on the Large Object Heap. + /// Currently, an object is allocated on the LOH if it is larger than 85000 bytes. See LARGE_OBJECT_SIZE in ndp\clr\src\vm\gc.h + /// We will go with exactly 80 KBytes, although this is somewhat arbitrary. + private const Int32 MaxShadowBufferSize = 81920; // Make sure not to get to the Large Object Heap. + private void EnsureShadowBufferAllocated() + { + + Contract.Assert( _buffer != null ); + Contract.Assert( _bufferSize > 0 ); + + // Already have shadow buffer? + if ( _buffer.Length != _bufferSize || _bufferSize >= MaxShadowBufferSize ) + return; + + Byte[] shadowBuffer = new Byte[Math.Min(_bufferSize + _bufferSize, MaxShadowBufferSize)]; + Buffer.BlockCopy( _buffer, 0, shadowBuffer, 0, _writePos ); + _buffer = shadowBuffer; + } + + + private void EnsureBufferAllocated() + { + + Contract.Assert( _bufferSize > 0 ); + + // BufferedStream is not intended for multi-threaded use, so no worries about the get/set race conditions on _buffer. + if ( _buffer == null ) + _buffer = new Byte[ _bufferSize ]; + } + + + internal Stream UnderlyingStream + { + [Pure] + get + { return _stream; } + } + + + internal Int32 BufferSize + { + [Pure] + get + { return _bufferSize; } + } + + + public override bool CanRead + { + [Pure] + get + { return _stream != null && _stream.CanRead; } + } + + + public override bool CanWrite + { + [Pure] + get + { return _stream != null && _stream.CanWrite; } + } + + + public override bool CanSeek + { + [Pure] + get + { return _stream != null && _stream.CanSeek; } + } + + + public override Int64 Length + { + get + { + EnsureNotClosed(); + + if ( _writePos > 0 ) + FlushWrite(); + + return _stream.Length; + } + } + + + public override Int64 Position + { + get + { + EnsureNotClosed(); + EnsureCanSeek(); + + Contract.Assert( !( _writePos > 0 && _readPos != _readLen ), "Read and Write buffers cannot both have data in them at the same time." ); + return _stream.Position + ( _readPos - _readLen + _writePos ); + } + set + { + if ( value < 0 ) + throw new ArgumentOutOfRangeException( "value", "The value cannot be negative." ); + Contract.EndContractBlock(); + + EnsureNotClosed(); + EnsureCanSeek(); + + if ( _writePos > 0 ) + FlushWrite(); + + _readPos = 0; + _readLen = 0; + _stream.Seek( value, SeekOrigin.Begin ); + } + } + + + protected override void Dispose( bool disposing ) + { + + try + { + if ( disposing && _stream != null ) + { + try + { + Flush(); + } + finally + { + _stream.Dispose(); + } + } + } + finally + { + _stream = null; + _buffer = null; + _lastSyncCompletedReadTask = null; + + // Call base.Dispose(bool) to cleanup async IO resources + base.Dispose( disposing ); + } + } + + + public override void Flush() + { + + EnsureNotClosed(); + + // Has WRITE data in the buffer: + if ( _writePos > 0 ) + { + + FlushWrite(); + Contract.Assert( _writePos == 0 && _readPos == 0 && _readLen == 0 ); + return; + } + + // Has READ data in the buffer: + if ( _readPos < _readLen ) + { + + // If the underlying stream is not seekable AND we have something in the read buffer, then FlushRead would throw. + // We can either throw away the buffer resulting in data loss (!) or ignore the Flush. + // (We cannot throw becasue it would be a breaking change.) We opt into ignoring the Flush in that situation. + if ( !_stream.CanSeek ) + return; + + FlushRead(); + + // User streams may have opted to throw from Flush if CanWrite is false (although the abstract Stream does not do so). + // However, if we do not forward the Flush to the underlying stream, we may have problems when chaining several streams. + // Let us make a best effort attempt: + if ( _stream.CanWrite || _stream is BufferedStream ) + _stream.Flush(); + + Contract.Assert( _writePos == 0 && _readPos == 0 && _readLen == 0 ); + return; + } + + // We had no data in the buffer, but we still need to tell the underlying stream to flush. + if ( _stream.CanWrite || _stream is BufferedStream ) + _stream.Flush(); + + _writePos = _readPos = _readLen = 0; + } + + public override Task FlushAsync( CancellationToken cancellationToken ) + { + + if ( cancellationToken.IsCancellationRequested ) + return _Task.FromCancellation( cancellationToken ); + + EnsureNotClosed(); + + return FlushAsyncInternal( cancellationToken, this, _stream, _writePos, _readPos, _readLen ); + } + + + private static async Task FlushAsyncInternal( CancellationToken cancellationToken, + BufferedStream _this, Stream stream, Int32 writePos, Int32 readPos, Int32 readLen ) + { + + // We bring instance fields down as local parameters to this async method becasue BufferedStream is derived from MarshalByRefObject. + // Field access would be from the async state machine i.e., not via the this pointer and would require runtime checking to see + // if we are talking to a remote object, which is currently very slow + + Contract.Assert( stream != null ); + + SemaphoreSlim sem = _this.EnsureAsyncActiveSemaphoreInitialized(); + await sem.WaitAsync().ConfigureAwait( false ); + try + { + + if ( writePos > 0 ) + { + + await _this.FlushWriteAsync( cancellationToken ).ConfigureAwait( false ); + Contract.Assert( _this._writePos == 0 && _this._readPos == 0 && _this._readLen == 0 ); + return; + } + + if ( readPos < readLen ) + { + + // If the underlying stream is not seekable AND we have something in the read buffer, then FlushRead would throw. + // We can either throw away the buffer resulting in date loss (!) or ignore the Flush. (We cannot throw becasue it + // would be a breaking change.) We opt into ignoring the Flush in that situation. + if ( !stream.CanSeek ) + return; + + _this.FlushRead(); // not async; it uses Seek, but there's no SeekAsync + + // User streams may have opted to throw from Flush if CanWrite is false (although the abstract Stream does not do so). + // However, if we do not forward the Flush to the underlying stream, we may have problems when chaining several streams. + // Let us make a best effort attempt: + if ( stream.CanRead || stream is BufferedStream ) + await stream.FlushAsync( cancellationToken ).ConfigureAwait( false ); + + Contract.Assert( _this._writePos == 0 && _this._readPos == 0 && _this._readLen == 0 ); + return; + } + + // We had no data in the buffer, but we still need to tell the underlying stream to flush. + if ( stream.CanWrite || stream is BufferedStream ) + await stream.FlushAsync( cancellationToken ).ConfigureAwait( false ); + + // There was nothing in the buffer: + Contract.Assert( _this._writePos == 0 && _this._readPos == _this._readLen ); + + } + finally + { + sem.Release(); + } + } + + + // Reading is done in blocks, but someone could read 1 byte from the buffer then write. + // At that point, the underlying stream's pointer is out of sync with this stream's position. + // All write functions should call this function to ensure that the buffered data is not lost. + private void FlushRead() + { + + Contract.Assert( _writePos == 0, "BufferedStream: Write buffer must be empty in FlushRead!" ); + + if ( _readPos - _readLen != 0 ) + _stream.Seek( _readPos - _readLen, SeekOrigin.Current ); + + _readPos = 0; + _readLen = 0; + } + + + private void ClearReadBufferBeforeWrite() + { + + // This is called by write methods to clear the read buffer. + + Contract.Assert( _readPos <= _readLen, "_readPos <= _readLen [" + _readPos + " <= " + _readLen + "]" ); + + // No READ data in the buffer: + if ( _readPos == _readLen ) + { + + _readPos = _readLen = 0; + return; + } + + // Must have READ data. + Contract.Assert( _readPos < _readLen ); + + // If the underlying stream cannot seek, FlushRead would end up throwing NotSupported. + // However, since the user did not call a method that is intuitively expected to seek, a better message is in order. + // Ideally, we would throw an InvalidOperation here, but for backward compat we have to stick with NotSupported. + if ( !_stream.CanSeek ) + throw new NotSupportedException( "Cannot write stream because read buffer cannot be flushed." ); + + FlushRead(); + } + + + private void FlushWrite() + { + + Contract.Assert( _readPos == 0 && _readLen == 0, + "BufferedStream: Read buffer must be empty in FlushWrite!" ); + Contract.Assert( _buffer != null && _bufferSize >= _writePos, + "BufferedStream: Write buffer must be allocated and write position must be in the bounds of the buffer in FlushWrite!" ); + + _stream.Write( _buffer, 0, _writePos ); + _writePos = 0; + _stream.Flush(); + } + + + private async Task FlushWriteAsync( CancellationToken cancellationToken ) + { + + Contract.Assert( _readPos == 0 && _readLen == 0, + "BufferedStream: Read buffer must be empty in FlushWrite!" ); + Contract.Assert( _buffer != null && _bufferSize >= _writePos, + "BufferedStream: Write buffer must be allocated and write position must be in the bounds of the buffer in FlushWrite!" ); + + await _stream.WriteAsync( _buffer, 0, _writePos, cancellationToken ).ConfigureAwait( false ); + _writePos = 0; + await _stream.FlushAsync( cancellationToken ).ConfigureAwait( false ); + } + + + private Int32 ReadFromBuffer( Byte[] array, Int32 offset, Int32 count ) + { + + Int32 readBytes = _readLen - _readPos; + Contract.Assert( readBytes >= 0 ); + + if ( readBytes == 0 ) + return 0; + + Contract.Assert( readBytes > 0 ); + + if ( readBytes > count ) + readBytes = count; + + Buffer.BlockCopy( _buffer, _readPos, array, offset, readBytes ); + _readPos += readBytes; + + return readBytes; + } + + + private Int32 ReadFromBuffer( Byte[] array, Int32 offset, Int32 count, out Exception error ) + { + + try + { + + error = null; + return ReadFromBuffer( array, offset, count ); + + } + catch ( Exception ex ) + { + error = ex; + return 0; + } + } + + + public override int Read( [In, Out] Byte[] array, Int32 offset, Int32 count ) + { + + if ( array == null ) + throw new ArgumentNullException( "array" ); + if ( offset < 0 ) + throw new ArgumentOutOfRangeException( "offset", "The value cannot be negative." ); + if ( count < 0 ) + throw new ArgumentOutOfRangeException( "count", "The value cannot be negative." ); + if ( array.Length - offset < count ) + throw new ArgumentException( "The offset is too big for length." ); + Contract.EndContractBlock(); + + EnsureNotClosed(); + EnsureCanRead(); + + Int32 bytesFromBuffer = ReadFromBuffer(array, offset, count); + + // We may have read less than the number of bytes the user asked for, but that is part of the Stream contract. + + // Reading again for more data may cause us to block if we're using a device with no clear end of file, + // such as a serial port or pipe. If we blocked here and this code was used with redirected pipes for a + // process's standard output, this can lead to deadlocks involving two processes. + // BUT - this is a breaking change. + // So: If we could not read all bytes the user asked for from the buffer, we will try once from the underlying + // stream thus ensuring the same blocking behaviour as if the underlying stream was not wrapped in this BufferedStream. + if ( bytesFromBuffer == count ) + return bytesFromBuffer; + + Int32 alreadySatisfied = bytesFromBuffer; + if ( bytesFromBuffer > 0 ) + { + count -= bytesFromBuffer; + offset += bytesFromBuffer; + } + + // So the READ buffer is empty. + Contract.Assert( _readLen == _readPos ); + _readPos = _readLen = 0; + + // If there was anything in the WRITE buffer, clear it. + if ( _writePos > 0 ) + FlushWrite(); + + // If the requested read is larger than buffer size, avoid the buffer and still use a single read: + if ( count >= _bufferSize ) + { + + return _stream.Read( array, offset, count ) + alreadySatisfied; + } + + // Ok. We can fill the buffer: + EnsureBufferAllocated(); + _readLen = _stream.Read( _buffer, 0, _bufferSize ); + + bytesFromBuffer = ReadFromBuffer( array, offset, count ); + + // We may have read less than the number of bytes the user asked for, but that is part of the Stream contract. + // Reading again for more data may cause us to block if we're using a device with no clear end of stream, + // such as a serial port or pipe. If we blocked here & this code was used with redirected pipes for a process's + // standard output, this can lead to deadlocks involving two processes. Additionally, translating one read on the + // BufferedStream to more than one read on the underlying Stream may defeat the whole purpose of buffering of the + // underlying reads are significantly more expensive. + + return bytesFromBuffer + alreadySatisfied; + } + + private Task LastSyncCompletedReadTask( Int32 val ) + { + + Task t = _lastSyncCompletedReadTask; + Contract.Assert( t == null || t.Status == TaskStatus.RanToCompletion ); + + if ( t != null && t.Result == val ) + return t; + + // ReSharper disable once RedundantTypeArgumentsOfMethod + t = Task.FromResult( val ); + _lastSyncCompletedReadTask = t; + return t; + } + + + public override Task ReadAsync( Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken ) + { + + if ( buffer == null ) + throw new ArgumentNullException( "buffer" ); + if ( offset < 0 ) + throw new ArgumentOutOfRangeException( "offset", "The value cannot be negative." ); + if ( count < 0 ) + throw new ArgumentOutOfRangeException( "count", "The value cannot be negative." ); + if ( buffer.Length - offset < count ) + throw new ArgumentException( "The offset is too big for length." ); + Contract.EndContractBlock(); + + // Fast path check for cancellation already requested + if ( cancellationToken.IsCancellationRequested ) + return _Task.FromCancellation( cancellationToken ); + + EnsureNotClosed(); + EnsureCanRead(); + + Int32 bytesFromBuffer = 0; + // Try to satisfy the request from the buffer synchronously. But still need a sem-lock in case that another + // Async IO Task accesses the buffer concurrently. If we fail to acquire the lock without waiting, make this + // an Async operation. + SemaphoreSlim sem = this.EnsureAsyncActiveSemaphoreInitialized(); + Task semaphoreLockTask = sem.WaitAsync(); + if ( semaphoreLockTask.Status == TaskStatus.RanToCompletion ) + { + + bool completeSynchronously = true; + try + { + Exception error; + bytesFromBuffer = ReadFromBuffer( buffer, offset, count, out error ); + + // If we satistied enough data from the buffer, we can complete synchronously. + // Reading again for more data may cause us to block if we're using a device with no clear end of file, + // such as a serial port or pipe. If we blocked here and this code was used with redirected pipes for a + // process's standard output, this can lead to deadlocks involving two processes. + // BUT - this is a breaking change. + // So: If we could not read all bytes the user asked for from the buffer, we will try once from the underlying + // stream thus ensuring the same blocking behaviour as if the underlying stream was not wrapped in this BufferedStream. + completeSynchronously = ( bytesFromBuffer == count || error != null ); + + if ( completeSynchronously ) + { + + return ( error == null ) + ? LastSyncCompletedReadTask( bytesFromBuffer ) + : _Task.FromException( error ); + } + } + finally + { + if ( completeSynchronously ) // if this is FALSE, we will be entering ReadFromUnderlyingStreamAsync and releasing there. + sem.Release(); + } + } + + // Delegate to the async implementation. + return ReadFromUnderlyingStreamAsync( buffer, offset + bytesFromBuffer, count - bytesFromBuffer, cancellationToken, + bytesFromBuffer, semaphoreLockTask ); + } + + + /// BufferedStream should be as thin a wrapper as possible. We want that ReadAsync delegates to + /// ReadAsync of the underlying _stream and that BeginRead delegates to BeginRead of the underlying stream, + /// rather than calling the base Stream which implements the one in terms of the other. This allows BufferedStream + /// to affect the semantics of the stream it wraps as little as possible. At the same time, we want to share as + /// much code between the APM and the Async pattern implementations as possible. This method is called by both with + /// a corresponding useApmPattern value. Recall that Task implements IAsyncResult. + /// -2 if _bufferSize was set to 0 while waiting on the semaphore; otherwise num of bytes read. + private async Task ReadFromUnderlyingStreamAsync( Byte[] array, Int32 offset, Int32 count, + CancellationToken cancellationToken, + Int32 bytesAlreadySatisfied, + Task semaphoreLockTask ) + { + + // Same conditions validated with exceptions in ReadAsync: + // (These should be Contract.Requires(..) but that method had some issues in async methods; using Assert(..) for now.) + Contract.Assert( array != null ); + Contract.Assert( offset >= 0 ); + Contract.Assert( count >= 0 ); + Contract.Assert( array.Length - offset >= count ); + Contract.Assert( _stream != null ); + Contract.Assert( _stream.CanRead ); + Contract.Assert( _bufferSize > 0 ); + Contract.Assert( semaphoreLockTask != null ); + + // Employ async waiting based on the same synchronization used in BeginRead of the abstract Stream. + await semaphoreLockTask.ConfigureAwait( false ); + try + { + + // The buffer might have been changed by another async task while we were waiting on the semaphore. + // Check it now again. + Int32 bytesFromBuffer = ReadFromBuffer(array, offset, count); + if ( bytesFromBuffer == count ) + return bytesAlreadySatisfied + bytesFromBuffer; + + if ( bytesFromBuffer > 0 ) + { + count -= bytesFromBuffer; + offset += bytesFromBuffer; + bytesAlreadySatisfied += bytesFromBuffer; + } + + Contract.Assert( _readLen == _readPos ); + _readPos = _readLen = 0; + + // If there was anything in the WRITE buffer, clear it. + if ( _writePos > 0 ) + await FlushWriteAsync( cancellationToken ).ConfigureAwait( false ); // no Begin-End read version for Flush. Use Async. + + // If the requested read is larger than buffer size, avoid the buffer and still use a single read: + if ( count >= _bufferSize ) + { + return bytesAlreadySatisfied + await _stream.ReadAsync( array, offset, count, cancellationToken ).ConfigureAwait( false ); + } + + // Ok. We can fill the buffer: + EnsureBufferAllocated(); + _readLen = await _stream.ReadAsync( _buffer, 0, _bufferSize, cancellationToken ).ConfigureAwait( false ); + + bytesFromBuffer = ReadFromBuffer( array, offset, count ); + return bytesAlreadySatisfied + bytesFromBuffer; + + } + finally + { + SemaphoreSlim sem = this.EnsureAsyncActiveSemaphoreInitialized(); + sem.Release(); + } + } + + + public override Int32 ReadByte() + { + + EnsureNotClosed(); + EnsureCanRead(); + + if ( _readPos == _readLen ) + { + + if ( _writePos > 0 ) + FlushWrite(); + + EnsureBufferAllocated(); + _readLen = _stream.Read( _buffer, 0, _bufferSize ); + _readPos = 0; + } + + if ( _readPos == _readLen ) + return -1; + + Int32 b = _buffer[_readPos++]; + return b; + } + + + private void WriteToBuffer( Byte[] array, ref Int32 offset, ref Int32 count ) + { + + Int32 bytesToWrite = Math.Min(_bufferSize - _writePos, count); + + if ( bytesToWrite <= 0 ) + return; + + EnsureBufferAllocated(); + Buffer.BlockCopy( array, offset, _buffer, _writePos, bytesToWrite ); + + _writePos += bytesToWrite; + count -= bytesToWrite; + offset += bytesToWrite; + } + + + private void WriteToBuffer( Byte[] array, ref Int32 offset, ref Int32 count, out Exception error ) + { + + try + { + + error = null; + WriteToBuffer( array, ref offset, ref count ); + + } + catch ( Exception ex ) + { + error = ex; + } + } + + + public override void Write( Byte[] array, Int32 offset, Int32 count ) + { + + if ( array == null ) + throw new ArgumentNullException( "array" ); + if ( offset < 0 ) + throw new ArgumentOutOfRangeException( "offset", "The value cannot be negative." ); + if ( count < 0 ) + throw new ArgumentOutOfRangeException( "count", "The value cannot be negative." ); + if ( array.Length - offset < count ) + throw new ArgumentException( "The offset is too big for length." ); + Contract.EndContractBlock(); + + EnsureNotClosed(); + EnsureCanWrite(); + + if ( _writePos == 0 ) + ClearReadBufferBeforeWrite(); + + #region Write algorithm comment + // We need to use the buffer, while avoiding unnecessary buffer usage / memory copies. + // We ASSUME that memory copies are much cheaper than writes to the underlying stream, so if an extra copy is + // guaranteed to reduce the number of writes, we prefer it. + // We pick a simple strategy that makes degenerate cases rare if our assumptions are right. + // + // For every write, we use a simple heuristic (below) to decide whether to use the buffer. + // The heuristic has the desirable property (*) that if the specified user data can fit into the currently available + // buffer space without filling it up completely, the heuristic will always tell us to use the buffer. It will also + // tell us to use the buffer in cases where the current write would fill the buffer, but the remaining data is small + // enough such that subsequent operations can use the buffer again. + // + // Algorithm: + // Determine whether or not to buffer according to the heuristic (below). + // If we decided to use the buffer: + // Copy as much user data as we can into the buffer. + // If we consumed all data: We are finished. + // Otherwise, write the buffer out. + // Copy the rest of user data into the now cleared buffer (no need to write out the buffer again as the heuristic + // will prevent it from being filled twice). + // If we decided not to use the buffer: + // Can the data already in the buffer and current user data be combines to a single write + // by allocating a "shadow" buffer of up to twice the size of _bufferSize (up to a limit to avoid LOH)? + // Yes, it can: + // Allocate a larger "shadow" buffer and ensure the buffered data is moved there. + // Copy user data to the shadow buffer. + // Write shadow buffer to the underlying stream in a single operation. + // No, it cannot (amount of data is still too large): + // Write out any data possibly in the buffer. + // Write out user data directly. + // + // Heuristic: + // If the subsequent write operation that follows the current write operation will result in a write to the + // underlying stream in case that we use the buffer in the current write, while it would not have if we avoided + // using the buffer in the current write (by writing current user data to the underlying stream directly), then we + // prefer to avoid using the buffer since the corresponding memory copy is wasted (it will not reduce the number + // of writes to the underlying stream, which is what we are optimising for). + // ASSUME that the next write will be for the same amount of bytes as the current write (most common case) and + // determine if it will cause a write to the underlying stream. If the next write is actually larger, our heuristic + // still yields the right behaviour, if the next write is actually smaller, we may making an unnecessary write to + // the underlying stream. However, this can only occur if the current write is larger than half the buffer size and + // we will recover after one iteration. + // We have: + // useBuffer = (_writePos + count + count < _bufferSize + _bufferSize) + // + // Example with _bufferSize = 20, _writePos = 6, count = 10: + // + // +---------------------------------------+---------------------------------------+ + // | current buffer | next iteration's "future" buffer | + // +---------------------------------------+---------------------------------------+ + // |0| | | | | | | | | |1| | | | | | | | | |2| | | | | | | | | |3| | | | | | | | | | + // |0|1|2|3|4|5|6|7|8|9|0|1|2|3|4|5|6|7|8|9|0|1|2|3|4|5|6|7|8|9|0|1|2|3|4|5|6|7|8|9| + // +-----------+-------------------+-------------------+---------------------------+ + // | _writePos | current count | assumed next count|avail buff after next write| + // +-----------+-------------------+-------------------+---------------------------+ + // + // A nice property (*) of this heuristic is that it will always succeed if the user data completely fits into the + // available buffer, i.e. if count < (_bufferSize - _writePos). + #endregion Write algorithm comment + + Contract.Assert( _writePos < _bufferSize ); + + Int32 totalUserBytes; + bool useBuffer; + checked + { // We do not expect buffer sizes big enough for an overflow, but if it happens, lets fail early: + totalUserBytes = _writePos + count; + useBuffer = ( totalUserBytes + count < ( _bufferSize + _bufferSize ) ); + } + + if ( useBuffer ) + { + + WriteToBuffer( array, ref offset, ref count ); + + if ( _writePos < _bufferSize ) + { + + Contract.Assert( count == 0 ); + return; + } + + Contract.Assert( count >= 0 ); + Contract.Assert( _writePos == _bufferSize ); + Contract.Assert( _buffer != null ); + + _stream.Write( _buffer, 0, _writePos ); + _writePos = 0; + + WriteToBuffer( array, ref offset, ref count ); + + Contract.Assert( count == 0 ); + Contract.Assert( _writePos < _bufferSize ); + + } + else + { // if (!useBuffer) + + // Write out the buffer if necessary. + if ( _writePos > 0 ) + { + + Contract.Assert( _buffer != null ); + Contract.Assert( totalUserBytes >= _bufferSize ); + + // Try avoiding extra write to underlying stream by combining previously buffered data with current user data: + if ( totalUserBytes <= ( _bufferSize + _bufferSize ) && totalUserBytes <= MaxShadowBufferSize ) + { + + EnsureShadowBufferAllocated(); + Buffer.BlockCopy( array, offset, _buffer, _writePos, count ); + _stream.Write( _buffer, 0, totalUserBytes ); + _writePos = 0; + return; + } + + _stream.Write( _buffer, 0, _writePos ); + _writePos = 0; + } + + // Write out user data. + _stream.Write( array, offset, count ); + } + } + + public override Task WriteAsync( Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken ) + { + + if ( buffer == null ) + throw new ArgumentNullException( "buffer" ); + if ( offset < 0 ) + throw new ArgumentOutOfRangeException( "offset", "The value cannot be negative." ); + if ( count < 0 ) + throw new ArgumentOutOfRangeException( "count", "The value cannot be negative." ); + if ( buffer.Length - offset < count ) + throw new ArgumentException( "The offset is too big for length." ); + Contract.EndContractBlock(); + + // Fast path check for cancellation already requested + if ( cancellationToken.IsCancellationRequested ) + return _Task.FromCancellation( cancellationToken ); + + EnsureNotClosed(); + EnsureCanWrite(); + + // Try to satisfy the request from the buffer synchronously. But still need a sem-lock in case that another + // Async IO Task accesses the buffer concurrently. If we fail to acquire the lock without waiting, make this + // an Async operation. + SemaphoreSlim sem = this.EnsureAsyncActiveSemaphoreInitialized(); + Task semaphoreLockTask = sem.WaitAsync(); + if ( semaphoreLockTask.Status == TaskStatus.RanToCompletion ) + { + + bool completeSynchronously = true; + try + { + + if ( _writePos == 0 ) + ClearReadBufferBeforeWrite(); + + Contract.Assert( _writePos < _bufferSize ); + + // If the write completely fits into the buffer, we can complete synchronously: + completeSynchronously = ( count < _bufferSize - _writePos ); + + if ( completeSynchronously ) + { + + Exception error; + WriteToBuffer( buffer, ref offset, ref count, out error ); + Contract.Assert( count == 0 ); + + return ( error == null ) + ? _Task.CompletedTask + : _Task.FromException( error ); + } + } + finally + { + if ( completeSynchronously ) // if this is FALSE, we will be entering WriteToUnderlyingStreamAsync and releasing there. + sem.Release(); + } + } + + // Delegate to the async implementation. + return WriteToUnderlyingStreamAsync( buffer, offset, count, cancellationToken, semaphoreLockTask ); + } + + + /// BufferedStream should be as thin a wrapper as possible. We want that WriteAsync delegates to + /// WriteAsync of the underlying _stream and that BeginWrite delegates to BeginWrite of the underlying stream, + /// rather than calling the base Stream which implements the one in terms of the other. This allows BufferedStream + /// to affect the semantics of the stream it wraps as little as possible. At the same time, we want to share as + /// much code between the APM and the Async pattern implementations as possible. This method is called by both with + /// a corresponding useApmPattern value. Recall that Task implements IAsyncResult. + private async Task WriteToUnderlyingStreamAsync( Byte[] array, Int32 offset, Int32 count, + CancellationToken cancellationToken, + Task semaphoreLockTask ) + { + + // (These should be Contract.Requires(..) but that method had some issues in async methods; using Assert(..) for now.) + Contract.Assert( array != null ); + Contract.Assert( offset >= 0 ); + Contract.Assert( count >= 0 ); + Contract.Assert( array.Length - offset >= count ); + Contract.Assert( _stream != null ); + Contract.Assert( _stream.CanWrite ); + Contract.Assert( _bufferSize > 0 ); + Contract.Assert( semaphoreLockTask != null ); + + // See the LARGE COMMENT in Write(..) for the explanation of the write buffer algorithm. + + await semaphoreLockTask.ConfigureAwait( false ); + try + { + + // The buffer might have been changed by another async task while we were waiting on the semaphore. + // However, note that if we recalculate the sync completion condition to TRUE, then useBuffer will also be TRUE. + + if ( _writePos == 0 ) + ClearReadBufferBeforeWrite(); + + Int32 totalUserBytes; + bool useBuffer; + checked + { // We do not expect buffer sizes big enough for an overflow, but if it happens, lets fail early: + totalUserBytes = _writePos + count; + useBuffer = ( totalUserBytes + count < ( _bufferSize + _bufferSize ) ); + } + + if ( useBuffer ) + { + + WriteToBuffer( array, ref offset, ref count ); + + if ( _writePos < _bufferSize ) + { + + Contract.Assert( count == 0 ); + return; + } + + Contract.Assert( count >= 0 ); + Contract.Assert( _writePos == _bufferSize ); + Contract.Assert( _buffer != null ); + + await _stream.WriteAsync( _buffer, 0, _writePos, cancellationToken ).ConfigureAwait( false ); + _writePos = 0; + + WriteToBuffer( array, ref offset, ref count ); + + Contract.Assert( count == 0 ); + Contract.Assert( _writePos < _bufferSize ); + + } + else + { // if (!useBuffer) + + // Write out the buffer if necessary. + if ( _writePos > 0 ) + { + + Contract.Assert( _buffer != null ); + Contract.Assert( totalUserBytes >= _bufferSize ); + + // Try avoiding extra write to underlying stream by combining previously buffered data with current user data: + if ( totalUserBytes <= ( _bufferSize + _bufferSize ) && totalUserBytes <= MaxShadowBufferSize ) + { + + EnsureShadowBufferAllocated(); + Buffer.BlockCopy( array, offset, _buffer, _writePos, count ); + await _stream.WriteAsync( _buffer, 0, totalUserBytes, cancellationToken ).ConfigureAwait( false ); + _writePos = 0; + return; + } + + await _stream.WriteAsync( _buffer, 0, _writePos, cancellationToken ).ConfigureAwait( false ); + _writePos = 0; + } + + // Write out user data. + await _stream.WriteAsync( array, offset, count, cancellationToken ).ConfigureAwait( false ); + } + } + finally + { + SemaphoreSlim sem = this.EnsureAsyncActiveSemaphoreInitialized(); + sem.Release(); + } + } + + + public override void WriteByte( Byte value ) + { + + EnsureNotClosed(); + + if ( _writePos == 0 ) + { + + EnsureCanWrite(); + ClearReadBufferBeforeWrite(); + EnsureBufferAllocated(); + } + + // We should not be flushing here, but only writing to the underlying stream, but previous version flushed, so we keep this. + if ( _writePos >= _bufferSize - 1 ) + FlushWrite(); + + _buffer[ _writePos++ ] = value; + + Contract.Assert( _writePos < _bufferSize ); + } + + + public override Int64 Seek( Int64 offset, SeekOrigin origin ) + { + + EnsureNotClosed(); + EnsureCanSeek(); + + // If we have bytes in the WRITE buffer, flush them out, seek and be done. + if ( _writePos > 0 ) + { + + // We should be only writing the buffer and not flushing, + // but the previous version did flush and we stick to it for back-compat reasons. + FlushWrite(); + return _stream.Seek( offset, origin ); + } + + // The buffer is either empty or we have a buffered READ. + + if ( _readLen - _readPos > 0 && origin == SeekOrigin.Current ) + { + + // If we have bytes in the READ buffer, adjust the seek offset to account for the resulting difference + // between this stream's position and the underlying stream's position. + offset -= ( _readLen - _readPos ); + } + + Int64 oldPos = Position; + Contract.Assert( oldPos == _stream.Position + ( _readPos - _readLen ) ); + + Int64 newPos = _stream.Seek(offset, origin); + + // If the seek destination is still within the data currently in the buffer, we want to keep the buffer data and continue using it. + // Otherwise we will throw away the buffer. This can only happen on READ, as we flushed WRITE data above. + + // The offset of the new/updated seek pointer within _buffer: + _readPos = ( Int32 )( newPos - ( oldPos - _readPos ) ); + + // If the offset of the updated seek pointer in the buffer is still legal, then we can keep using the buffer: + if ( 0 <= _readPos && _readPos < _readLen ) + { + + // Adjust the seek pointer of the underlying stream to reflect the amount of useful bytes in the read buffer: + _stream.Seek( _readLen - _readPos, SeekOrigin.Current ); + + } + else + { // The offset of the updated seek pointer is not a legal offset. Loose the buffer. + + _readPos = _readLen = 0; + } + + Contract.Assert( newPos == Position, "newPos (=" + newPos + ") == Position (=" + Position + ")" ); + return newPos; + } + + + public override void SetLength( Int64 value ) + { + + if ( value < 0 ) + throw new ArgumentOutOfRangeException( "value", "The size cannot be negative." ); + Contract.EndContractBlock(); + + EnsureNotClosed(); + EnsureCanSeek(); + EnsureCanWrite(); + + Flush(); + _stream.SetLength( value ); + } + + // From https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/IO/Stream.cs ef1e2ab328087c61a6878c1e84f4fc5d710aebce + + // To implement Async IO operations on streams that don't support async IO + + private SemaphoreSlim _asyncActiveSemaphore; + + internal SemaphoreSlim EnsureAsyncActiveSemaphoreInitialized() + { + // Lazily-initialize _asyncActiveSemaphore. As we're never accessing the SemaphoreSlim's + // WaitHandle, we don't need to worry about Disposing it. + return LazyInitializer.EnsureInitialized( ref _asyncActiveSemaphore, () => new SemaphoreSlim( 1, 1 ) ); + } + + // End From Stream.cs + + // From https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/IO/__Error.cs ef1e2ab328087c61a6878c1e84f4fc5d710aebce + private static class __Error + { + internal static void StreamIsClosed() + { + throw new ObjectDisposedException( null, "This stream is already closed." ); + } + + internal static void ReadNotSupported() + { + throw new NotSupportedException( "Cannot read on the current stream." ); + } + internal static void WriteNotSupported() + { + throw new NotSupportedException( "Cannot write on the current stream." ); + } + + internal static void SeekNotSupported() + { + throw new NotSupportedException( "Cannot seek on the current stream." ); + } + } + + // From + private static class _Task + { + /// Gets a task that's already been completed successfully. + /// May not always return the same instance. + public static Task CompletedTask + { + get + { + var tcs = new TaskCompletionSource(); + tcs.SetResult( null ); + return tcs.Task; + } + } + + // ReSharper disable once UnusedParameter.Local + public static Task FromCancellation(CancellationToken cancellationToken) + { + var tcs = new TaskCompletionSource(); + tcs.SetCanceled(); + return tcs.Task; + } + + public static Task FromException(Exception ex) + { + return FromException( ex ); + } + + public static Task FromException( Exception ex ) + { + var tcs = new TaskCompletionSource(); + tcs.SetException( ex ); + return tcs.Task; + } + } + + } // class BufferedStream +} // namespace diff --git a/src/MsgPack.Core/MPContract.cs b/src/MsgPack.Core/MPContract.cs new file mode 100644 index 000000000..bffdff1b7 --- /dev/null +++ b/src/MsgPack.Core/MPContract.cs @@ -0,0 +1,72 @@ +#region -- License Terms -- +// MessagePack for CLI +// +// Copyright (C) 2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +using System; +using System.Diagnostics; + +namespace MsgPack +{ + /// + /// System.Contract alternative working on Xamarin. + /// + internal static class MPContract + { + [Conditional( "DEBUG" )] + public static void Assert( bool condition ) + { + if ( !condition ) + { + throw new Exception( "Assertion error." ); + } + } + + [Conditional( "DEBUG" )] + public static void Assert( bool condition, string userMessage ) + { + if ( !condition ) + { + throw new Exception( "Assertion error: " + userMessage ); + } + } + + [Conditional("__NEVER")] + public static void EndContractBlock() + { + // nop + } + + [Conditional( "__NEVER" )] + public static void Requires( bool expression ) + { + // nop + } + + [Conditional( "__NEVER" )] + public static void Ensures( bool expression ) + { + // nop + } + + public static T Result() + { + return default( T ); + } + } + + internal sealed class PureAttribute : Attribute { } +} \ No newline at end of file diff --git a/src/MsgPack.Core/MsgPack.Core.csproj b/src/MsgPack.Core/MsgPack.Core.csproj new file mode 100644 index 000000000..87bd941c6 --- /dev/null +++ b/src/MsgPack.Core/MsgPack.Core.csproj @@ -0,0 +1,269 @@ + + + + + 14.0 + Debug + AnyCPU + {08D9A49D-736E-4CAD-919E-72CA8C1D4A9F} + Library + Properties + MsgPack + MsgPack.Core + ja-JP + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;FEATURE_TAP;NETSTANDARD1_1 + prompt + 4 + bin\Debug\MsgPack.Core.XML + + + pdbonly + true + bin\Release\ + TRACE;FEATURE_TAP;NETSTANDARD1_1 + prompt + 4 + bin\Release\MsgPack.Core.XML + + + true + + + ..\MsgPack.snk + + + + + MsgPack.snk + + + + + + Properties\CommonAssemblyInfo.cs + + + AsyncReadResult.cs + + + AsyncReadResult`1.cs + + + BigEndianBinary.cs + + + Binary.cs + + + BufferManager.cs + + + CollectionDebuggerProxy`1.cs + + + CollectionOperation.cs + + + DictionaryDebuggerProxy`2.cs + + + Float32Bits.cs + + + Float64Bits.cs + + + GlobalSuppressions.cs + + + IAsyncPackable.cs + + + IAsyncUnpackable.cs + + + InvalidMessagePackStreamException.cs + + + IPackable.cs + + + ItemsUnpacker.cs + + + ItemsUnpacker.Read.cs + + + ItemsUnpacker.Skipping.cs + + + ItemsUnpacker.Unpacking.cs + + + IUnpackable.cs + + + KnownExtTypeCode.cs + + + KnownExtTypeName.cs + + + MessageNotSupportedException.cs + + + MessagePackCode.cs + + + MessagePackConvert.cs + + + MessagePackExtendedTypeObject.cs + + + MessagePackObject.cs + + + MessagePackObject.Utilities.cs + + + MessagePackObjectDictionary.cs + + + MessagePackObjectDictionary.Enumerator.cs + + + MessagePackObjectDictionary.KeySet.cs + + + MessagePackObjectDictionary.KeySet.Enumerator.cs + + + MessagePackObjectDictionary.ValueCollection.cs + + + MessagePackObjectDictionary.ValueCollection.Enumerator.cs + + + MessagePackObjectEqualityComparer.cs + + + MessagePackString.cs + + + MessageTypeException.cs + + + Packer.cs + + + Packer.Nullable.cs + + + Packer.Packing.cs + + + PackerCompatibilityOptions.cs + + + PackerUnpackerStreamOptions.cs + + + PackingOptions.cs + + + PreserveAttribute.cs + + + ReflectionAbstractions.cs + + + SetOperation.cs + + + StreamPacker.cs + + + StringEscape.cs + + + SubtreeUnpacker.cs + + + SubtreeUnpacker.Unpacking.cs + + + TupleItems.cs + + + UnassignedMessageTypeException.cs + + + Unpacker.cs + + + Unpacker.Unpacking.cs + + + UnpackException.cs + + + Unpacking.cs + + + Unpacking.Numerics.cs + + + Unpacking.Others.cs + + + Unpacking.Streaming.cs + + + Unpacking.String.cs + + + UnpackingMode.cs + + + UnpackingResult.cs + + + UnpackingStream.cs + + + UnpackingStreamReader.cs + + + UnsafeNativeMethods.cs + + + + + + + + + remarks.xml + + + + + \ No newline at end of file diff --git a/src/MsgPack.Core/NetStandardCompatibility.cs b/src/MsgPack.Core/NetStandardCompatibility.cs new file mode 100644 index 000000000..48c752f16 --- /dev/null +++ b/src/MsgPack.Core/NetStandardCompatibility.cs @@ -0,0 +1,88 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; + +namespace MsgPack +{ + // ReSharper disable once InconsistentNaming + internal static class NetStandardCompatibility + { + private static readonly Dictionary _typeCodeTable = + new Dictionary() + { + { typeof( Boolean ), TypeCode.Boolean }, + { typeof( Char ), TypeCode.Char }, + { typeof( Byte ), TypeCode.Byte }, + { typeof( Int16 ), TypeCode.Int16 }, + { typeof( Int32 ), TypeCode.Int32 }, + { typeof( Int64 ), TypeCode.Int64 }, + { typeof( SByte ), TypeCode.SByte }, + { typeof( UInt16 ), TypeCode.UInt16 }, + { typeof( UInt32 ), TypeCode.UInt32 }, + { typeof( UInt64 ), TypeCode.UInt64 }, + { typeof( Single ), TypeCode.Single }, + { typeof( Double ), TypeCode.Double }, + { typeof( DateTime ), TypeCode.DateTime }, + { typeof( Decimal ), TypeCode.Decimal }, + { typeof( String ), TypeCode.String }, + }; + + public static TypeCode GetTypeCode( Type type ) + { + if ( type == null ) + { + return TypeCode.Empty; + } + + TypeCode result; + if ( !_typeCodeTable.TryGetValue( type, out result ) ) + { + result = TypeCode.Object; + } + + return result; + } + } + + internal enum TypeCode + { + Byte, + Int16, + Int32, + Int64, + SByte, + UInt16, + UInt32, + UInt64, + Single, + Double, + Char, + Boolean, + String, + DateTime, + Decimal, + Empty, + // ReSharper disable once InconsistentNaming + DBNull, // Never used + Object + } +} diff --git a/src/MsgPack.Core/Properties/AssemblyInfo.cs b/src/MsgPack.Core/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..0a9a99106 --- /dev/null +++ b/src/MsgPack.Core/Properties/AssemblyInfo.cs @@ -0,0 +1,43 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: AssemblyTitle( "MessagePack for CLI(.NET/Mono)" )] +[assembly: AssemblyDescription( "MessagePack for CLI(.NET/Mono) core library." )] + +[assembly: AssemblyFileVersion( "0.7.2259.1047" )] + +[assembly: AllowPartiallyTrustedCallers] + +[assembly: InternalsVisibleTo( "MsgPack.Serialization, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.Core, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.CSharp, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.VisualBasic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] + +#if DEBUG || PERFORMANCE_TEST +[assembly: InternalsVisibleTo( "MsgPack.UnitTest, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.CodeTree, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.BclExtensions, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +#endif + + diff --git a/src/MsgPack.Core/project.json b/src/MsgPack.Core/project.json new file mode 100644 index 000000000..a10cdc415 --- /dev/null +++ b/src/MsgPack.Core/project.json @@ -0,0 +1,25 @@ +{ + "supports": {}, + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tools": "4.0.1", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Linq": "4.1.0", + "System.Reflection": "4.1.0", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.Serialization.Primitives": "4.1.1", + "System.Text.Encoding": "4.0.11", + "System.Text.Encoding.Extensions": "4.0.11", + "System.Threading": "4.0.11" + }, + "frameworks": { + "netstandard1.1": {} + } +} \ No newline at end of file diff --git a/src/MsgPack.CoreClr/project.json b/src/MsgPack.CoreClr/project.json index 462e8bebb..2e06da42d 100644 --- a/src/MsgPack.CoreClr/project.json +++ b/src/MsgPack.CoreClr/project.json @@ -22,13 +22,24 @@ "../MsgPack/**/*.cs", "../CommonAssemblyInfo.cs", "../netstandard/BufferedStream.cs", + "../netstandard/MPContract.cs", "../netstandard/NetStandardCompatibility.cs", "./**/*.cs" ], "exclude": [ "../MsgPack/Properties/AssemblyInfo.cs", - "../MsgPack/Serialization/AbstractSerializers/**/*.*", + "../MsgPack/Serialization/AbstractSerializers/A*.cs", + "../MsgPack/Serialization/AbstractSerializers/C*.cs", + "../MsgPack/Serialization/AbstractSerializers/D*.cs", + "../MsgPack/Serialization/AbstractSerializers/E*.cs", + "../MsgPack/Serialization/AbstractSerializers/F*.cs", + "../MsgPack/Serialization/AbstractSerializers/ICodeConstruct.cs", + "../MsgPack/Serialization/AbstractSerializers/ISerializerCode*.cs", + "../MsgPack/Serialization/AbstractSerializers/M*.cs", + "../MsgPack/Serialization/AbstractSerializers/S*.cs", + "../MsgPack/Serialization/AbstractSerializers/T*.cs", "../MsgPack/Serialization/CodeDomSerializers/**/*.*", + "../MsgPack/Serialization/CodeGenerators/SerializerAssemblyGenerationLogic.cs", "../MsgPack/Serialization/DefaultSerializers/System_Security_Cryptography_HashAlgorithmNameMessagePackSerializer.cs", "../MsgPack/Serialization/EmittingSerializers/**/*.*", "../MsgPack/Serialization/Metadata/_CultureInfo.cs", diff --git a/src/MsgPack.Net35/MsgPack.Net35.csproj b/src/MsgPack.Net35/MsgPack.Net35.csproj index f095be7c0..c4a3ccf7d 100644 --- a/src/MsgPack.Net35/MsgPack.Net35.csproj +++ b/src/MsgPack.Net35/MsgPack.Net35.csproj @@ -23,6 +23,7 @@ 4 true bin\Debug\MsgPack.xml + 1574 pdbonly @@ -33,6 +34,7 @@ 4 true ..\..\bin\net35-client\MsgPack.XML + 1574 true @@ -51,6 +53,7 @@ prompt AllRules.ruleset true + 1574 @@ -294,6 +297,21 @@ Serialization\CodeDomSerializers\VariableCodeDomConstruct.cs + + Serialization\CodeGenerators\SerializerAssemblyGenerationLogic.cs + + + Serialization\CodeGenerators\SerializerCodeGeneratorFactory.cs + + + Serialization\CodeGenerators\SerializerCodesGenerationLogic.cs + + + Serialization\CodeGenerators\SerializerCodesGenerationLogicFactory.cs + + + Serialization\CodeGenerators\SerializerGenerationLogic`1.cs + Serialization\CollectionDetailedKind.cs @@ -510,6 +528,9 @@ Serialization\DefaultSerializers\UnixEpocFileTimeMessagePackSerializer.cs + + Serialization\DependentAssemblyManager.cs + Serialization\DictionaryKeyTransformers.cs diff --git a/src/MsgPack.Net45/MsgPack.Net45.csproj b/src/MsgPack.Net45/MsgPack.Net45.csproj index 675aa5dfd..63da03c73 100644 --- a/src/MsgPack.Net45/MsgPack.Net45.csproj +++ b/src/MsgPack.Net45/MsgPack.Net45.csproj @@ -18,7 +18,7 @@ full false bin\Debug\ - TRACE;DEBUG;FEATURE_TAP;NETFX_45 + TRACE;DEBUG;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;NETFX_45 prompt 4 bin\Debug\MsgPack.XML @@ -27,7 +27,7 @@ pdbonly true ..\..\bin\net45\ - TRACE;FEATURE_TAP;NETFX_45 + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;NETFX_45 prompt 4 ..\..\bin\net45\MsgPack.XML @@ -40,7 +40,7 @@ bin\CodeAnalysis\ - TRACE;FEATURE_TAP;NETFX_45;CODE_ANALYSIS + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;NETFX_45;CODE_ANALYSIS true pdbonly @@ -295,6 +295,21 @@ Serialization\CodeDomSerializers\VariableCodeDomConstruct.cs + + Serialization\CodeGenerators\SerializerAssemblyGenerationLogic.cs + + + Serialization\CodeGenerators\SerializerCodeGeneratorFactory.cs + + + Serialization\CodeGenerators\SerializerCodesGenerationLogic.cs + + + Serialization\CodeGenerators\SerializerCodesGenerationLogicFactory.cs + + + Serialization\CodeGenerators\SerializerGenerationLogic`1.cs + Serialization\CollectionDetailedKind.cs @@ -541,6 +556,9 @@ Serialization\DefaultSerializers\UnixEpocFileTimeMessagePackSerializer.cs + + Serialization\DependentAssemblyManager.cs + Serialization\DictionaryKeyTransformers.cs diff --git a/src/MsgPack.Serialization/MsgPack.Serialization.csproj b/src/MsgPack.Serialization/MsgPack.Serialization.csproj new file mode 100644 index 000000000..3a2860a35 --- /dev/null +++ b/src/MsgPack.Serialization/MsgPack.Serialization.csproj @@ -0,0 +1,792 @@ + + + + + 14.0 + Debug + AnyCPU + {153CED68-9905-4B1F-9790-F463840895E2} + Library + Properties + MsgPack + MsgPack.Serialization + ja-JP + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;FEATURE_TAP;FEATURE_CONCURRENT;NETSTANDARD1_1 + prompt + 4 + bin\Debug\MsgPack.Serialization.XML + + + pdbonly + true + bin\Release\ + TRACE;FEATURE_TAP;FEATURE_CONCURRENT;NETSTANDARD1_1 + prompt + 4 + bin\Release\MsgPack.Serialization.XML + + + true + + + ..\MsgPack.snk + + + + + MsgPack.snk + + + + + + Properties\CommonAssemblyInfo.cs + + + PackerUnpackerExtensions.cs + + + Serialization\AbstractSerializers\ActionType.cs + + + Serialization\AbstractSerializers\CachedDelegateInfo.cs + + + Serialization\AbstractSerializers\ConstructorDefinition.cs + + + Serialization\AbstractSerializers\DynamicUnpackingContext.cs + + + Serialization\AbstractSerializers\EnumSerializerMethod.cs + + + Serialization\AbstractSerializers\FieldDefinition.cs + + + Serialization\AbstractSerializers\FieldName.cs + + + Serialization\AbstractSerializers\ICodeConstruct.cs + + + Serialization\AbstractSerializers\ISerializerBuilder.cs + + + Serialization\AbstractSerializers\MethodDefinition.cs + + + Serialization\AbstractSerializers\MethodName.cs + + + Serialization\AbstractSerializers\MethodNamePrefix.cs + + + Serialization\AbstractSerializers\SerializerBuilderHelper.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.Collection.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.CommonConstructs.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.Enum.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.Nullable.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.Object.cs + + + Serialization\AbstractSerializers\SerializerBuilder`2.Tuple.cs + + + Serialization\AbstractSerializers\SerializerFieldKey.cs + + + Serialization\AbstractSerializers\SerializerGenerationContext.cs + + + Serialization\AbstractSerializers\SerializerSpecification.cs + + + Serialization\AbstractSerializers\TypeDefinition.cs + + + Serialization\CollectionDetailedKind.cs + + + Serialization\CollectionKind.cs + + + Serialization\CollectionSerializers\CollectionMessagePackSerializerBase`2.cs + + + Serialization\CollectionSerializers\CollectionMessagePackSerializer`2.cs + + + Serialization\CollectionSerializers\CollectionSerializerHelpers.cs + + + Serialization\CollectionSerializers\DictionaryMessagePackSerializerBase`3.cs + + + Serialization\CollectionSerializers\DictionaryMessagePackSerializer`3.cs + + + Serialization\CollectionSerializers\EnumerableMessagePackSerializerBase`2.cs + + + Serialization\CollectionSerializers\EnumerableMessagePackSerializer`2.cs + + + Serialization\CollectionSerializers\ICollectionInstanceFactory.cs + + + Serialization\CollectionSerializers\NonGenericCollectionMessagePackSerializer`1.cs + + + Serialization\CollectionSerializers\NonGenericDictionaryMessagePackSerializer`1.cs + + + Serialization\CollectionSerializers\NonGenericEnumerableMessagePackSerializerBase`1.cs + + + Serialization\CollectionSerializers\NonGenericEnumerableMessagePackSerializer`1.cs + + + Serialization\CollectionSerializers\NonGenericListMessagePackSerializer`1.cs + + + Serialization\CollectionSerializers\ReadOnlyCollectionMessagePackSerializer`2.cs + + + Serialization\CollectionSerializers\ReadOnlyDictionaryMessagePackSerializer`3.cs + + + Serialization\CollectionTraitOptions.cs + + + Serialization\CollectionTraits.cs + + + Serialization\DataMemberContract.cs + + + Serialization\DateTimeConversionMethod.cs + + + Serialization\DateTimeMemberConversionMethod.cs + + + Serialization\DateTimeMessagePackSerializerHelpers.cs + + + Serialization\DefaultConcreteTypeRepository.cs + + + Serialization\DefaultSerializerNameResolver.cs + + + Serialization\DefaultSerializers\AbstractCollectionMessagePackSerializer`2.cs + + + Serialization\DefaultSerializers\AbstractCollectionSerializerHelper.cs + + + Serialization\DefaultSerializers\AbstractDictionaryMessagePackSerializer`3.cs + + + Serialization\DefaultSerializers\AbstractEnumerableMessagePackSerializer`2.cs + + + Serialization\DefaultSerializers\AbstractNonGenericCollectionMessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\AbstractNonGenericDictionaryMessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\AbstractNonGenericEnumerableMessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\AbstractNonGenericListMessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\AbstractReadOnlyCollectionMessagePackSerializer`2.cs + + + Serialization\DefaultSerializers\AbstractReadOnlyDictionaryMessagePackSerializer`3.cs + + + Serialization\DefaultSerializers\ArraySegmentMessageSerializer.cs + + + Serialization\DefaultSerializers\ArraySerializer.cs + + + Serialization\DefaultSerializers\ArraySerializer.Primitives.cs + + + Serialization\DefaultSerializers\ArraySerializer`1.cs + + + Serialization\DefaultSerializers\DateTimeMessagePackSerializerProvider.cs + + + Serialization\DefaultSerializers\DateTimeOffsetMessagePackSerializer.cs + + + Serialization\DefaultSerializers\DateTimeOffsetMessagePackSerializerProvider.cs + + + Serialization\DefaultSerializers\FileTimeMessagePackSerializerProvider.cs + + + Serialization\DefaultSerializers\FSharpCollectionSerializer`2.cs + + + Serialization\DefaultSerializers\FSharpMapSerializer`3.cs + + + Serialization\DefaultSerializers\GenericSerializer.cs + + + Serialization\DefaultSerializers\ImmutableCollectionSerializer`2.cs + + + Serialization\DefaultSerializers\ImmutableDictionarySerializer`3.cs + + + Serialization\DefaultSerializers\ImmutableStackSerializer`2.cs + + + Serialization\DefaultSerializers\InternalDateTimeExtensions.cs + + + Serialization\DefaultSerializers\MessagePackObjectExtensions.cs + + + Serialization\DefaultSerializers\MsgPack_MessagePackExtendedTypeObjectMessagePackSerializer.cs + + + Serialization\DefaultSerializers\MsgPack_MessagePackObjectDictionaryMessagePackSerializer.cs + + + Serialization\DefaultSerializers\MsgPack_MessagePackObjectMessagePackSerializer.cs + + + Serialization\DefaultSerializers\MultidimensionalArraySerializer`1.cs + + + Serialization\DefaultSerializers\NativeDateTimeMessagePackSerializer.cs + + + Serialization\DefaultSerializers\NativeFileTimeMessagePackSerializer.cs + + + Serialization\DefaultSerializers\NullableMessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\System_ArraySegment_1MessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\System_ByteArrayMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_CharArrayMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_Dictionary_2MessagePackSerializer`2.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_KeyValuePair_2MessagePackSerializer`2.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_ListOfMessagePackObjectMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_List_1MessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_Queue_1MessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\System_Collections_Generic_Stack_1MessagePackSerializer`1.cs + + + Serialization\DefaultSerializers\System_Globalization_CultureInfoMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_ObjectMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_StringMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_Text_StringBuilderMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_UriMessagePackSerializer.cs + + + Serialization\DefaultSerializers\System_VersionMessagePackSerializer.cs + + + Serialization\DefaultSerializers\UnixEpocDateTimeMessagePackSerializer.cs + + + Serialization\DefaultSerializers\UnixEpocFileTimeMessagePackSerializer.cs + + + Serialization\DependentAssemblyManager.cs + + + Serialization\DictionaryKeyTransformers.cs + + + Serialization\DictionarySerlaizationOptions.cs + + + Serialization\EmitterFlavor.cs + + + Serialization\EmittingSerializers\AndConditionILConstruct.cs + + + Serialization\EmittingSerializers\AssemblyBuilderEmittingContext.cs + + + Serialization\EmittingSerializers\AssemblyBuilderSerializerBuilder.cs + + + Serialization\EmittingSerializers\BinaryOperatorILConstruct.cs + + + Serialization\EmittingSerializers\ConditionalILConstruct.cs + + + Serialization\EmittingSerializers\ContextfulILConstruct.cs + + + Serialization\EmittingSerializers\ILConstruct.cs + + + Serialization\EmittingSerializers\ILMethodConctext.cs + + + Serialization\EmittingSerializers\InvocationILConsruct.cs + + + Serialization\EmittingSerializers\LoadFieldILConstruct.cs + + + Serialization\EmittingSerializers\SequenceILConstruct.cs + + + Serialization\EmittingSerializers\SerializationMethodGeneratorManager.cs + + + Serialization\EmittingSerializers\SerializerEmitter.cs + + + Serialization\EmittingSerializers\SerializerEmitter.enum.cs + + + Serialization\EmittingSerializers\SerializerEmitter.object.cs + + + Serialization\EmittingSerializers\SinglelStepILConstruct.cs + + + Serialization\EmittingSerializers\StatementExpressionILConstruct.cs + + + Serialization\EmittingSerializers\StoreFieldILConstruct.cs + + + Serialization\EmittingSerializers\StoreVariableILConstruct.cs + + + Serialization\EmittingSerializers\UnaryOperatorILConstruct.cs + + + Serialization\EmittingSerializers\VariableILConstruct.cs + + + Serialization\EnumMemberSerializationMethod.cs + + + Serialization\EnumMessagePackSerializerHelpers.cs + + + Serialization\EnumMessagePackSerializerProvider.cs + + + Serialization\EnumMessagePackSerializer`1.cs + + + Serialization\EnumNameTransformers.cs + + + Serialization\EnumSerializationMethod.cs + + + Serialization\EnumSerializationOptions.cs + + + Serialization\ExtTypeCodeMapping.cs + + + Serialization\FromExpression.cs + + + Serialization\FromExpression.ToMethod.cs + + + Serialization\ICustomizableEnumSerializer.cs + + + Serialization\IdentifierUtility.cs + + + Serialization\IMessagePackSerializer.cs + + + Serialization\IMessagePackSingleObjectSerializer.cs + + + Serialization\INilImplicationHandlerOnUnpackedParameter.cs + + + Serialization\INilImplicationHandlerParameter.cs + + + Serialization\ISerializerGeneratorConfiguration.cs + + + Serialization\KeyNameTransformers.cs + + + Serialization\LazyDelegatingMessagePackSerializer`1.cs + + + Serialization\MessagePackDateTimeMemberAttribute.cs + + + Serialization\MessagePackDeserializationConstructorAttribute.cs + + + Serialization\MessagePackEnumAttribute.cs + + + Serialization\MessagePackEnumMemberAttribute.cs + + + Serialization\MessagePackIgnoreAttribute.cs + + + Serialization\MessagePackKnownTypeAttributes.cs + + + Serialization\MessagePackMemberAttribute.cs + + + Serialization\MessagePackRuntimeTypeAttributes.cs + + + Serialization\MessagePackSerializer.cs + + + Serialization\MessagePackSerializer.Factories.cs + + + Serialization\MessagePackSerializerExtensions.cs + + + Serialization\MessagePackSerializerProvider.cs + + + Serialization\MessagePackSerializer`1.cs + + + Serialization\Metadata\_CultureInfo.cs + + + Serialization\Metadata\_DateTimeMessagePackSerializerHelpers.cs + + + Serialization\Metadata\_Decimal.cs + + + Serialization\Metadata\_DictionaryEntry.cs + + + Serialization\Metadata\_DynamicUnpackingContext.cs + + + Serialization\Metadata\_EnumMessagePackSerializerHelpers.cs + + + Serialization\Metadata\_FieldInfo.cs + + + Serialization\Metadata\_IDictionaryEnumerator.cs + + + Serialization\Metadata\_IDisposable.cs + + + Serialization\Metadata\_IEnumreator.cs + + + Serialization\Metadata\_MessagePackObject.cs + + + Serialization\Metadata\_MessagePackSerializer.cs + + + Serialization\Metadata\_MethodBase.cs + + + Serialization\Metadata\_Object.cs + + + Serialization\Metadata\_Packer.cs + + + Serialization\Metadata\_SerializationContext.cs + + + Serialization\Metadata\_String.cs + + + Serialization\Metadata\_Unpacker.cs + + + Serialization\Metadata\_UnpackHelpers.cs + + + Serialization\Metadata\_UnpackHelpers.direct.cs + + + Serialization\NilImplication.cs + + + Serialization\NilImplicationHandler`4.cs + + + Serialization\NullTextWriter.cs + + + Serialization\PackHelperParameters.cs + + + Serialization\PackHelpers.cs + + + Serialization\PolymorphicTypeVerificationContext.cs + + + Serialization\Polymorphism\IPolymorphicDeserializer.cs + + + Serialization\Polymorphism\IPolymorphicHelperAttributes.cs + + + Serialization\Polymorphism\KnownTypePolymorphicMessagePackSerializer`1.cs + + + Serialization\Polymorphism\PolymorphicSerializerProvider`1.cs + + + Serialization\Polymorphism\RuntimeTypeVerifier.cs + + + Serialization\Polymorphism\TypeEmbedingPolymorphicMessagePackSerializer`1.cs + + + Serialization\Polymorphism\TypeInfoEncoder.cs + + + Serialization\Polymorphism\TypeInfoEncoding.cs + + + Serialization\PolymorphismSchema.Constructors.cs + + + Serialization\PolymorphismSchema.cs + + + Serialization\PolymorphismSchema.Internals.cs + + + Serialization\PolymorphismSchemaChildrenType.cs + + + Serialization\PolymorphismTarget.cs + + + Serialization\PolymorphismType.cs + + + Serialization\ReflectionExtensions.cs + + + Serialization\ReflectionHelpers.cs + + + Serialization\ReflectionSerializers\ReflectionCollectionMessagePackSerializer`2.cs + + + Serialization\ReflectionSerializers\ReflectionDictionaryMessagePackSerializer`3.cs + + + Serialization\ReflectionSerializers\ReflectionEnumerableMessagePackSerializer`2.cs + + + Serialization\ReflectionSerializers\ReflectionEnumMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionNilImplicationHandler.cs + + + Serialization\ReflectionSerializers\ReflectionNonGeenricCollectionMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionNonGeenricEnumerableMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionNonGenericDictionaryMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionNonGenericListMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionObjectMessagePackSerializer`1.cs + + + Serialization\ReflectionSerializers\ReflectionSerializerHelper.cs + + + Serialization\ReflectionSerializers\ReflectionSerializerNilImplicationHandlerOnUnpackedParameter.cs + + + Serialization\ReflectionSerializers\ReflectionSerializerNilImplicationHandlerParameter.cs + + + Serialization\ReflectionSerializers\ReflectionTupleMessagePackSerializer`1.cs + + + Serialization\Reflection\GenericTypeExtensions.cs + + + Serialization\Reflection\ReflectionExtensions.cs + + + Serialization\Reflection\TracingILGenerator.conveniences.cs + + + Serialization\Reflection\TracingILGenerator.cs + + + Serialization\Reflection\TracingILGenerator.emits.cs + + + Serialization\ResolveSerializerEventArgs.cs + + + Serialization\SerializationCompatibilityOptions.cs + + + Serialization\SerializationContext.cs + + + Serialization\SerializationContext.ExtTypeCodes.cs + + + Serialization\SerializationExceptions.cs + + + Serialization\SerializationMethod.cs + + + Serialization\SerializationMethodGeneratorOption.cs + + + Serialization\SerializationTarget.cs + + + Serialization\SerializerCapabilities.cs + + + Serialization\SerializerDebugging.cs + + + Serialization\SerializerOptions.cs + + + Serialization\SerializerRegistrationOptions.cs + + + Serialization\SerializerRepository.cs + + + Serialization\SerializerTypeKeyRepository.cs + + + Serialization\SerializingMember.cs + + + Serialization\Tracer.cs + + + Serialization\TypeKeyRepository.cs + + + Serialization\UnpackHelperParameters.cs + + + Serialization\UnpackHelpers.cs + + + Serialization\UnpackHelpers.direct.cs + + + Serialization\UnpackHelpers.facade.cs + + + + + + + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + + + \ No newline at end of file diff --git a/src/MsgPack.Serialization/Properties/AssemblyInfo.cs b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..7c4750dc0 --- /dev/null +++ b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs @@ -0,0 +1,42 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: AssemblyTitle( "MessagePack for CLI(.NET/Mono)" )] +[assembly: AssemblyDescription( "MessagePack for CLI(.NET/Mono) serialization library." )] + +[assembly: AssemblyFileVersion( "0.7.2259.1047" )] + +[assembly: AllowPartiallyTrustedCallers] + +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.Core, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.CSharp, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.CodeGeneration.VisualBasic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] + +#if DEBUG || PERFORMANCE_TEST +[assembly: InternalsVisibleTo( "MsgPack.UnitTest, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.CodeTree, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +[assembly: InternalsVisibleTo( "MsgPack.UnitTest.BclExtensions, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a967de8de9d45380b93a6aa56f64fc2cb2d3c9d4b400e00de01f31ba9e15cf5ca95926dbf8760cce413eabd711e23df0c133193a570da8a3bb1bdc00ef170fccb2bc033266fa5346442c9cf0b071133d5b484845eab17095652aeafeeb71193506b8294d9c8c91e3fd01cc50bdbc2d0eb78dd655bb8cd0bd3cdbbcb192549cb4" )] +#endif + + diff --git a/src/MsgPack.Serialization/Serialization/DefaultSerializers/DefaultSerializers.cs b/src/MsgPack.Serialization/Serialization/DefaultSerializers/DefaultSerializers.cs new file mode 100644 index 000000000..dda6e7c3e --- /dev/null +++ b/src/MsgPack.Serialization/Serialization/DefaultSerializers/DefaultSerializers.cs @@ -0,0 +1,982 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +using System; +using System.Globalization; +using System.Runtime.Serialization; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP + +#warning TODO: back to T4 + +namespace MsgPack.Serialization.DefaultSerializers +{ + // This file generated from DefaultSerializers.tt T4Template. + // Do not modify this file. Edit DefaultSerializers.tt instead. + + // ReSharper disable InconsistentNaming + // ReSharper disable RedundantNameQualifier + // ReSharper disable RedundantCast + + internal sealed class System_BooleanMessagePackSerializer : MessagePackSerializer< System.Boolean > + { + public System_BooleanMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Boolean value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Boolean UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsBoolean(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Boolean ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Boolean value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_ByteMessagePackSerializer : MessagePackSerializer< System.Byte > + { + public System_ByteMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Byte value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Byte UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsByte(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Byte ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Byte value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_CharMessagePackSerializer : MessagePackSerializer< System.Char > + { + public System_CharMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Char value ) + { + packer.Pack( ( System.UInt16 )value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Char UnpackFromCore( Unpacker unpacker ) + { + try + { + return ( System.Char ) unpacker.LastReadData.AsUInt16(); + } + catch( ArgumentException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Char value, CancellationToken cancellationToken ) + { + await packer.PackAsync( ( System.UInt16 )value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_DecimalMessagePackSerializer : MessagePackSerializer< System.Decimal > + { + public System_DecimalMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Decimal value ) + { + packer.PackString( value.ToString( "G", CultureInfo.InvariantCulture ) ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Decimal UnpackFromCore( Unpacker unpacker ) + { + try + { + return System.Decimal.Parse( unpacker.LastReadData.AsString(), CultureInfo.InvariantCulture ); + } + catch( ArgumentException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Decimal value, CancellationToken cancellationToken ) + { + await packer.PackStringAsync( value.ToString( "G", CultureInfo.InvariantCulture ), cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_DoubleMessagePackSerializer : MessagePackSerializer< System.Double > + { + public System_DoubleMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Double value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Double UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsDouble(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Double ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Double value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_GuidMessagePackSerializer : MessagePackSerializer< System.Guid > + { + public System_GuidMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Guid value ) + { + packer.PackRaw( value.ToByteArray() ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Guid UnpackFromCore( Unpacker unpacker ) + { + try + { + return new System.Guid( unpacker.LastReadData.AsBinary() ); + } + catch( ArgumentException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Guid value, CancellationToken cancellationToken ) + { + await packer.PackRawAsync( value.ToByteArray(), cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_Int16MessagePackSerializer : MessagePackSerializer< System.Int16 > + { + public System_Int16MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Int16 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Int16 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsInt16(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Int16 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Int16 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_Int32MessagePackSerializer : MessagePackSerializer< System.Int32 > + { + public System_Int32MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Int32 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Int32 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsInt32(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Int32 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Int32 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_Int64MessagePackSerializer : MessagePackSerializer< System.Int64 > + { + public System_Int64MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Int64 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Int64 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsInt64(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Int64 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Int64 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_SByteMessagePackSerializer : MessagePackSerializer< System.SByte > + { + public System_SByteMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.SByte value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.SByte UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsSByte(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.SByte ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.SByte value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_SingleMessagePackSerializer : MessagePackSerializer< System.Single > + { + public System_SingleMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Single value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Single UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsSingle(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Single ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Single value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_TimeSpanMessagePackSerializer : MessagePackSerializer< System.TimeSpan > + { + public System_TimeSpanMessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.TimeSpan value ) + { + packer.Pack( value.Ticks ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.TimeSpan UnpackFromCore( Unpacker unpacker ) + { + System.Int64 ctorArgument; + try + { + ctorArgument = unpacker.LastReadData.AsInt64(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Int64 ), ex.Message ) ); + } + + return new System.TimeSpan( ctorArgument ); + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.TimeSpan value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value.Ticks, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_UInt16MessagePackSerializer : MessagePackSerializer< System.UInt16 > + { + public System_UInt16MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.UInt16 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.UInt16 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsUInt16(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.UInt16 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.UInt16 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_UInt32MessagePackSerializer : MessagePackSerializer< System.UInt32 > + { + public System_UInt32MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.UInt32 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.UInt32 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsUInt32(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.UInt32 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.UInt32 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + + internal sealed class System_UInt64MessagePackSerializer : MessagePackSerializer< System.UInt64 > + { + public System_UInt64MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.UInt64 value ) + { + packer.Pack( value ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.UInt64 UnpackFromCore( Unpacker unpacker ) + { + try + { + return unpacker.LastReadData.AsUInt64(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.UInt64 ), ex.Message ) ); + } + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.UInt64 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } + +#if !SILVERLIGHT +#if !NETSTANDARD1_1 +#if !UNITY || MSGPACK_UNITY_FULL +#warning TODO: LegacyCollections + internal sealed class System_Collections_Specialized_BitVector32MessagePackSerializer : MessagePackSerializer< System.Collections.Specialized.BitVector32 > + { + public System_Collections_Specialized_BitVector32MessagePackSerializer( SerializationContext ownerContext ) + : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override void PackToCore( Packer packer, System.Collections.Specialized.BitVector32 value ) + { + packer.Pack( value.Data ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override System.Collections.Specialized.BitVector32 UnpackFromCore( Unpacker unpacker ) + { + System.Int32 ctorArgument; + try + { + ctorArgument = unpacker.LastReadData.AsInt32(); + } + catch( InvalidOperationException ex ) + { + throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not '{0}' type. {1}", typeof( System.Int32 ), ex.Message ) ); + } + + return new System.Collections.Specialized.BitVector32( ctorArgument ); + } + +#if FEATURE_TAP + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + protected internal override async Task PackToAsyncCore( Packer packer, System.Collections.Specialized.BitVector32 value, CancellationToken cancellationToken ) + { + await packer.PackAsync( value.Data, cancellationToken ).ConfigureAwait( false ); + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + { + var tcs = new TaskCompletionSource(); + try + { + tcs.SetResult( this.UnpackFromCore( unpacker ) ); + } + catch( Exception ex ) + { + tcs.SetException( ex ); + } + + return tcs.Task; + } + +#endif // FEATURE_TAP + + } +#endif // !NETSTANDARD1_1 +#endif // !SILVERLIGHT +#endif // !UNITY || MSGPACK_UNITY_FULL + +#if !WINDOWS_PHONE +#if !NETFX_35 && !UNITY +#if !UNITY || MSGPACK_UNITY_FULL + // internal sealed class System_Numerics_BigIntegerMessagePackSerializer : MessagePackSerializer< System.Numerics.BigInteger > + // { + // public System_Numerics_BigIntegerMessagePackSerializer( SerializationContext ownerContext ) + // : base( ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) { } + + // [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + // protected internal override void PackToCore( Packer packer, System.Numerics.BigInteger value ) + // { + // packer.PackRaw( value.ToByteArray() ); + // } + + // [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + // protected internal override System.Numerics.BigInteger UnpackFromCore( Unpacker unpacker ) + // { + // try + // { + // return new System.Numerics.BigInteger( unpacker.LastReadData.AsBinary() ); + // } + // catch( ArgumentException ex ) + // { + // throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + // } + // catch( InvalidOperationException ex ) + // { + // throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", ex.Message ), ex ); + // } + // } + + //#if FEATURE_TAP + + // [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + // protected internal override async Task PackToAsyncCore( Packer packer, System.Numerics.BigInteger value, CancellationToken cancellationToken ) + // { + // await packer.PackRawAsync( value.ToByteArray(), cancellationToken ).ConfigureAwait( false ); + // } + + // [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "0", Justification = "Validated by caller in base class" )] + // [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Transfers all catched exceptions." )] + // protected internal override Task UnpackFromAsyncCore( Unpacker unpacker, CancellationToken cancellationToken ) + // { + // var tcs = new TaskCompletionSource(); + // try + // { + // tcs.SetResult( this.UnpackFromCore( unpacker ) ); + // } + // catch( Exception ex ) + // { + // tcs.SetException( ex ); + // } + + // return tcs.Task; + // } + + //#endif // FEATURE_TAP + + // } +#endif // !NETFX_35 && !UNITY +#endif // !WINDOWS_PHONE +#endif // !UNITY || MSGPACK_UNITY_FULL + // ReSharper restore RedundantCast + // ReSharper restore RedundantNameQualifier + // ReSharper restore InconsistentNaming +} diff --git a/src/MsgPack.Serialization/Serialization/SerializerRepository.defaults.cs b/src/MsgPack.Serialization/Serialization/SerializerRepository.defaults.cs new file mode 100644 index 000000000..5e55af5ab --- /dev/null +++ b/src/MsgPack.Serialization/Serialization/SerializerRepository.defaults.cs @@ -0,0 +1,201 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Reflection; +using System.Text; + +using MsgPack.Serialization.DefaultSerializers; + +namespace MsgPack.Serialization +{ +#warning TODO: back to T4 + // This file generated from SerializerRepository.tt T4Template. + // Do not modify this file. Edit SerializerRepository.tt instead. + + // ReSharper disable RedundantNameQualifier + partial class SerializerRepository + { + internal const int DefaultTableCapacity = 56; + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "This API is naturally coupled with many types" )] + internal static Dictionary InitializeDefaultTable( SerializationContext ownerContext ) + { + var dictionary = new Dictionary( DefaultTableCapacity ); + dictionary.Add( typeof( MessagePackObject ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.MsgPack_MessagePackObjectMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( MessagePackObjectDictionary ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.MsgPack_MessagePackObjectDictionaryMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( MessagePackExtendedTypeObject ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.MsgPack_MessagePackExtendedTypeObjectMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( List ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_Generic_ListOfMessagePackObjectMessagePackSerializer( ownerContext ) ); +#if !UNITY + dictionary.Add( typeof( Object ).TypeHandle, new MsgPack.Serialization.Polymorphic.PolymorphicSerializerProvider( new MsgPack.Serialization.DefaultSerializers.System_ObjectMessagePackSerializer( ownerContext ) ) ); +#else + dictionary.Add( typeof( Object ).TypeHandle, new MsgPack.Serialization.Polymorphic.PolymorphicSerializerProvider( ownerContext, new MsgPack.Serialization.DefaultSerializers.System_ObjectMessagePackSerializer( ownerContext ) ) ); +#endif // !UNITY + dictionary.Add( typeof( String ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_StringMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( StringBuilder ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Text_StringBuilderMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( Char[] ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_CharArrayMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( Byte[] ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_ByteArrayMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( DateTime ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.DateTimeMessagePackSerializerProvider( ownerContext, false ) ); + dictionary.Add( typeof( DateTimeOffset ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.DateTimeOffsetMessagePackSerializerProvider( ownerContext, false ) ); +#if ( !SILVERLIGHT || WINDOWS_PHONE ) && !XAMARIN && !UNITY && !UNITY + dictionary.Add( typeof( System.Runtime.InteropServices.ComTypes.FILETIME ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.FileTimeMessagePackSerializerProvider( ownerContext, false ) ); +#endif // ( !SILVERLIGHT || WINDOWS_PHONE ) && !XAMARIN && !UNITY && !UNITY + // DateTime, DateTimeOffset, and FILETIME must have nullable providers. + dictionary.Add( typeof( DateTime? ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.DateTimeMessagePackSerializerProvider( ownerContext, true ) ); + dictionary.Add( typeof( DateTimeOffset? ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.DateTimeOffsetMessagePackSerializerProvider( ownerContext, true ) ); +#if ( !SILVERLIGHT || WINDOWS_PHONE ) && !XAMARIN && !UNITY && !UNITY + dictionary.Add( typeof( System.Runtime.InteropServices.ComTypes.FILETIME? ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.FileTimeMessagePackSerializerProvider( ownerContext, true ) ); +#endif // ( !SILVERLIGHT || WINDOWS_PHONE ) && !XAMARIN && !UNITY && !UNITY +#if !NETFX_CORE && !NETSTANDARD1_1 + dictionary.Add( typeof( DBNull ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_DBNullMessagePackSerializer( ownerContext ) ); +#endif // !NETFX_CORE && !NETSTANDARD1_1 + dictionary.Add( typeof( System.Boolean ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_BooleanMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Byte ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_ByteMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Char ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_CharMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Decimal ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_DecimalMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Double ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_DoubleMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Guid ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_GuidMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Int16 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Int16MessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Int32 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Int32MessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Int64 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Int64MessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.SByte ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_SByteMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.Single ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_SingleMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.TimeSpan ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_TimeSpanMessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.UInt16 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_UInt16MessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.UInt32 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_UInt32MessagePackSerializer( ownerContext ) ); + dictionary.Add( typeof( System.UInt64 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_UInt64MessagePackSerializer( ownerContext ) ); +#if !NETSTANDARD1_1 +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN + dictionary.Add( typeof( System.Security.Cryptography.HashAlgorithmName ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Security_Cryptography_HashAlgorithmNameMessagePackSerializer( ownerContext ) ); +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#endif // !NETSTANDARD1_1 +#if !NETSTANDARD1_1 +#if !SILVERLIGHT +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Collections.Specialized.BitVector32 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_Specialized_BitVector32MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !SILVERLIGHT +#endif // !NETSTANDARD1_1 +#if !WINDOWS_PHONE +#if !NETFX_35 && !UNITY +#if !UNITY || MSGPACK_UNITY_FULL +// dictionary.Add( typeof( System.Numerics.BigInteger ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_BigIntegerMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETFX_35 && !UNITY +#endif // !WINDOWS_PHONE +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Matrix3x2 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_Matrix3x2MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Matrix4x4 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_Matrix4x4MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Plane ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_PlaneMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Quaternion ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_QuaternionMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Vector2 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_Vector2MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Vector3 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_Vector3MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Numerics.Vector4 ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_Vector4MessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !XAMARIN +#endif // !NETFX_35 && !UNITY && !NETFX_40 && !NETFX_45 && !SILVERLIGHT + dictionary.Add( typeof( System.ArraySegment<> ).TypeHandle, typeof( System_ArraySegment_1MessagePackSerializer<> ) ); + dictionary.Add( typeof( System.Globalization.CultureInfo ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Globalization_CultureInfoMessagePackSerializer( ownerContext ) ); + //dictionary.Add( typeof( System.Collections.DictionaryEntry ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_DictionaryEntryMessagePackSerializer( ownerContext ) ); +#if !NETSTANDARD1_1 +#if !SILVERLIGHT + dictionary.Add( typeof( System.Collections.Stack ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_StackMessagePackSerializer( ownerContext ) ); +#endif // !SILVERLIGHT +#endif // !NETSTANDARD1_1 +#if !NETSTANDARD1_1 +#if !SILVERLIGHT + dictionary.Add( typeof( System.Collections.Queue ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_QueueMessagePackSerializer( ownerContext ) ); +#endif // !SILVERLIGHT +#endif // !NETSTANDARD1_1 + dictionary.Add( typeof( System.Collections.Generic.KeyValuePair<,> ).TypeHandle, typeof( System_Collections_Generic_KeyValuePair_2MessagePackSerializer<, > ) ); +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Collections.Generic.Stack<> ).TypeHandle, typeof( System_Collections_Generic_Stack_1MessagePackSerializer<> ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Collections.Generic.Queue<> ).TypeHandle, typeof( System_Collections_Generic_Queue_1MessagePackSerializer<> ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#if !WINDOWS_PHONE +#if !NETFX_35 && !UNITY +#if !UNITY || MSGPACK_UNITY_FULL + //dictionary.Add( typeof( System.Numerics.Complex ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Numerics_ComplexMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !NETFX_35 && !UNITY +#endif // !WINDOWS_PHONE +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Uri ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_UriMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Version ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_VersionMessagePackSerializer( ownerContext ) ); +#if !NETSTANDARD1_1 +#if !SILVERLIGHT +#if !UNITY || MSGPACK_UNITY_FULL + dictionary.Add( typeof( System.Collections.Specialized.NameValueCollection ).TypeHandle, new MsgPack.Serialization.DefaultSerializers.System_Collections_Specialized_NameValueCollectionMessagePackSerializer( ownerContext ) ); +#endif // !UNITY || MSGPACK_UNITY_FULL +#endif // !SILVERLIGHT +#endif // !NETSTANDARD1_1 + return dictionary; + } + } +} diff --git a/src/MsgPack.Serialization/project.json b/src/MsgPack.Serialization/project.json new file mode 100644 index 000000000..7df0b9af4 --- /dev/null +++ b/src/MsgPack.Serialization/project.json @@ -0,0 +1,29 @@ +{ + "supports": {}, + "dependencies": { + "System.Collections": "4.0.11", + "System.Collections.Concurrent": "4.0.12", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tools": "4.0.1", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Linq": "4.1.0", + "System.Reflection": "4.1.0", + "System.Reflection.Emit": "4.0.1", + "System.Reflection.Emit.Lightweight": "4.0.1", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.Serialization.Primitives": "4.1.1", + "System.Text.Encoding": "4.0.11", + "System.Text.Encoding.Extensions": "4.0.11", + "System.Threading": "4.0.11", + "System.Linq.Expressions": "4.1.0" + }, + "frameworks": { + "netstandard1.1": {} + } +} \ No newline at end of file diff --git a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj index 850391f9c..38e7defe0 100644 --- a/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj +++ b/src/MsgPack.Silverlight.5/MsgPack.Silverlight.5.csproj @@ -35,6 +35,7 @@ prompt 4 Bin\Debug\MsgPack.XML + 1574 pdbonly @@ -46,6 +47,7 @@ prompt 4 ..\..\bin\sl5\MsgPack.XML + 1574 true @@ -65,6 +67,7 @@ AllRules.ruleset true true + 1574 diff --git a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj index af2e12fa6..818299ba7 100644 --- a/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj +++ b/src/MsgPack.Silverlight.WindowsPhone/MsgPack.Silverlight.WindowsPhone.csproj @@ -29,6 +29,7 @@ true prompt 4 + 1574 pdbonly @@ -40,6 +41,7 @@ prompt 4 ..\..\bin\windowsphone8\MsgPack.XML + 1574 true @@ -94,6 +96,7 @@ prompt AllRules.ruleset true + 1574 bin\x86\CodeAnalysis\ @@ -521,6 +524,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj index b27e5ecb6..0624673bb 100644 --- a/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj +++ b/src/MsgPack.Unity.Full/MsgPack.Unity.Full.csproj @@ -21,7 +21,7 @@ prompt 4 bin\Debug\MsgPack.XML - 3001,3002 + 3001,3002,1574 pdbonly @@ -31,14 +31,14 @@ prompt 4 ..\..\build\MsgPack-CLI\unity-full\MsgPack.XML - 3001,3002 + 3001,3002,1574 bin\CodeAnalysis\ TRACE;UNITY_IPHONE;MSGPACK_UNITY_FULL;AOT;CODE_ANALYSIS true - 3001,3002 + 3001,3002,1574 pdbonly AnyCPU prompt @@ -427,6 +427,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack.Unity/MsgPack.Unity.csproj b/src/MsgPack.Unity/MsgPack.Unity.csproj index d156062d4..8cb5e0577 100644 --- a/src/MsgPack.Unity/MsgPack.Unity.csproj +++ b/src/MsgPack.Unity/MsgPack.Unity.csproj @@ -23,7 +23,7 @@ prompt 4 bin\Debug\MsgPack.XML - 3001,3002 + 3001,3002,1574 AllRules.ruleset @@ -34,7 +34,7 @@ prompt 4 ..\..\build\MsgPack-CLI\unity\MsgPack.XML - 3001,3002 + 3001,3002,1574 AllRules.ruleset @@ -42,7 +42,7 @@ TRACE;UNITY_IPHONE;AOT;CODE_ANALYSIS ..\..\bin\unity3d\MsgPack.XML true - 3001,3002 + 3001,3002,1574 pdbonly AnyCPU prompt @@ -437,6 +437,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack.Uwp/MsgPack.Uwp.csproj b/src/MsgPack.Uwp/MsgPack.Uwp.csproj index b032b9f2b..8e27b8c7e 100644 --- a/src/MsgPack.Uwp/MsgPack.Uwp.csproj +++ b/src/MsgPack.Uwp/MsgPack.Uwp.csproj @@ -533,6 +533,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack.Xamarin.Android/MsgPack.Xamarin.Android.csproj b/src/MsgPack.Xamarin.Android/MsgPack.Xamarin.Android.csproj index e01c7ca21..a91404f84 100644 --- a/src/MsgPack.Xamarin.Android/MsgPack.Xamarin.Android.csproj +++ b/src/MsgPack.Xamarin.Android/MsgPack.Xamarin.Android.csproj @@ -455,6 +455,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack.Xamarin.iOS/MsgPack.Xamarin.iOS.csproj b/src/MsgPack.Xamarin.iOS/MsgPack.Xamarin.iOS.csproj index 69095753d..990d3a349 100644 --- a/src/MsgPack.Xamarin.iOS/MsgPack.Xamarin.iOS.csproj +++ b/src/MsgPack.Xamarin.iOS/MsgPack.Xamarin.iOS.csproj @@ -451,6 +451,9 @@ Serialization\ExtTypeCodeMapping.cs + + Serialization\FromExpression.cs + Serialization\ICustomizableEnumSerializer.cs diff --git a/src/MsgPack/BigEndianBinary.cs b/src/MsgPack/BigEndianBinary.cs index f553f714e..3794eb9ae 100644 --- a/src/MsgPack/BigEndianBinary.cs +++ b/src/MsgPack/BigEndianBinary.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/CollectionOperation.cs b/src/MsgPack/CollectionOperation.cs index 10887c3ba..362b0c7e8 100644 --- a/src/MsgPack/CollectionOperation.cs +++ b/src/MsgPack/CollectionOperation.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; namespace MsgPack diff --git a/src/MsgPack/Float32Bits.cs b/src/MsgPack/Float32Bits.cs index 1ed5cae17..be6944809 100644 --- a/src/MsgPack/Float32Bits.cs +++ b/src/MsgPack/Float32Bits.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Runtime.InteropServices; namespace MsgPack diff --git a/src/MsgPack/Float64Bits.cs b/src/MsgPack/Float64Bits.cs index a7e17bcc4..00f7f9c7c 100644 --- a/src/MsgPack/Float64Bits.cs +++ b/src/MsgPack/Float64Bits.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Runtime.InteropServices; namespace MsgPack diff --git a/src/MsgPack/IAsyncUnpackable.cs b/src/MsgPack/IAsyncUnpackable.cs index b4e94dff4..b1055f0c0 100644 --- a/src/MsgPack/IAsyncUnpackable.cs +++ b/src/MsgPack/IAsyncUnpackable.cs @@ -21,7 +21,6 @@ #if FEATURE_TAP using System; -using System.Runtime.Serialization; using System.Threading; using System.Threading.Tasks; diff --git a/src/MsgPack/ItemsUnpacker.cs b/src/MsgPack/ItemsUnpacker.cs index efd51a46f..07259d134 100644 --- a/src/MsgPack/ItemsUnpacker.cs +++ b/src/MsgPack/ItemsUnpacker.cs @@ -24,11 +24,11 @@ using System; #if DEBUG -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // DEBUG using System.Globalization; using System.IO; diff --git a/src/MsgPack/MessagePackConvert.cs b/src/MsgPack/MessagePackConvert.cs index 04f406c80..7c5981d73 100644 --- a/src/MsgPack/MessagePackConvert.cs +++ b/src/MsgPack/MessagePackConvert.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Text; namespace MsgPack diff --git a/src/MsgPack/MessagePackObject.Utilities.cs b/src/MsgPack/MessagePackObject.Utilities.cs index cc180c737..85d21c8a1 100644 --- a/src/MsgPack/MessagePackObject.Utilities.cs +++ b/src/MsgPack/MessagePackObject.Utilities.cs @@ -25,11 +25,11 @@ using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || !UNITY +#endif // CORE_CLR || !UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; #if NETFX_CORE diff --git a/src/MsgPack/MessagePackObject.cs b/src/MsgPack/MessagePackObject.cs index 54502d377..2322abeb4 100644 --- a/src/MsgPack/MessagePackObject.cs +++ b/src/MsgPack/MessagePackObject.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Runtime.InteropServices; namespace MsgPack diff --git a/src/MsgPack/MessagePackObject.tt b/src/MsgPack/MessagePackObject.tt index c9cb8d140..b563c49e5 100644 --- a/src/MsgPack/MessagePackObject.tt +++ b/src/MsgPack/MessagePackObject.tt @@ -79,11 +79,11 @@ Func IsNotCLSCompliant = #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Runtime.InteropServices; namespace MsgPack diff --git a/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs index 8bb56b925..e09eedf20 100644 --- a/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs +++ b/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs @@ -25,11 +25,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs index 71b92b5b3..a9e92c4f4 100644 --- a/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs +++ b/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs @@ -25,11 +25,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/MessagePackObjectDictionary.KeySet.cs b/src/MsgPack/MessagePackObjectDictionary.KeySet.cs index 91d67cc13..d0ed0acea 100644 --- a/src/MsgPack/MessagePackObjectDictionary.KeySet.cs +++ b/src/MsgPack/MessagePackObjectDictionary.KeySet.cs @@ -27,11 +27,11 @@ using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs index 00d919f77..c8fd89ef6 100644 --- a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs +++ b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs @@ -25,11 +25,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs index b9cd8e723..06bd73432 100644 --- a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs +++ b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs @@ -27,11 +27,11 @@ using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack { diff --git a/src/MsgPack/MessagePackObjectDictionary.cs b/src/MsgPack/MessagePackObjectDictionary.cs index 6b82bdec4..cf0d10f87 100644 --- a/src/MsgPack/MessagePackObjectDictionary.cs +++ b/src/MsgPack/MessagePackObjectDictionary.cs @@ -27,11 +27,11 @@ using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; diff --git a/src/MsgPack/MessagePackString.cs b/src/MsgPack/MessagePackString.cs index 1d38b1b3e..f86a6051c 100644 --- a/src/MsgPack/MessagePackString.cs +++ b/src/MsgPack/MessagePackString.cs @@ -24,11 +24,11 @@ using System; using System.Diagnostics; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Security; diff --git a/src/MsgPack/MsgPack.csproj b/src/MsgPack/MsgPack.csproj index 7370ceab5..9da43d78c 100644 --- a/src/MsgPack/MsgPack.csproj +++ b/src/MsgPack/MsgPack.csproj @@ -20,7 +20,7 @@ full false bin\Debug\ - TRACE;DEBUG;FEATURE_TAP;FEATURE_ET + TRACE;DEBUG;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT prompt 4 bin\Debug\MsgPack.XML @@ -31,7 +31,7 @@ pdbonly true ..\..\bin\net46\ - TRACE;FEATURE_TAP + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT prompt 4 ..\..\bin\net46\MsgPack.XML @@ -39,7 +39,7 @@ bin\Performance Test\ - TRACE;FEATURE_TAP;PERFORMANCE_TEST + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;PERFORMANCE_TEST bin\Release\MsgPack.XML true pdbonly @@ -59,7 +59,7 @@ bin\Instrument\ - TRACE;FEATURE_TAP;PERFORMANCE_TEST + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;PERFORMANCE_TEST bin\Instrument\MsgPack.XML false pdbonly @@ -73,7 +73,7 @@ bin\CodeAnalysis\ - TRACE;FEATURE_TAP;CODE_ANALYSIS + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;CODE_ANALYSIS true @@ -89,7 +89,7 @@ bin\CoreProfile\ - TRACE;FEATURE_TAP;CORE_PROFILE + TRACE;FEATURE_TAP;FEATURE_ET;FEATURE_CONCURRENT;CORE_PROFILE bin\CoreProfile\MsgPack.XML true pdbonly @@ -200,6 +200,9 @@ + + + @@ -258,6 +261,7 @@ + @@ -407,7 +411,9 @@ + + diff --git a/src/MsgPack/Packer.Packing.cs b/src/MsgPack/Packer.Packing.cs index b3e75be12..40b93d696 100644 --- a/src/MsgPack/Packer.Packing.cs +++ b/src/MsgPack/Packer.Packing.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Text; #if FEATURE_TAP diff --git a/src/MsgPack/Packer.Packing.tt b/src/MsgPack/Packer.Packing.tt index 6e5391bd4..08d007b16 100644 --- a/src/MsgPack/Packer.Packing.tt +++ b/src/MsgPack/Packer.Packing.tt @@ -35,11 +35,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Text; #if FEATURE_TAP diff --git a/src/MsgPack/Packer.cs b/src/MsgPack/Packer.cs index 26a279364..ba98e5c82 100644 --- a/src/MsgPack/Packer.cs +++ b/src/MsgPack/Packer.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.IO; #if FEATURE_TAP diff --git a/src/MsgPack/PackerUnpackerExtensions.cs b/src/MsgPack/PackerUnpackerExtensions.cs index 5830332ad..106ee989d 100644 --- a/src/MsgPack/PackerUnpackerExtensions.cs +++ b/src/MsgPack/PackerUnpackerExtensions.cs @@ -25,11 +25,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/PackerUnpackerExtensions.tt b/src/MsgPack/PackerUnpackerExtensions.tt index c29146763..cee7965b2 100644 --- a/src/MsgPack/PackerUnpackerExtensions.tt +++ b/src/MsgPack/PackerUnpackerExtensions.tt @@ -35,11 +35,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/PreserveAttribute.cs b/src/MsgPack/PreserveAttribute.cs index ad5440b24..3cafbaef4 100644 --- a/src/MsgPack/PreserveAttribute.cs +++ b/src/MsgPack/PreserveAttribute.cs @@ -25,7 +25,9 @@ namespace MsgPack // For Unity and Xamarin internal sealed class PreserveAttribute : Attribute { +#pragma warning disable CS0649 public bool AllMembers; public bool Conditional; +#pragma warning restore CS0649 } } diff --git a/src/MsgPack/ReflectionAbstractions.cs b/src/MsgPack/ReflectionAbstractions.cs index 1bac72e0e..514a2c458 100644 --- a/src/MsgPack/ReflectionAbstractions.cs +++ b/src/MsgPack/ReflectionAbstractions.cs @@ -25,11 +25,11 @@ using System; using System.Collections.Generic; using System.Diagnostics; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/ConstructorDefinition.cs b/src/MsgPack/Serialization/AbstractSerializers/ConstructorDefinition.cs index edf646e3e..305d2aa05 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/ConstructorDefinition.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/ConstructorDefinition.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/FieldDefinition.cs b/src/MsgPack/Serialization/AbstractSerializers/FieldDefinition.cs index fa818f0f3..2548ceeb6 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/FieldDefinition.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/FieldDefinition.cs @@ -19,11 +19,11 @@ #endregion -- License Terms -- using System; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/MethodDefinition.cs b/src/MsgPack/Serialization/AbstractSerializers/MethodDefinition.cs index 38d990c22..735dc8207 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/MethodDefinition.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/MethodDefinition.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Collection.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Collection.cs index 6494dd615..4224bf149 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Collection.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Collection.cs @@ -23,11 +23,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Reflection; #if FEATURE_TAP diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.CommonConstructs.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.CommonConstructs.cs index 8c54f6522..288cb3597 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.CommonConstructs.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.CommonConstructs.cs @@ -24,11 +24,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Enum.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Enum.cs index 5a33acfc5..223bd572c 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Enum.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Enum.cs @@ -19,11 +19,11 @@ #endregion -- License Terms -- using System; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 #if FEATURE_TAP using System.Threading; #endif // FEATURE_TAP diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs index e95342a28..6e5e6a87a 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs index 75c97281f..18f1a2402 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Linq; using System.Reflection; #if FEATURE_TAP diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.cs index 66992d06f..b4fa49929 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.cs @@ -19,11 +19,11 @@ #endregion -- License Terms -- using System; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using MsgPack.Serialization.CollectionSerializers; diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerGenerationContext.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerGenerationContext.cs index b5083f21e..103252f1e 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerGenerationContext.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerGenerationContext.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerSpecification.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerSpecification.cs index 047f6a620..1e4bcbc70 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerSpecification.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerSpecification.cs @@ -20,11 +20,11 @@ using System; #if DEBUG -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 #endif // DEBUG namespace MsgPack.Serialization.AbstractSerializers diff --git a/src/MsgPack/Serialization/AbstractSerializers/TypeDefinition.cs b/src/MsgPack/Serialization/AbstractSerializers/TypeDefinition.cs index 2fa2ff513..4e719a0f5 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/TypeDefinition.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/TypeDefinition.cs @@ -20,13 +20,14 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.Linq; +using System.Reflection; using MsgPack.Serialization.Reflection; @@ -39,6 +40,27 @@ internal class TypeDefinition { private static readonly TypeDefinition[] EmptyArray = new TypeDefinition[ 0 ]; + public static readonly TypeDefinition ObjectType = TypeDefinition.Object( typeof( object ) ); + public static readonly TypeDefinition ByteType = TypeDefinition.Object( typeof( byte ) ); + public static readonly TypeDefinition SByteType = TypeDefinition.Object( typeof( sbyte ) ); + public static readonly TypeDefinition Int16Type = TypeDefinition.Object( typeof( short ) ); + public static readonly TypeDefinition UInt16Type = TypeDefinition.Object( typeof( ushort ) ); + public static readonly TypeDefinition Int32Type = TypeDefinition.Object( typeof( int ) ); + public static readonly TypeDefinition UInt32Type = TypeDefinition.Object( typeof( uint ) ); + public static readonly TypeDefinition Int64Type = TypeDefinition.Object( typeof( long ) ); + public static readonly TypeDefinition UInt64Type = TypeDefinition.Object( typeof( ulong ) ); + public static readonly TypeDefinition SingleType = TypeDefinition.Object( typeof( float ) ); + public static readonly TypeDefinition DoubleType = TypeDefinition.Object( typeof( double ) ); + public static readonly TypeDefinition BooleanType = TypeDefinition.Object( typeof( bool ) ); + public static readonly TypeDefinition CharType = TypeDefinition.Object( typeof( char ) ); + public static readonly TypeDefinition StringType = TypeDefinition.Object( typeof( string ) ); + public static readonly TypeDefinition TypeType = TypeDefinition.Object( typeof( Type ) ); + public static readonly TypeDefinition MethodBaseType = TypeDefinition.Object( typeof( MethodBase ) ); + public static readonly TypeDefinition FieldInfoType = TypeDefinition.Object( typeof( FieldInfo ) ); + public static readonly TypeDefinition SerializationContextType = TypeDefinition.Object( typeof( SerializationContext ) ); + + + private readonly Flags _flags; public bool IsArray diff --git a/src/MsgPack/Serialization/CodeDomSerializers/CodeDomSerializerBuilder.cs b/src/MsgPack/Serialization/CodeDomSerializers/CodeDomSerializerBuilder.cs index d6611c2c4..e3d89d7d0 100644 --- a/src/MsgPack/Serialization/CodeDomSerializers/CodeDomSerializerBuilder.cs +++ b/src/MsgPack/Serialization/CodeDomSerializers/CodeDomSerializerBuilder.cs @@ -1206,7 +1206,7 @@ protected override Func CreateEnumS #endif // !NETFX_35 private static Type PrepareSerializerConstructorCreation( CodeDomContext codeGenerationContext ) { - if ( !SerializerDebugging.OnTheFlyCodeDomEnabled ) + if ( !SerializerDebugging.OnTheFlyCodeGenerationEnabled ) { throw new NotSupportedException(); } @@ -1224,7 +1224,7 @@ private static Type PrepareSerializerConstructorCreation( CodeDomContext codeGen cr = codeProvider.CompileAssemblyFromDom( - new CompilerParameters( SerializerDebugging.CodeDomSerializerDependentAssemblies.ToArray() ) + new CompilerParameters( SerializerDebugging.CodeSerializerDependentAssemblies.ToArray() ) #if PERFORMANCE_TEST { IncludeDebugInformation = false, diff --git a/src/MsgPack/Serialization/CodeGenerators/SerializerAssemblyGenerationLogic.cs b/src/MsgPack/Serialization/CodeGenerators/SerializerAssemblyGenerationLogic.cs new file mode 100644 index 000000000..5834fa01f --- /dev/null +++ b/src/MsgPack/Serialization/CodeGenerators/SerializerAssemblyGenerationLogic.cs @@ -0,0 +1,58 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Reflection.Emit; + +using MsgPack.Serialization.AbstractSerializers; +using MsgPack.Serialization.EmittingSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal sealed class SerializerAssemblyGenerationLogic : SerializerGenerationLogic + { + protected override EmitterFlavor EmitterFlavor + { + get { return EmitterFlavor.FieldBased; } + } + + public SerializerAssemblyGenerationLogic() {} + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] + protected override ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, SerializerAssemblyGenerationConfiguration configuration ) + { + return + new AssemblyBuilderCodeGenerationContext( + context, + AppDomain.CurrentDomain.DefineDynamicAssembly( + configuration.AssemblyName, + AssemblyBuilderAccess.RunAndSave, + configuration.OutputDirectory + ), + configuration + ); + } + + protected override Func CreateGeneratorFactory( SerializationContext context ) + { + return type => new AssemblyBuilderSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ); + } + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/CodeGenerators/SerializerCodeGeneratorFactory.cs b/src/MsgPack/Serialization/CodeGenerators/SerializerCodeGeneratorFactory.cs new file mode 100644 index 000000000..f662f468b --- /dev/null +++ b/src/MsgPack/Serialization/CodeGenerators/SerializerCodeGeneratorFactory.cs @@ -0,0 +1,29 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal abstract class SerializerCodeGeneratorFactory + { + internal abstract SerializerGenerationLogic Create( SerializerCodeGenerationConfiguration configuration ); + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogic.cs b/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogic.cs new file mode 100644 index 000000000..93d5a58c0 --- /dev/null +++ b/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogic.cs @@ -0,0 +1,49 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +using MsgPack.Serialization.AbstractSerializers; +using MsgPack.Serialization.CodeDomSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal sealed class SerializerCodesGenerationLogic : SerializerGenerationLogic + { + public static readonly SerializerCodesGenerationLogic Instance = new SerializerCodesGenerationLogic(); + + protected override EmitterFlavor EmitterFlavor + { + get { return EmitterFlavor.CodeDomBased; } + } + + private SerializerCodesGenerationLogic() {} + + protected override ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, SerializerCodeGenerationConfiguration configuration ) + { + return new CodeDomContext( context, configuration ); + } + + protected override Func CreateGeneratorFactory( SerializationContext context ) + { + return type => new CodeDomSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ); + } + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogicFactory.cs b/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogicFactory.cs new file mode 100644 index 000000000..5856a4844 --- /dev/null +++ b/src/MsgPack/Serialization/CodeGenerators/SerializerCodesGenerationLogicFactory.cs @@ -0,0 +1,36 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal sealed class SerializerCodesGenerationLogicFactory : SerializerCodeGeneratorFactory + { + public static readonly SerializerCodesGenerationLogicFactory Instance = new SerializerCodesGenerationLogicFactory(); + + private SerializerCodesGenerationLogicFactory() { } + + internal override SerializerGenerationLogic Create( SerializerCodeGenerationConfiguration configuration ) + { + return SerializerCodesGenerationLogic.Instance; + } + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/CodeGenerators/SerializerGenerationLogic`1.cs b/src/MsgPack/Serialization/CodeGenerators/SerializerGenerationLogic`1.cs new file mode 100644 index 000000000..88d376caa --- /dev/null +++ b/src/MsgPack/Serialization/CodeGenerators/SerializerGenerationLogic`1.cs @@ -0,0 +1,157 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; + +using MsgPack.Serialization.AbstractSerializers; + +namespace MsgPack.Serialization.CodeGenerators +{ + internal abstract class SerializerGenerationLogic + where TConfig : class, ISerializerGeneratorConfiguration + { + protected abstract EmitterFlavor EmitterFlavor { get; } + + public IEnumerable Generate( IEnumerable targetTypes, TConfig configuration ) + { + if ( targetTypes == null ) + { + throw new ArgumentNullException( "targetTypes" ); + } + + if ( configuration == null ) + { + throw new ArgumentNullException( "configuration" ); + } + + configuration.Validate(); + var context = + new SerializationContext + { +#if !NETSTANDARD1_3 + GeneratorOption = SerializationMethodGeneratorOption.CanDump, +#endif // !NETSTANDARD1_3 + EnumSerializationMethod = configuration.EnumSerializationMethod, + SerializationMethod = configuration.SerializationMethod + }; + context.SerializerOptions.EmitterFlavor = this.EmitterFlavor; + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = configuration.CompatibilityOptions.AllowNonCollectionEnumerableTypes; + context.CompatibilityOptions.IgnorePackabilityForCollection = configuration.CompatibilityOptions.IgnorePackabilityForCollection; + context.CompatibilityOptions.OneBoundDataMemberOrder = configuration.CompatibilityOptions.OneBoundDataMemberOrder; + context.CompatibilityOptions.PackerCompatibilityOptions = configuration.CompatibilityOptions.PackerCompatibilityOptions; +#if FEATURE_TAP + context.SerializerOptions.WithAsync = configuration.WithAsync; +#endif // FEATURE_TAP + + IEnumerable realTargetTypes; + if ( configuration.IsRecursive ) + { + realTargetTypes = + targetTypes + .SelectMany( t => ExtractElementTypes( context, configuration, t ) ); + } + else + { + realTargetTypes = + targetTypes + .Where( t => !SerializationTarget.BuiltInSerializerExists( configuration, t, t.GetCollectionTraits( CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) ); + } + + var generationContext = this.CreateGenerationContext( context, configuration ); + var generatorFactory = this.CreateGeneratorFactory( context ); + + foreach ( var targetType in realTargetTypes.Distinct() ) + { + var generator = generatorFactory( targetType ); + + var concreteType = default( Type ); + if ( targetType.GetIsInterface() || targetType.GetIsAbstract() ) + { + concreteType = context.DefaultCollectionTypes.GetConcreteType( targetType ); + } + + generator.BuildSerializerCode( generationContext, concreteType, null ); + } + + Directory.CreateDirectory( configuration.OutputDirectory ); + + return generationContext.Generate(); + } + + private static IEnumerable ExtractElementTypes( SerializationContext context, ISerializerGeneratorConfiguration configuration, Type type ) + { + if ( !SerializationTarget.BuiltInSerializerExists( configuration, type, type.GetCollectionTraits( CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) ) + { + yield return type; + + // Search dependents recursively if the type is NOT enum. + if ( !type.GetIsEnum() ) + { + foreach ( + var dependentType in + SerializationTarget.Prepare( context, type ) + .Members.Where( m => m.Member != null ).SelectMany( m => ExtractElementTypes( context, configuration, m.Member.GetMemberValueType() ) ) + ) + { + yield return dependentType; + } + } + } + + if ( type.IsArray ) + { + var elementType = type.GetElementType(); + if ( !SerializationTarget.BuiltInSerializerExists( configuration, elementType, elementType.GetCollectionTraits( CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false ) ) ) + { + foreach ( var descendant in ExtractElementTypes( context, configuration, elementType ) ) + { + yield return descendant; + } + + yield return elementType; + } + + yield break; + } + + if ( type.GetIsGenericType() ) + { + // Search generic arguments recursively. + foreach ( var elementType in type.GetGenericArguments().SelectMany( g => ExtractElementTypes( context, configuration, g ) ) ) + { + yield return elementType; + } + } + + if ( configuration.WithNullableSerializers && type.GetIsValueType() && Nullable.GetUnderlyingType( type ) == null ) + { + // Retrun nullable companion even if they always have built-in serializers. + yield return typeof( Nullable<> ).MakeGenericType( type ); + } + } + + protected abstract ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, TConfig configuration ); + + protected abstract Func CreateGeneratorFactory( SerializationContext context ); + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/DataMemberContract.cs b/src/MsgPack/Serialization/DataMemberContract.cs index 38b54d66d..75d610785 100644 --- a/src/MsgPack/Serialization/DataMemberContract.cs +++ b/src/MsgPack/Serialization/DataMemberContract.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 || NETSTANDARD1_1 using System.Globalization; using System.Reflection; using System.Runtime.Serialization; diff --git a/src/MsgPack/Serialization/DefaultSerializers/ArraySerializer.cs b/src/MsgPack/Serialization/DefaultSerializers/ArraySerializer.cs index cce934acb..e8ae27b3d 100644 --- a/src/MsgPack/Serialization/DefaultSerializers/ArraySerializer.cs +++ b/src/MsgPack/Serialization/DefaultSerializers/ArraySerializer.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack.Serialization.DefaultSerializers { diff --git a/src/MsgPack/Serialization/DefaultSerializers/DateTimeOffsetMessagePackSerializer.cs b/src/MsgPack/Serialization/DefaultSerializers/DateTimeOffsetMessagePackSerializer.cs index bb27b972a..837cca3f0 100644 --- a/src/MsgPack/Serialization/DefaultSerializers/DateTimeOffsetMessagePackSerializer.cs +++ b/src/MsgPack/Serialization/DefaultSerializers/DateTimeOffsetMessagePackSerializer.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Runtime.Serialization; #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/Serialization/DefaultSerializers/GenericSerializer.cs b/src/MsgPack/Serialization/DefaultSerializers/GenericSerializer.cs index e0df1a72a..e52b027bd 100644 --- a/src/MsgPack/Serialization/DefaultSerializers/GenericSerializer.cs +++ b/src/MsgPack/Serialization/DefaultSerializers/GenericSerializer.cs @@ -30,11 +30,11 @@ using System.Collections; #endif // !UNITY using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack.Serialization.DefaultSerializers { diff --git a/src/MsgPack/Serialization/DefaultSerializers/NullableMessagePackSerializer`1.cs b/src/MsgPack/Serialization/DefaultSerializers/NullableMessagePackSerializer`1.cs index 2bb2c5149..6175fb484 100644 --- a/src/MsgPack/Serialization/DefaultSerializers/NullableMessagePackSerializer`1.cs +++ b/src/MsgPack/Serialization/DefaultSerializers/NullableMessagePackSerializer`1.cs @@ -24,11 +24,11 @@ using System; #if DEBUG -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // DEBUG #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/Serialization/DependentAssemblyManager.cs b/src/MsgPack/Serialization/DependentAssemblyManager.cs new file mode 100644 index 000000000..0f10610bb --- /dev/null +++ b/src/MsgPack/Serialization/DependentAssemblyManager.cs @@ -0,0 +1,220 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Reflection; +#if FEATURE_CONCURRENT +using System.Collections.Concurrent; +using System.Threading; +#else +using System.Linq; +#endif // FEATURE_CONCURRENT + +namespace MsgPack.Serialization +{ + internal abstract class DependentAssemblyManager + { +#if FEATURE_CONCURRENT + + private static DependentAssemblyManager _default = new NullDependentAssemblyManager(); + + public static DependentAssemblyManager Default + { + get { return Volatile.Read( ref _default ); } + set { Volatile.Write( ref _default, value ); } + } + + private readonly ConcurrentDictionary _runtimeAssemblies; + + private readonly ConcurrentDictionary _compiledCodeDomSerializerAssemblies; + +#else + + private static volatile DependentAssemblyManager _default = new NullDependentAssemblyManager(); + + public static DependentAssemblyManager Default + { + get { return _default; } + set { _default = value; } + } + + private readonly object _syncRoot; + + private readonly Dictionary _runtimeAssemblies; + + private readonly Dictionary _compiledCodeDomSerializerAssemblies; + +#endif // FEATURE_CONCURRENT + + public IEnumerable CodeSerializerDependentAssemblies + { + get + { + // ReSharper disable JoinDeclarationAndInitializer + ICollection runtimeAssemblies; + ICollection compiledAssemblies; + // ReSharper restore JoinDeclarationAndInitializer +#if !FEATURE_CONCURRENT + lock ( this._syncRoot ) + { + runtimeAssemblies = this._runtimeAssemblies.Keys.ToArray(); + compiledAssemblies = this._compiledCodeDomSerializerAssemblies.Keys.ToArray(); + } +#else + runtimeAssemblies = this._runtimeAssemblies.Keys; + compiledAssemblies = this._compiledCodeDomSerializerAssemblies.Keys; +#endif // !FEATURE_CONCURRENT + + // FCL dependencies and msgpack core libs + foreach ( var runtimeAssembly in runtimeAssemblies ) + { + yield return runtimeAssembly; + } + + // dependents + foreach ( var compiledAssembly in compiledAssemblies ) + { + yield return compiledAssembly; + } + } + } + +#if FEATURE_CONCURRENT + + private string _dumpDirectory; + + public string DumpDirectory + { + get { return Volatile.Read( ref this._dumpDirectory ); } + set { Volatile.Write( ref this._dumpDirectory, value ); } + } + +#else + + private volatile string _dumpDirectory; + + public string DumpDirectory + { + get { return this._dumpDirectory; } + set { this._dumpDirectory = value; } + } + +#endif // FEATURE_CONCURRENT + + protected DependentAssemblyManager() + { +#if FEATURE_CONCURRENT + this._runtimeAssemblies = new ConcurrentDictionary( StringComparer.OrdinalIgnoreCase ); +#else + this._runtimeAssemblies = new Dictionary( StringComparer.OrdinalIgnoreCase ); +#endif // FEATURE_CONCURRENT + + this.ResetRuntimeAssemblies(); + +#if FEATURE_CONCURRENT + this._compiledCodeDomSerializerAssemblies = new ConcurrentDictionary( StringComparer.OrdinalIgnoreCase ); +#else + this._compiledCodeDomSerializerAssemblies = new Dictionary( StringComparer.OrdinalIgnoreCase ); + this._syncRoot = new object(); +#endif // FEATURE_CONCURRENT + } + + protected abstract IEnumerable GetRuntimeAssemblies(); + + private void ResetRuntimeAssemblies() + { + var assemblies = this.GetRuntimeAssemblies(); +#if !FEATURE_CONCURRENT + lock ( this._syncRoot ) + { +#endif // !FEATURE_CONCURRENT + this._runtimeAssemblies.Clear(); + foreach ( var assembly in assemblies ) + { + this._runtimeAssemblies[ assembly ] = null; + } +#if !FEATURE_CONCURRENT + } +#endif // !FEATURE_CONCURRENT + } + + public void AddRuntimeAssembly( string pathToAssembly ) + { +#if !FEATURE_CONCURRENT + lock ( this._syncRoot ) + { +#endif // !FEATURE_CONCURRENT + this._runtimeAssemblies[ pathToAssembly ] = null; +#if !FEATURE_CONCURRENT + } +#endif // !FEATURE_CONCURRENT + } + + public void AddCompiledCodeDomAssembly( string pathToAssembly ) + { +#if !FEATURE_CONCURRENT + lock ( this._syncRoot ) + { +#endif // !FEATURE_CONCURRENT + this._compiledCodeDomSerializerAssemblies[ pathToAssembly ] = null; +#if !FEATURE_CONCURRENT + } +#endif // !FEATURE_CONCURRENT + } + + public void ResetDependentAssemblies() + { +#if !FEATURE_CONCURRENT + lock ( this._syncRoot ) + { +#endif // !FEATURE_CONCURRENT + this.Record( this._compiledCodeDomSerializerAssemblies.Keys ); + this._compiledCodeDomSerializerAssemblies.Clear(); + this.ResetRuntimeAssemblies(); +#if !FEATURE_CONCURRENT + } +#endif // !FEATURE_CONCURRENT + } + + protected abstract void Record( IEnumerable assemblies ); + + public abstract void DeletePastTemporaries(); + + public virtual Assembly LoadAssembly( string path ) + { + throw new NotSupportedException(); + } + + private sealed class NullDependentAssemblyManager : DependentAssemblyManager + { + public NullDependentAssemblyManager() : base() { } + + protected override void Record( IEnumerable assemblies ) { } + + public override void DeletePastTemporaries() { } + + protected override IEnumerable GetRuntimeAssemblies() + { + yield break; + } + } + } +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/EmitterFlavor.cs b/src/MsgPack/Serialization/EmitterFlavor.cs index 4fc4aab41..ddd76f158 100644 --- a/src/MsgPack/Serialization/EmitterFlavor.cs +++ b/src/MsgPack/Serialization/EmitterFlavor.cs @@ -27,21 +27,27 @@ namespace MsgPack.Serialization /// internal enum EmitterFlavor { -#if !SILVERLIGHT +#if !SILVERLIGHT && !AOT /// /// Caches serializers for the members (de)serialization. /// It is default. /// FieldBased, -#endif // SILVERLIGHT -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !SILVERLIGHT + /// + /// Uses Reslyn SyntaxFactory code generation to (de)serialization. + /// It requires a long time but prevents runtime code generation at all. + /// + CodeTreeBased, + +#if !NETSTANDARD1_1 /// /// Uses code DOM code generation to (de)serialization. /// It requires a long time but prevents runtime code generation at all. /// CodeDomBased, -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !SILVERLIGHT +#endif // !NETSTANDARD1_1 +#endif // !SILVERLIGHT && !AOT /// /// Uses reflection to (de)serialization. diff --git a/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderEmittingContext.cs b/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderEmittingContext.cs index 0ee8b700e..b14a26b09 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderEmittingContext.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderEmittingContext.cs @@ -23,7 +23,11 @@ using System; using System.Collections.Generic; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Linq; using System.Reflection; #if FEATURE_TAP diff --git a/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderSerializerBuilder.cs b/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderSerializerBuilder.cs index 60ceb9a26..d771240f1 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderSerializerBuilder.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/AssemblyBuilderSerializerBuilder.cs @@ -20,7 +20,11 @@ using System; using System.Collections.Generic; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/EmittingSerializers/SerializationMethodGeneratorManager.cs b/src/MsgPack/Serialization/EmittingSerializers/SerializationMethodGeneratorManager.cs index 98666eac3..f17d933a3 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/SerializationMethodGeneratorManager.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/SerializationMethodGeneratorManager.cs @@ -20,7 +20,11 @@ using System; using System.Diagnostics; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Reflection; using System.Reflection.Emit; using System.Security; diff --git a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.cs b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.cs index 8064654f1..3db76d09c 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.cs @@ -20,7 +20,11 @@ using System; using System.Collections.Generic; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.enum.cs b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.enum.cs index 1c48a3cd3..844d2bb6f 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.enum.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.enum.cs @@ -19,7 +19,11 @@ #endregion -- License Terms -- using System; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Linq.Expressions; using System.Reflection; using System.Reflection.Emit; diff --git a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.object.cs b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.object.cs index a8af381b7..54f648cb1 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.object.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/SerializerEmitter.object.cs @@ -20,7 +20,11 @@ using System; using System.Collections.Generic; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Linq; using System.Linq.Expressions; using System.Reflection; diff --git a/src/MsgPack/Serialization/EmittingSerializers/VariableILConstruct.cs b/src/MsgPack/Serialization/EmittingSerializers/VariableILConstruct.cs index ac431bb5d..655bb85e2 100644 --- a/src/MsgPack/Serialization/EmittingSerializers/VariableILConstruct.cs +++ b/src/MsgPack/Serialization/EmittingSerializers/VariableILConstruct.cs @@ -19,11 +19,11 @@ #endregion -- License Terms -- using System; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using MsgPack.Serialization.AbstractSerializers; diff --git a/src/MsgPack/Serialization/EnumSerializationOptions.cs b/src/MsgPack/Serialization/EnumSerializationOptions.cs index 75d0f9100..a42a28c58 100644 --- a/src/MsgPack/Serialization/EnumSerializationOptions.cs +++ b/src/MsgPack/Serialization/EnumSerializationOptions.cs @@ -27,11 +27,11 @@ #endif // NETFX_35 || UNITY || SILVERLIGHT using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Threading; namespace MsgPack.Serialization diff --git a/src/MsgPack/Serialization/ExtTypeCodeMapping.cs b/src/MsgPack/Serialization/ExtTypeCodeMapping.cs index 3934191a4..89b45c447 100644 --- a/src/MsgPack/Serialization/ExtTypeCodeMapping.cs +++ b/src/MsgPack/Serialization/ExtTypeCodeMapping.cs @@ -27,11 +27,11 @@ #endif // !NETFX_40 && !NETFX_35 && !UNITY && !SILVERLIGHT using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; #if NETFX_45 diff --git a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs index f59f7773d..a744bc229 100644 --- a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs +++ b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack.Serialization { diff --git a/src/MsgPack/Serialization/MessagePackSerializer.Factories.cs b/src/MsgPack/Serialization/MessagePackSerializer.Factories.cs index 7e85b05fc..9383c70f8 100644 --- a/src/MsgPack/Serialization/MessagePackSerializer.Factories.cs +++ b/src/MsgPack/Serialization/MessagePackSerializer.Factories.cs @@ -26,9 +26,9 @@ #define AOT #endif -#if !AOT && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT #define FEATURE_EMIT -#endif // !AOT && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT using System; using System.IO; @@ -42,17 +42,19 @@ #else // !SILVERLIGHT && !NETFX_35 && !UNITY using System.Collections.Generic; #endif // !SILVERLIGHT && !NETFX_35 && !UNITY -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if NETFX_CORE || WINDOWS_PHONE using System.Linq.Expressions; #endif #if FEATURE_EMIT using MsgPack.Serialization.AbstractSerializers; +#if !NETSTANDARD1_1 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; #endif // FEATURE_EMIT @@ -255,20 +257,12 @@ internal static MessagePackSerializer CreateInternal( SerializationContext ISerializerBuilder builder; switch ( context.SerializerOptions.EmitterFlavor ) { +#if !NETSTANDARD1_1 case EmitterFlavor.CodeDomBased: +#endif // !NETSTANDARD1_! + case EmitterFlavor.CodeTreeBased: { - if ( !SerializerDebugging.OnTheFlyCodeDomEnabled ) - { - throw new NotSupportedException( - String.Format( - CultureInfo.CurrentCulture, - "Flavor '{0:G}'({0:D}) is not supported for serializer instance creation.", - context.SerializerOptions.EmitterFlavor - ) - ); - } - - builder = new CodeDomSerializerBuilder( typeof( T ), collectionTraits ); + builder = SerializerDebugging.CreateOnTheFlyCodeGenerationSerializerBuilder( typeof( T ), collectionTraits, context.SerializerOptions.EmitterFlavor ); break; } case EmitterFlavor.FieldBased: @@ -279,7 +273,7 @@ internal static MessagePackSerializer CreateInternal( SerializationContext default: // EmitterFlavor.ReflectionBased { #endif // FEATURE_EMIT - return + return GenericSerializer.TryCreateAbstractCollectionSerializer( context, typeof( T ), concreteType, schema ) as MessagePackSerializer ?? CreateReflectionInternal( context, concreteType ?? typeof( T ), schema ); #if FEATURE_EMIT diff --git a/src/MsgPack/Serialization/Metadata/_IEnumreator.cs b/src/MsgPack/Serialization/Metadata/_IEnumreator.cs index a6a9475f9..d6e88037a 100644 --- a/src/MsgPack/Serialization/Metadata/_IEnumreator.cs +++ b/src/MsgPack/Serialization/Metadata/_IEnumreator.cs @@ -22,7 +22,11 @@ using System.Collections; using System.Collections.Generic; #if DEBUG +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 #endif // DEBUG using System.Reflection; diff --git a/src/MsgPack/Serialization/Metadata/_UnpackHelpers.direct.cs b/src/MsgPack/Serialization/Metadata/_UnpackHelpers.direct.cs index 0741e09ae..9c0985215 100644 --- a/src/MsgPack/Serialization/Metadata/_UnpackHelpers.direct.cs +++ b/src/MsgPack/Serialization/Metadata/_UnpackHelpers.direct.cs @@ -20,11 +20,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Reflection; namespace MsgPack.Serialization.Metadata diff --git a/src/MsgPack/Serialization/PackHelpers.cs b/src/MsgPack/Serialization/PackHelpers.cs index 6182e4bf6..c97dad3bf 100644 --- a/src/MsgPack/Serialization/PackHelpers.cs +++ b/src/MsgPack/Serialization/PackHelpers.cs @@ -32,11 +32,11 @@ #if !UNITY || MSGPACK_UNITY_FULL using System.ComponentModel; #endif //!UNITY || MSGPACK_UNITY_FULL -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if FEATURE_TAP using System.Threading; using System.Threading.Tasks; diff --git a/src/MsgPack/Serialization/Polymorphic/RuntimeTypeVerifier.cs b/src/MsgPack/Serialization/Polymorphic/RuntimeTypeVerifier.cs index 8a9a1fef2..3eeec3dc5 100644 --- a/src/MsgPack/Serialization/Polymorphic/RuntimeTypeVerifier.cs +++ b/src/MsgPack/Serialization/Polymorphic/RuntimeTypeVerifier.cs @@ -29,11 +29,11 @@ using System; using System.Collections.Generic; #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT using System.Globalization; using System.Reflection; diff --git a/src/MsgPack/Serialization/PolymorphicTypeVerificationContext.cs b/src/MsgPack/Serialization/PolymorphicTypeVerificationContext.cs index 835c1a394..e75d94611 100644 --- a/src/MsgPack/Serialization/PolymorphicTypeVerificationContext.cs +++ b/src/MsgPack/Serialization/PolymorphicTypeVerificationContext.cs @@ -28,11 +28,11 @@ using System; #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT using System.Reflection; diff --git a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs index e8d0ab476..24165b3f4 100644 --- a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs +++ b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs @@ -26,11 +26,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; diff --git a/src/MsgPack/Serialization/PolymorphismSchema.cs b/src/MsgPack/Serialization/PolymorphismSchema.cs index 8f1c2a544..6368c64e4 100644 --- a/src/MsgPack/Serialization/PolymorphismSchema.cs +++ b/src/MsgPack/Serialization/PolymorphismSchema.cs @@ -174,7 +174,7 @@ private PolymorphismSchema TryGetKeySchema() } } -#if NETFX_35 || NETFX_40 || SILVERLIGHT || UNITY || CORE_CLR +#if NETFX_35 || NETFX_40 || SILVERLIGHT || UNITY || CORE_CLR || NETSTANDARD1_1 private sealed class ReadOnlyDictionary : IDictionary { private readonly IDictionary _underlying; diff --git a/src/MsgPack/Serialization/Reflection/GenericTypeExtensions.cs b/src/MsgPack/Serialization/Reflection/GenericTypeExtensions.cs index 42562c44c..ed108316b 100644 --- a/src/MsgPack/Serialization/Reflection/GenericTypeExtensions.cs +++ b/src/MsgPack/Serialization/Reflection/GenericTypeExtensions.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; #if NETFX_CORE using System.Reflection; diff --git a/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs b/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs index e83701f96..4d3d25d4f 100644 --- a/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs +++ b/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Reflection; using System.Text; diff --git a/src/MsgPack/Serialization/Reflection/TracingILGenerator.conveniences.cs b/src/MsgPack/Serialization/Reflection/TracingILGenerator.conveniences.cs index 88fe68ae1..879486341 100644 --- a/src/MsgPack/Serialization/Reflection/TracingILGenerator.conveniences.cs +++ b/src/MsgPack/Serialization/Reflection/TracingILGenerator.conveniences.cs @@ -19,7 +19,11 @@ #endregion -- License Terms -- using System; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Globalization; using System.Reflection; using System.Reflection.Emit; diff --git a/src/MsgPack/Serialization/Reflection/TracingILGenerator.cs b/src/MsgPack/Serialization/Reflection/TracingILGenerator.cs index b6020038d..74bbb1a43 100644 --- a/src/MsgPack/Serialization/Reflection/TracingILGenerator.cs +++ b/src/MsgPack/Serialization/Reflection/TracingILGenerator.cs @@ -21,11 +21,11 @@ using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR +#if CORE_CLR || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR +#endif // CORE_CLR || NETSTANDARD1_1 using System.Globalization; using System.IO; using System.Reflection; @@ -197,20 +197,19 @@ public TracingILGenerator( MethodBuilder methodBuilder, TextWriter traceWriter ) { Contract.Assert( methodBuilder != null ); } +#endif // DEBUG -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 /// /// Initializes a new instance of the class. /// /// The dynamic method. /// The trace writer. - public TracingILGenerator( DynamicMethod dynamicMethod, TextWriter traceWriter ) - : this( dynamicMethod != null ? dynamicMethod.GetILGenerator() : null, true, traceWriter, false ) + /// true if the underlying builders are debuggable; othersie false. + public TracingILGenerator( DynamicMethod dynamicMethod, TextWriter traceWriter, bool isDebuggable ) + : this( dynamicMethod != null ? dynamicMethod.GetILGenerator() : null, true, traceWriter, isDebuggable ) { Contract.Assert( dynamicMethod != null ); } -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 -#endif // DEBUG // TODO: NLIblet @@ -277,7 +276,6 @@ public void FlushTrace() #region -- Locals -- -#if DEBUG /// /// Declare local without pinning and name for debugging. /// @@ -292,6 +290,7 @@ public LocalBuilder DeclareLocal( Type localType ) return this.DeclareLocalCore( localType, null ); } +#if DEBUG /// /// Declare local without name for debugging. /// diff --git a/src/MsgPack/Serialization/Reflection/TracingILGenerator.emits.cs b/src/MsgPack/Serialization/Reflection/TracingILGenerator.emits.cs index 65f3f151d..c7f9c205c 100644 --- a/src/MsgPack/Serialization/Reflection/TracingILGenerator.emits.cs +++ b/src/MsgPack/Serialization/Reflection/TracingILGenerator.emits.cs @@ -23,7 +23,11 @@ using System; using System.Diagnostics.CodeAnalysis; +#if NETSTANDARD1_1 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.Linq; using System.Reflection.Emit; using System.Runtime.CompilerServices; diff --git a/src/MsgPack/Serialization/ReflectionExtensions.cs b/src/MsgPack/Serialization/ReflectionExtensions.cs index 70764f606..c96f61c9d 100644 --- a/src/MsgPack/Serialization/ReflectionExtensions.cs +++ b/src/MsgPack/Serialization/ReflectionExtensions.cs @@ -29,14 +29,15 @@ using System.Collections; using System.Collections.Generic; using System.Diagnostics; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; +using System.Reflection.Emit; using MsgPack.Serialization.Reflection; @@ -146,6 +147,158 @@ private static Exception HoistUpInnerException( TargetInvocationException target } } +#warning TODO: Remove System.Linq.Expressions + public static Type[] GetParameterTypes( this MethodBase source ) + { + var parameters = source.GetParameters(); + Type[] parameterTypes = new Type[ parameters.Length ]; + for ( var i = 0; i < parameters.Length; i++ ) + { + parameterTypes[ i ] = parameters[ i ].ParameterType; + } + + return parameterTypes; + } + + public static Func CreateConstructorDelegate() + { + return CreateConstructorDelegate( typeof( T ) ); + } + + public static Func CreateConstructorDelegate( this Type source ) + { + ValidateInstanceType( source, typeof( T ) ); + + ConstructorInfo defaultConstructor = null; + + if ( !typeof( T ).GetIsValueType() ) + { + defaultConstructor = typeof( T ).GetConstructor( ReflectionAbstractions.EmptyTypes ); + + if ( defaultConstructor == null ) + { + throw new InvalidOperationException( + String.Format( + CultureInfo.CurrentCulture, + "There are no default constructors in type '{0}'.", + typeof( T ) + ) + ); + } + } + +#if AOT || SILVERLIGHT + return new Func( () => ( T ) defaultConstructor.InvokePreservingExceptionType() ); +#else + return ( Func )CreateDelegate( typeof( Func ), typeof( T ), defaultConstructor, ReflectionAbstractions.EmptyTypes ); +#endif // AOT || SILVERLIGHT + } + + + public static Func CreateConstructorDelegate() + { + return CreateConstructorDelegate( typeof( T ) ); + } + + public static Func CreateConstructorDelegate( this Type source ) + { + ValidateInstanceType( source, typeof( T ) ); + var parameterTypes = new[] { typeof( TArg ) }; + +#if AOT || SILVERLIGHT + return new Func( a => ( T )GetConstructor( typeof( T ), parameterTypes ).InvokePreservingExceptionType( a ) ); +#else + return ( Func )CreateDelegate( typeof( Func ), typeof( T ), GetConstructor( typeof( T ), parameterTypes ), parameterTypes ); +#endif // AOT || SILVERLIGHT + } + + private static void ValidateInstanceType( Type source, Type returnType ) + { + if ( source == null ) + { + throw new ArgumentNullException( "source" ); + } + + if ( !returnType.IsAssignableFrom( source ) ) + { + throw new InvalidOperationException( + String.Format( + CultureInfo.CurrentCulture, + "The instance type '{0}' is not assignable to return type '{1}'.", + source, + returnType + ) + ); + } + + } + + private static ConstructorInfo GetConstructor( Type source, Type[] parameterTypes ) + { + // Avoid LINQ for performance here. + foreach ( var candidate in source.GetConstructors() ) + { + var parameters = candidate.GetParameters(); + if ( parameters.Length == parameterTypes.Length ) + { + bool typesAreMatch = true; + for ( var i = 0; i < parameterTypes.Length; i++ ) + { + if ( parameters[ i ].ParameterType != parameterTypes[ i ] ) + { + typesAreMatch = false; + break; + } + } + + if ( typesAreMatch ) + { + return candidate; + } + } + } + + throw new InvalidOperationException( + String.Format( + CultureInfo.CurrentCulture, + "There are no constructors in type '{0}' which matches parameter types '{1}'.", + source, + String.Join( ", ", parameterTypes.Select( t => t.GetFullName() ).ToArray() ) + ) + ); + } + +#if !AOT && !SILVERLIGHT + + private static Delegate CreateDelegate( Type delegateType, Type targetType, ConstructorInfo constructor, Type[] parameterTypes ) + { + var dynamicMethod = + new DynamicMethod( "Create" + targetType.Name, targetType, parameterTypes, restrictedSkipVisibility: true ); + var il = new TracingILGenerator( dynamicMethod, NullTextWriter.Instance, isDebuggable: false ); + if ( constructor == null ) + { + // Value type's init. + il.DeclareLocal( targetType ); + il.EmitAnyLdloca( 0 ); + il.EmitInitobj( targetType ); + il.EmitAnyLdloc( 0 ); + } + else + { + for ( var i = 0; i < parameterTypes.Length; i++ ) + { + il.EmitAnyLdarg( i ); + } + + il.EmitNewobj( constructor ); + } + + il.EmitRet(); + return dynamicMethod.CreateDelegate( delegateType ); + } + +#endif // !AOT && !SILVERLIGHT + public static Type GetMemberValueType( this MemberInfo source ) { if ( source == null ) @@ -968,4 +1121,184 @@ private struct GenericCollectionTypes // ReSharper restore InconsistentNaming } } + +#warning TODO: Move out + internal sealed class FieldInfoEqualityComparer : EqualityComparer + { + public static readonly FieldInfoEqualityComparer Instance = new FieldInfoEqualityComparer(); + + private FieldInfoEqualityComparer() { } + + public override bool Equals( FieldInfo left, FieldInfo right ) + { + if ( ReferenceEquals( left, right ) ) + { + return true; + } + + if ( left == null ) + { + return right == null; + } + else if ( right == null ) + { + return false; + } + + // This assembly should work in netstandard1.3, + // so we cannot use MemberInfo.MetadataToken here. + // Therefore, it compares honestly referring ECMA-335 I.8.6.1.6 Signature Matching. + // "For signatures other than method signatures two signatures are said to match if and only if every + // component type of the signature is identical in the two signatures." + + if ( !Object.Equals( left.DeclaringType, right.DeclaringType ) ) + { + return false; + } + + if ( !Object.Equals( left.FieldType, right.FieldType ) ) + { + return false; + } + + if ( left.Name != right.Name ) + { + return false; + } + + return true; + } + + public override int GetHashCode( FieldInfo obj ) + { + if ( obj == null ) + { + return 0; + } + + var hashCode = obj.DeclaringType.GetHashCode(); + hashCode ^= obj.Name.GetHashCode(); + return hashCode; + } + } + + internal sealed class MethodBaseEqualityComparer : EqualityComparer + { + public static readonly MethodBaseEqualityComparer Instance = new MethodBaseEqualityComparer(); + + private MethodBaseEqualityComparer() { } + + public sealed override bool Equals( MethodBase left, MethodBase right ) + { + if ( ReferenceEquals( left, right ) ) + { + return true; + } + + if ( left == null ) + { + return right == null; + } + else if ( right == null ) + { + return false; + } + + // This assembly should work in netstandard1.3, + // so we cannot use MemberInfo.MetadataToken here. + // Therefore, it compares honestly referring ECMA-335 I.8.6.1.6 Signature Matching. + // " Two method signatures are said to match if and only if: + // * the calling conventions are identical; + // * both signatures are either static or instance; + // * the number of generic parameters is identical, if the method is generic; + // * for instance signatures the type of the this pointer of the overriding / hiding signature is assignable-to(I.8.7) + // the type of the this pointer of the overridden / hidden signature; + // * the number and type signatures of the parameters are identical; and + // * the type signatures for the result are identical" + + if ( !Object.Equals( left.DeclaringType, right.DeclaringType ) ) + { + return false; + } + + var leftMethodInfo = left as MethodInfo; + if ( leftMethodInfo != null ) + { + var rightMethodInfo = right as MethodInfo; + if ( rightMethodInfo == null ) + { + return false; + } + + if ( !Object.Equals( leftMethodInfo.ReturnType, rightMethodInfo.ReturnType ) ) + { + return false; + } + } + + if ( left.CallingConvention != right.CallingConvention ) + { + return false; + } + + if ( left.IsStatic != right.IsStatic ) + { + return false; + } + + if ( left.Name != right.Name ) + { + return false; + } + + var leftGenericParameters = left.GetGenericArguments(); + var rightGenericParameters = right.GetGenericArguments(); + if ( leftGenericParameters.Length != rightGenericParameters.Length ) + { + return false; + } + + for ( int i = 0; i < leftGenericParameters.Length; i++ ) + { + if ( !Object.Equals( leftGenericParameters[ i ], rightGenericParameters[ i ] ) ) + { + return false; + } + } + + var leftParameters = left.GetParameters(); + var rightParameters = right.GetParameters(); + if ( leftParameters.Length != rightParameters.Length ) + { + return false; + } + + for ( int i = 0; i < leftParameters.Length; i++ ) + { + if ( !Object.Equals( leftParameters[ i ].ParameterType, rightParameters[ i ].ParameterType ) ) + { + return false; + } + } + + return true; + } + + public sealed override int GetHashCode( MethodBase obj ) + { + if ( obj == null ) + { + return 0; + } + + var hashCode = obj.DeclaringType.GetHashCode(); + hashCode ^= obj.Name.GetHashCode(); + foreach ( ParameterInfo parameter in obj.GetParameters() ) + { + hashCode ^= parameter.ParameterType.GetHashCode(); + } + + return hashCode; + } + } } diff --git a/src/MsgPack/Serialization/ReflectionHelpers.cs b/src/MsgPack/Serialization/ReflectionHelpers.cs index 6eacafc55..bd456bdfe 100644 --- a/src/MsgPack/Serialization/ReflectionHelpers.cs +++ b/src/MsgPack/Serialization/ReflectionHelpers.cs @@ -28,11 +28,11 @@ using System; using System.Linq; -#if UNITY +#if UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // UNITY +#endif // UNITY || NETSTANDARD1_1 #if !UNITY || MSGPACK_UNITY_FULL using System.ComponentModel; #endif //!UNITY || MSGPACK_UNITY_FULL diff --git a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs index 68969be95..498c80b80 100644 --- a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs +++ b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs @@ -28,11 +28,11 @@ using System; using System.Collections; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Reflection; #if FEATURE_TAP diff --git a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionSerializerHelper.cs b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionSerializerHelper.cs index 740a84d74..5b2affe3a 100644 --- a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionSerializerHelper.cs +++ b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionSerializerHelper.cs @@ -30,11 +30,11 @@ using System.Collections; using System.Collections.Generic; using System.Globalization; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Reflection; using System.Runtime.Serialization; diff --git a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionTupleMessagePackSerializer`1.cs b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionTupleMessagePackSerializer`1.cs index e53ff1c0b..1332720f1 100644 --- a/src/MsgPack/Serialization/ReflectionSerializers/ReflectionTupleMessagePackSerializer`1.cs +++ b/src/MsgPack/Serialization/ReflectionSerializers/ReflectionTupleMessagePackSerializer`1.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; using System.Reflection; #if FEATURE_TAP diff --git a/src/MsgPack/Serialization/ResolveSerializerEventArgs.cs b/src/MsgPack/Serialization/ResolveSerializerEventArgs.cs index b911cb5f1..69c6e0f13 100644 --- a/src/MsgPack/Serialization/ResolveSerializerEventArgs.cs +++ b/src/MsgPack/Serialization/ResolveSerializerEventArgs.cs @@ -24,11 +24,11 @@ using System; #if DEBUG -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // DEBUG using System.Globalization; diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs index f9ad549a5..aa7f4bccc 100644 --- a/src/MsgPack/Serialization/SerializationContext.cs +++ b/src/MsgPack/Serialization/SerializationContext.cs @@ -32,11 +32,11 @@ #else // !SILVERLIGHT && !NETFX_35 && !UNITY using System.Collections.Generic; #endif // !SILVERLIGHT && !NETFX_35 && !UNITY -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if UNITY || NETSTANDARD1_1 || NETSTANDARD1_3 using System.Linq; #endif // UNITY || NETSTANDARD1_1 || NETSTANDARD1_3 diff --git a/src/MsgPack/Serialization/SerializationExceptions.cs b/src/MsgPack/Serialization/SerializationExceptions.cs index 46f8c200b..3576bad95 100644 --- a/src/MsgPack/Serialization/SerializationExceptions.cs +++ b/src/MsgPack/Serialization/SerializationExceptions.cs @@ -27,11 +27,11 @@ #if !UNITY || MSGPACK_UNITY_FULL using System.ComponentModel; #endif // !UNITY || MSGPACK_UNITY_FULL -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; #if !UNITY using System.Reflection; diff --git a/src/MsgPack/Serialization/SerializationTarget.cs b/src/MsgPack/Serialization/SerializationTarget.cs index 9dff56efd..1e6474982 100644 --- a/src/MsgPack/Serialization/SerializationTarget.cs +++ b/src/MsgPack/Serialization/SerializationTarget.cs @@ -31,11 +31,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.Linq; using System.Reflection; @@ -712,12 +712,12 @@ public static string GetTupleItemNameFromIndex( int i ) } #endif // !NETFX_35 -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !AOT +#if !SILVERLIGHT && !AOT public static bool BuiltInSerializerExists( ISerializerGeneratorConfiguration configuration, Type type, CollectionTraits traits ) { return GenericSerializer.IsSupported( type, traits, configuration.PreferReflectionBasedSerializer ) || SerializerRepository.InternalDefault.Contains( type ); } -#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !AOT +#endif // !SILVERLIGHT && !AOT private sealed class MemberConstructorParameterEqualityComparer : EqualityComparer> { diff --git a/src/MsgPack/Serialization/SerializerCodeGenerationConfiguration.cs b/src/MsgPack/Serialization/SerializerCodeGenerationConfiguration.cs index 68c1c8f0b..a953d13d0 100644 --- a/src/MsgPack/Serialization/SerializerCodeGenerationConfiguration.cs +++ b/src/MsgPack/Serialization/SerializerCodeGenerationConfiguration.cs @@ -236,6 +236,31 @@ public SerializationCompatibilityOptions CompatibilityOptions /// public bool WithAsync { get; set; } + private string _providerName; + +#warning TODO: mpu + /// + /// Gets or sets a code provider name. + /// + /// + /// A code provider name. Setting null causes setting empty string which represents default provider. + /// + public string ProviderName + { + get { return this._providerName; } + set { this._providerName = value ?? String.Empty; } + } + +#warning TODO: mpu + /// + /// Gets or sets a value indicating whether generated serializers will not be qualified with or not. + /// + /// + /// true if generated serializers will not be qualified with ; otherwise, false. + /// Default is false. + /// + public bool SuppressDebuggerNonUserCodeAttribute { get; set; } + /// /// Initializes a new instance of the class. /// diff --git a/src/MsgPack/Serialization/SerializerDebugging.cs b/src/MsgPack/Serialization/SerializerDebugging.cs index ee8724d48..8bc8d0b9d 100644 --- a/src/MsgPack/Serialization/SerializerDebugging.cs +++ b/src/MsgPack/Serialization/SerializerDebugging.cs @@ -24,15 +24,14 @@ #endif using System; -#if !NETFX_35 && !UNITY && !WINDOWS_PHONE -using System.Collections.Concurrent; -#endif // !NETFX_35 && !UNITY && !WINDOWS_PHONE +#if FEATURE_CONCURRENT +#endif // FEATURE_CONCURRENT using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.IO; using System.Linq; @@ -41,6 +40,13 @@ using System.Runtime.CompilerServices; using System.Threading; +#if !AOT && !SILVERLIGHT +using MsgPack.Serialization.AbstractSerializers; +#if !NETSTANDARD1_1 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 +#endif // !AOT && !SILVERLIGHT + namespace MsgPack.Serialization { /// @@ -65,7 +71,6 @@ public static bool TraceEnabled set { _traceEnabled = value; } } -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 [ThreadStatic] private static bool _dumpEnabled; @@ -81,7 +86,6 @@ public static bool DumpEnabled get { return _dumpEnabled; } set { _dumpEnabled = value; } } -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 #endif // !AOT [ThreadStatic] @@ -182,8 +186,9 @@ public static void FlushTraceData() Tracer.Emit.TraceData( Tracer.EventType.DefineType, Tracer.EventId.DefineType, _ilTraceWriter.ToString() ); _ilTraceWriter.GetStringBuilder().Length = 0; } +#endif // !AOT && !SILVERLIGHT -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !NETSTANDARD1_1 && !SILVERLIGHT && !AOT [ThreadStatic] private static AssemblyBuilder _assemblyBuilder; @@ -220,193 +225,119 @@ public static void PrepareDump() _moduleBuilder = _assemblyBuilder.DefineDynamicModule( "ExpressionTreeSerializerLogics", "ExpressionTreeSerializerLogics.dll", true ); } +#endif // !NETSTANDARD1_1 && !SILVERLIGHT && !AOT - [ThreadStatic] - private static IList _runtimeAssemblies; +#if !AOT && !SILVERLIGHT +#if FEATURE_CONCURRENT - [ThreadStatic] - private static IList _compiledCodeDomSerializerAssemblies; + private static DependentAssemblyManager _dependentAssemblyManager = DependentAssemblyManager.Default; - public static IEnumerable CodeDomSerializerDependentAssemblies + public static DependentAssemblyManager DependentAssemblyManager { - get - { - EnsureDependentAssembliesListsInitialized(); -#if DEBUG - Contract.Assert( _compiledCodeDomSerializerAssemblies != null ); -#endif // DEBUG - // FCL dependencies and msgpack core libs - foreach ( var runtimeAssembly in _runtimeAssemblies ) - { - yield return runtimeAssembly; - } + get { return Volatile.Read( ref _dependentAssemblyManager ); } + set { Volatile.Write( ref _dependentAssemblyManager, value ); } + } - // dependents - foreach ( var compiledAssembly in _compiledCodeDomSerializerAssemblies ) - { - yield return compiledAssembly; - } - } +#else + + private static volatile DependentAssemblyManager _dependentAssemblyManager = DependentAssemblyManager.Default; + + public static DependentAssemblyManager DependentAssemblyManager + { + get { return _dependentAssemblyManager; } + set { _dependentAssemblyManager = value; } } -#endif // !SILVERLIGHT -#if NETSTANDARD1_1 || NETSTANDARD1_3 - [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "pathToAssembly", Justification = "For API compatibility" )] -#endif // NETSTANDARD1_1 || NETSTANDARD1_3 + +#endif // FEATURE_CONCURRENT + + public static IEnumerable CodeSerializerDependentAssemblies + { + get { return _dependentAssemblyManager.CodeSerializerDependentAssemblies; } + } + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void AddRuntimeAssembly( string pathToAssembly ) { -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 - EnsureDependentAssembliesListsInitialized(); - _runtimeAssemblies.Add( pathToAssembly ); -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + _dependentAssemblyManager.AddRuntimeAssembly( pathToAssembly ); } -#if NETSTANDARD1_1 || NETSTANDARD1_3 [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "pathToAssembly", Justification = "For API compatibility" )] -#endif // NETSTANDARD1_1 || NETSTANDARD1_3 [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void AddCompiledCodeDomAssembly( string pathToAssembly ) { -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 - EnsureDependentAssembliesListsInitialized(); - _compiledCodeDomSerializerAssemblies.Add( pathToAssembly ); -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + _dependentAssemblyManager.AddCompiledCodeDomAssembly( pathToAssembly ); } [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void ResetDependentAssemblies() { -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 - EnsureDependentAssembliesListsInitialized(); - -#if !NETFX_35 - File.AppendAllLines( GetHistoryFilePath(), _compiledCodeDomSerializerAssemblies ); -#else - File.AppendAllText( GetHistoryFilePath(), String.Join( Environment.NewLine, _compiledCodeDomSerializerAssemblies.ToArray() ) + Environment.NewLine ); -#endif // !NETFX_35 - _compiledCodeDomSerializerAssemblies.Clear(); - ResetRuntimeAssemblies(); -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + _dependentAssemblyManager.ResetDependentAssemblies(); } - private static string _dumpDirectory; - public static string DumpDirectory { - get { return Interlocked.CompareExchange( ref _dumpDirectory, null, null ); } - set { Interlocked.Exchange( ref _dumpDirectory, value ); } + get { return _dependentAssemblyManager.DumpDirectory; } + set { _dependentAssemblyManager.DumpDirectory = value; } } -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 - private static int _wasDeleted; - private const string HistoryFile = "MsgPack.Serialization.SerializationGenerationDebugging.CodeDOM.History.txt"; - [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void DeletePastTemporaries() { - if ( Interlocked.CompareExchange( ref _wasDeleted, 1, 0 ) != 0 ) - { - return; - } - - try - { - var historyFilePath = GetHistoryFilePath(); - if ( !File.Exists( historyFilePath ) ) - { - return; - } - - foreach ( var pastAssembly in File.ReadAllLines( historyFilePath ) ) - { - if ( !String.IsNullOrEmpty( pastAssembly ) ) - { - File.Delete( pastAssembly ); - } - } - - new FileStream( historyFilePath, FileMode.Truncate ).Close(); - } - catch ( IOException ) { } + _dependentAssemblyManager.DeletePastTemporaries(); } - [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] - private static string GetHistoryFilePath() + public static Assembly LoadAssembly( string path ) { - return Path.Combine( Path.GetTempPath(), HistoryFile ); + return _dependentAssemblyManager.LoadAssembly( path ); } - private static void EnsureDependentAssembliesListsInitialized() - { - if ( _runtimeAssemblies == null ) - { - _runtimeAssemblies = new List(); - ResetRuntimeAssemblies(); - } - - if ( _compiledCodeDomSerializerAssemblies == null ) - { - _compiledCodeDomSerializerAssemblies = new List(); - } - } - - private static void ResetRuntimeAssemblies() - { - _runtimeAssemblies.Add( "System.dll" ); -#if NETFX_35 - _runtimeAssemblies.Add( typeof( Enumerable ).Assembly.Location ); -#else - _runtimeAssemblies.Add( "System.Core.dll" ); - _runtimeAssemblies.Add( "System.Numerics.dll" ); -#endif // NETFX_35 - _runtimeAssemblies.Add( typeof( SerializerDebugging ).Assembly.Location ); - } -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - [ThreadStatic] - private static bool _onTheFlyCodeDomEnabled; + private static Func _onTheFlyCodeGenerationSerializerBuilderFactory; [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] - public static bool OnTheFlyCodeDomEnabled + public static bool OnTheFlyCodeGenerationEnabled { - get { return _onTheFlyCodeDomEnabled; } - set { _onTheFlyCodeDomEnabled = value; } + get { return _onTheFlyCodeGenerationSerializerBuilderFactory != null; } } -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 - /// - /// Creates the new type builder for the serializer. - /// - /// The serialization target type. - /// - /// PrepareDump() was not called. - [Obsolete( "", true )] - [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] - public static TypeBuilder NewTypeBuilder( Type targetType ) + public static ISerializerBuilder CreateOnTheFlyCodeGenerationSerializerBuilder( Type targetType, CollectionTraits collectionTraits, EmitterFlavor emitterFlavor ) { - if ( _moduleBuilder == null ) + var factory = _onTheFlyCodeGenerationSerializerBuilderFactory; + + if ( factory == null ) { - throw new InvalidOperationException( "PrepareDump() was not called." ); + throw new NotSupportedException( + String.Format( + CultureInfo.CurrentCulture, + "Flavor '{0:G}'({0:D}) is not supported for serializer instance creation.", + emitterFlavor + ) + ); } - return - _moduleBuilder.DefineType( IdentifierUtility.EscapeTypeName( targetType ) + "SerializerLogics" ); + return factory( targetType, collectionTraits ); + } + + public static void SetOnTheFlyCodeGenerationBuilderFactory( Func factory ) + { + _onTheFlyCodeGenerationSerializerBuilderFactory = factory; } +#if !NETSTANDARD1_1 + /// /// Takes dump of instructions. /// [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void Dump() { -#if !NETFX_35 if ( _assemblyBuilder != null ) { _assemblyBuilder.Save( _assemblyBuilder.GetName().Name + ".dll" ); } -#endif // !NETFX_35 } -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + +#endif // !NETSTANDARD1_1 /// /// Resets debugging states. @@ -414,11 +345,11 @@ public static void Dump() [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] public static void Reset() { -#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !NETSTANDARD1_1 _assemblyBuilder = null; _moduleBuilder = null; _dumpEnabled = false; -#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !NETSTANDARD1_1 if ( _ilTraceWriter != null ) { @@ -431,29 +362,29 @@ public static void Reset() } #endif // !AOT && !SILVERLIGHT -#if NETFX_35 || UNITY || SILVERLIGHT +#if !FEATURE_CONCURRENT private static int _useLegacyNullMapEntryHandling; #else private static bool _useLegacyNullMapEntryHandling; -#endif // NETFX_35 || UNITY || SILVERLIGHT +#endif // !FEATURE_CONCURRENT internal static bool UseLegacyNullMapEntryHandling { get { -#if NETFX_35 || UNITY || SILVERLIGHT +#if !FEATURE_CONCURRENT return Volatile.Read( ref _useLegacyNullMapEntryHandling ) == 1; #else return Volatile.Read( ref _useLegacyNullMapEntryHandling ); -#endif +#endif // !FEATURE_CONCURRENT } set { -#if NETFX_35 || UNITY || SILVERLIGHT +#if !FEATURE_CONCURRENT Volatile.Write( ref _useLegacyNullMapEntryHandling, value ? 1 : 0 ); #else Volatile.Write( ref _useLegacyNullMapEntryHandling, value ); -#endif +#endif // !FEATURE_CONCURRENT } } diff --git a/src/MsgPack/Serialization/SerializerGenerator.cs b/src/MsgPack/Serialization/SerializerGenerator.cs index 7a4a225a0..7eeebd927 100644 --- a/src/MsgPack/Serialization/SerializerGenerator.cs +++ b/src/MsgPack/Serialization/SerializerGenerator.cs @@ -22,16 +22,26 @@ #endregion -- License Terms -- using System; +#if FEATURE_CONCURRENT +using System.Collections.Concurrent; +#endif // FEATURE_CONCURRENT using System.Collections.Generic; +using System.Globalization; +#if NETSTANDARD1_3 +using Contract = MsgPack.MPContract; +#else using System.Diagnostics.Contracts; +#endif // NETSTANDARD1_1 using System.IO; using System.Linq; using System.Reflection; -using System.Reflection.Emit; -using MsgPack.Serialization.AbstractSerializers; -using MsgPack.Serialization.CodeDomSerializers; -using MsgPack.Serialization.EmittingSerializers; +using MsgPack.Serialization.CodeGenerators; +#if NETSTANDARD1_3 + +#else + +#endif // NETSTANDARD1_3 namespace MsgPack.Serialization { @@ -55,8 +65,52 @@ namespace MsgPack.Serialization /// If you want to get such fine grained control for them, you should implement own hand made serializers. /// /// - public class SerializerGenerator + public partial class SerializerGenerator { +#if FEATURE_CONCURRENT + + private static readonly ConcurrentDictionary CodeGeneratorFactories = InitializeCodeGeneratorFactories(); + +#else + + private static readonly Dictionary CodeGeneratorFactories = InitializeCodeGeneratorFactories(); + private static readonly object SyncRoot = new object(); + +#endif // FEATURE_CONCURRENT + +#if FEATURE_CONCURRENT + private static ConcurrentDictionary InitializeCodeGeneratorFactories() + { + var factories = new ConcurrentDictionary( StringComparer.OrdinalIgnoreCase ); +#else + private static Dictionary InitializeCodeGeneratorFactories() + { + var factories = new Dictionary( StringComparer.OrdinalIgnoreCase ); +#endif // FEATURE_CONCURRENT +#if !NETSTANDARD1_3 + factories[ String.Empty ] = SerializerCodesGenerationLogicFactory.Instance; + factories[ "codedom" ] = SerializerCodesGenerationLogicFactory.Instance; +#endif // !NETSTANDARD1_3 + return factories; + } + + + internal static void RegisterGenerator( string[] keys, SerializerCodeGeneratorFactory factory ) + { +#if !FEATURE_CONCURRENT + lock ( SyncRoot ) + { +#endif // !FEATURE_CONCURRENT + foreach ( var key in keys ) + { + CodeGeneratorFactories[ key ] = factory; + } +#if !FEATURE_CONCURRENT + } +#endif // !FEATURE_CONCURRENT + } + +#if !NETSTANDARD1_3 /// /// Gets the type of the root object which will be serialized/deserialized. /// @@ -283,6 +337,9 @@ public static IEnumerable GenerateSerializerCode { return new SerializerAssemblyGenerationLogic().Generate( targetTypes, configuration ); } + +#endif // !NETSTANDARD1_3 + /// /// Generates source codes which implement auto-generated serializer types for specified types with default configuration. /// @@ -412,183 +469,25 @@ public static IEnumerable GenerateSerializerSour /// public static IEnumerable GenerateSerializerSourceCodes( SerializerCodeGenerationConfiguration configuration, IEnumerable targetTypes ) { - return new SerializerCodesGenerationLogic().Generate( targetTypes, configuration ?? new SerializerCodeGenerationConfiguration() ); - } - - private abstract class SerializerGenerationLogic - where TConfig : class, ISerializerGeneratorConfiguration - { - protected abstract EmitterFlavor EmitterFlavor { get; } - - public IEnumerable Generate( IEnumerable targetTypes, TConfig configuration ) - { - if ( targetTypes == null ) - { - throw new ArgumentNullException( "targetTypes" ); - } - - if ( configuration == null ) - { - throw new ArgumentNullException( "configuration" ); - } - - configuration.Validate(); - var context = - new SerializationContext - { - GeneratorOption = SerializationMethodGeneratorOption.CanDump, - EnumSerializationMethod = configuration.EnumSerializationMethod, - SerializationMethod = configuration.SerializationMethod - }; - context.SerializerOptions.EmitterFlavor = this.EmitterFlavor; - context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = configuration.CompatibilityOptions.AllowNonCollectionEnumerableTypes; - context.CompatibilityOptions.IgnorePackabilityForCollection = configuration.CompatibilityOptions.IgnorePackabilityForCollection; - context.CompatibilityOptions.OneBoundDataMemberOrder = configuration.CompatibilityOptions.OneBoundDataMemberOrder; - context.CompatibilityOptions.PackerCompatibilityOptions = configuration.CompatibilityOptions.PackerCompatibilityOptions; -#if !NETFX_35 - context.SerializerOptions.WithAsync = configuration.WithAsync; -#endif // !NETFX_35 - - IEnumerable realTargetTypes; - if ( configuration.IsRecursive ) - { - realTargetTypes = - targetTypes - .SelectMany( t => ExtractElementTypes( context, configuration, t ) ); - } - else - { - realTargetTypes = - targetTypes - .Where( t => !SerializationTarget.BuiltInSerializerExists( configuration, t, t.GetCollectionTraits( CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) ); - } - - var generationContext = this.CreateGenerationContext( context, configuration ); - var generatorFactory = this.CreateGeneratorFactory( context ); - - foreach ( var targetType in realTargetTypes.Distinct() ) - { - var generator = generatorFactory( targetType ); - - var concreteType = default( Type ); - if ( targetType.GetIsInterface() || targetType.GetIsAbstract() ) - { - concreteType = context.DefaultCollectionTypes.GetConcreteType( targetType ); - } - - generator.BuildSerializerCode( generationContext, concreteType, null ); - } - - Directory.CreateDirectory( configuration.OutputDirectory ); - - return generationContext.Generate(); - } - - private static IEnumerable ExtractElementTypes( SerializationContext context, ISerializerGeneratorConfiguration configuration, Type type ) - { - if ( !SerializationTarget.BuiltInSerializerExists( configuration, type, type.GetCollectionTraits( CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ) ) - { - yield return type; - - // Search dependents recursively if the type is NOT enum. - if ( !type.GetIsEnum() ) - { - foreach ( - var dependentType in - SerializationTarget.Prepare( context, type ) - .Members.Where( m => m.Member != null ).SelectMany( m => ExtractElementTypes( context, configuration, m.Member.GetMemberValueType() ) ) - ) - { - yield return dependentType; - } - } - } - - if ( type.IsArray ) - { - var elementType = type.GetElementType(); - if ( !SerializationTarget.BuiltInSerializerExists( configuration, elementType, elementType.GetCollectionTraits( CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false ) ) ) - { - foreach ( var descendant in ExtractElementTypes( context, configuration, elementType ) ) - { - yield return descendant; - } - - yield return elementType; - } - - yield break; - } - - if ( type.IsGenericType ) - { - // Search generic arguments recursively. - foreach ( var elementType in type.GetGenericArguments().SelectMany( g => ExtractElementTypes( context, configuration, g ) ) ) - { - yield return elementType; - } - } - - if ( configuration.WithNullableSerializers && type.GetIsValueType() && Nullable.GetUnderlyingType( type ) == null ) - { - // Retrun nullable companion even if they always have built-in serializers. - yield return typeof( Nullable<> ).MakeGenericType( type ); - } - } - - protected abstract ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, TConfig configuration ); - - protected abstract Func CreateGeneratorFactory( SerializationContext context ); - } - - private sealed class SerializerAssemblyGenerationLogic : SerializerGenerationLogic - { - protected override EmitterFlavor EmitterFlavor - { - get { return EmitterFlavor.FieldBased; } - } - - public SerializerAssemblyGenerationLogic() { } - - [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )] - protected override ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, SerializerAssemblyGenerationConfiguration configuration ) - { - return - new AssemblyBuilderCodeGenerationContext( - context, - AppDomain.CurrentDomain.DefineDynamicAssembly( - configuration.AssemblyName, - AssemblyBuilderAccess.RunAndSave, - configuration.OutputDirectory - ), - configuration - ); - } - - protected override Func CreateGeneratorFactory( SerializationContext context ) + var providerName = + configuration == null + ? String.Empty + : configuration.ProviderName; + SerializerCodeGeneratorFactory factory; + +#if !FEATURE_CONCURRENT + lock ( SyncRoot ) { - return type => new AssemblyBuilderSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ); - } - } - - private sealed class SerializerCodesGenerationLogic : SerializerGenerationLogic - { - protected override EmitterFlavor EmitterFlavor +#endif // !FEATURE_CONCURRENT + if ( !CodeGeneratorFactories.TryGetValue( providerName, out factory ) ) { - get { return EmitterFlavor.CodeDomBased; } + throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "Unknown provider name '{0}'", providerName ) ); } - - public SerializerCodesGenerationLogic() { } - - protected override ISerializerCodeGenerationContext CreateGenerationContext( SerializationContext context, SerializerCodeGenerationConfiguration configuration ) - { - return new CodeDomContext( context, configuration ); +#if !FEATURE_CONCURRENT } +#endif // !FEATURE_CONCURRENT - protected override Func CreateGeneratorFactory( SerializationContext context ) - { - return type => new CodeDomSerializerBuilder( type, type.GetCollectionTraits( CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes ) ); - } + return factory.Create( configuration ).Generate( targetTypes, configuration ?? new SerializerCodeGenerationConfiguration() ); } } -} +} \ No newline at end of file diff --git a/src/MsgPack/Serialization/SerializerOptions.cs b/src/MsgPack/Serialization/SerializerOptions.cs index 200aa3760..99d2d1702 100644 --- a/src/MsgPack/Serialization/SerializerOptions.cs +++ b/src/MsgPack/Serialization/SerializerOptions.cs @@ -25,11 +25,11 @@ using System; using System.Threading; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 namespace MsgPack.Serialization { diff --git a/src/MsgPack/Serialization/SerializerTypeKeyRepository.cs b/src/MsgPack/Serialization/SerializerTypeKeyRepository.cs index 26de608d6..2700efe67 100644 --- a/src/MsgPack/Serialization/SerializerTypeKeyRepository.cs +++ b/src/MsgPack/Serialization/SerializerTypeKeyRepository.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if !NETFX_35 && !UNITY using System.Security; #endif // !NETFX_35 && !UNITY diff --git a/src/MsgPack/Serialization/SerializingMember.cs b/src/MsgPack/Serialization/SerializingMember.cs index baf8a5889..612213370 100644 --- a/src/MsgPack/Serialization/SerializingMember.cs +++ b/src/MsgPack/Serialization/SerializingMember.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using MPContract = MsgPack.MPContract; #else using MPContract = System.Diagnostics.Contracts.Contract; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Reflection; namespace MsgPack.Serialization diff --git a/src/MsgPack/Serialization/TypeKeyRepository.cs b/src/MsgPack/Serialization/TypeKeyRepository.cs index fbafa26d1..c18dc6b92 100644 --- a/src/MsgPack/Serialization/TypeKeyRepository.cs +++ b/src/MsgPack/Serialization/TypeKeyRepository.cs @@ -24,11 +24,11 @@ using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if NETFX_CORE using System.Reflection; #endif diff --git a/src/MsgPack/Serialization/UnpackHelpers.cs b/src/MsgPack/Serialization/UnpackHelpers.cs index a6500f23c..a130720c5 100644 --- a/src/MsgPack/Serialization/UnpackHelpers.cs +++ b/src/MsgPack/Serialization/UnpackHelpers.cs @@ -38,11 +38,11 @@ #endif //!UNITY || MSGPACK_UNITY_FULL using System.Diagnostics; #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT using System.Reflection; using System.Runtime.CompilerServices; diff --git a/src/MsgPack/Serialization/UnpackHelpers.direct.cs b/src/MsgPack/Serialization/UnpackHelpers.direct.cs index 00bf33a10..467a217c2 100644 --- a/src/MsgPack/Serialization/UnpackHelpers.direct.cs +++ b/src/MsgPack/Serialization/UnpackHelpers.direct.cs @@ -31,11 +31,11 @@ using System.ComponentModel; #endif // !UNITY || MSGPACK_UNITY_FULL #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/Serialization/UnpackHelpers.direct.tt b/src/MsgPack/Serialization/UnpackHelpers.direct.tt index 19bb2a3b5..12f7fe02c 100644 --- a/src/MsgPack/Serialization/UnpackHelpers.direct.tt +++ b/src/MsgPack/Serialization/UnpackHelpers.direct.tt @@ -41,11 +41,11 @@ using System; using System.ComponentModel; #endif // !UNITY || MSGPACK_UNITY_FULL #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/Serialization/UnpackHelpers.facade.cs b/src/MsgPack/Serialization/UnpackHelpers.facade.cs index 51e5627ac..60dd85223 100644 --- a/src/MsgPack/Serialization/UnpackHelpers.facade.cs +++ b/src/MsgPack/Serialization/UnpackHelpers.facade.cs @@ -33,11 +33,11 @@ using System.ComponentModel; #endif // !UNITY || MSGPACK_UNITY_FULL #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/Serialization/UnpackHelpers.facade.tt b/src/MsgPack/Serialization/UnpackHelpers.facade.tt index 5d099afa4..9cc061803 100644 --- a/src/MsgPack/Serialization/UnpackHelpers.facade.tt +++ b/src/MsgPack/Serialization/UnpackHelpers.facade.tt @@ -42,11 +42,11 @@ using System.Collections.Generic; using System.ComponentModel; #endif // !UNITY || MSGPACK_UNITY_FULL #if ASSERT -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #endif // ASSERT #if FEATURE_TAP using System.Threading; diff --git a/src/MsgPack/SetOperation.cs b/src/MsgPack/SetOperation.cs index b7593196a..67d2f0f34 100644 --- a/src/MsgPack/SetOperation.cs +++ b/src/MsgPack/SetOperation.cs @@ -25,11 +25,11 @@ #if !UNITY using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; diff --git a/src/MsgPack/SubtreeUnpacker.cs b/src/MsgPack/SubtreeUnpacker.cs index dcc67b0d6..3e65bee47 100644 --- a/src/MsgPack/SubtreeUnpacker.cs +++ b/src/MsgPack/SubtreeUnpacker.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 #if FEATURE_TAP using System.Threading; using System.Threading.Tasks; diff --git a/src/MsgPack/TupleItems.cs b/src/MsgPack/TupleItems.cs index 83f2dbaac..616804a27 100644 --- a/src/MsgPack/TupleItems.cs +++ b/src/MsgPack/TupleItems.cs @@ -25,11 +25,11 @@ #if !UNITY using System; using System.Collections.Generic; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Linq; #if NETFX_CORE using System.Reflection; diff --git a/src/MsgPack/Unpacking.Numerics.cs b/src/MsgPack/Unpacking.Numerics.cs index fe9252e58..e617c644c 100644 --- a/src/MsgPack/Unpacking.Numerics.cs +++ b/src/MsgPack/Unpacking.Numerics.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; namespace MsgPack diff --git a/src/MsgPack/Unpacking.Numerics.tt b/src/MsgPack/Unpacking.Numerics.tt index 0defe268b..43b3f2a54 100644 --- a/src/MsgPack/Unpacking.Numerics.tt +++ b/src/MsgPack/Unpacking.Numerics.tt @@ -70,11 +70,11 @@ Func __isClsCompliant = #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; namespace MsgPack diff --git a/src/MsgPack/Unpacking.Others.cs b/src/MsgPack/Unpacking.Others.cs index f667831e3..37a6ad4d6 100644 --- a/src/MsgPack/Unpacking.Others.cs +++ b/src/MsgPack/Unpacking.Others.cs @@ -25,11 +25,11 @@ using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; namespace MsgPack diff --git a/src/MsgPack/Unpacking.Others.tt b/src/MsgPack/Unpacking.Others.tt index 239a831ba..2e46145e6 100644 --- a/src/MsgPack/Unpacking.Others.tt +++ b/src/MsgPack/Unpacking.Others.tt @@ -70,11 +70,11 @@ var __methods = new [] using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; namespace MsgPack diff --git a/src/MsgPack/Unpacking.Streaming.cs b/src/MsgPack/Unpacking.Streaming.cs index 2389c23a6..ffa345acb 100644 --- a/src/MsgPack/Unpacking.Streaming.cs +++ b/src/MsgPack/Unpacking.Streaming.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; using System.Text; diff --git a/src/MsgPack/Unpacking.String.cs b/src/MsgPack/Unpacking.String.cs index 76fe610cc..f95d78471 100644 --- a/src/MsgPack/Unpacking.String.cs +++ b/src/MsgPack/Unpacking.String.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.Globalization; using System.IO; using System.Text; diff --git a/src/MsgPack/UnpackingStream.cs b/src/MsgPack/UnpackingStream.cs index 6e7b9a444..a1c9d5876 100644 --- a/src/MsgPack/UnpackingStream.cs +++ b/src/MsgPack/UnpackingStream.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_1 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_1 using System.IO; namespace MsgPack diff --git a/src/MsgPack/Validation.cs b/src/MsgPack/Validation.cs index 1a42a31a4..8c497d64e 100644 --- a/src/MsgPack/Validation.cs +++ b/src/MsgPack/Validation.cs @@ -23,11 +23,11 @@ #endif using System; -#if CORE_CLR || UNITY +#if CORE_CLR || UNITY || NETSTANDARD1_3 using Contract = MsgPack.MPContract; #else using System.Diagnostics.Contracts; -#endif // CORE_CLR || UNITY +#endif // CORE_CLR || UNITY || NETSTANDARD1_3 using System.Globalization; using System.Text.RegularExpressions; @@ -42,24 +42,6 @@ namespace MsgPack // [ArgumentValidator] internal static class Validation { -#if DEBUG - public static void ValidateIsNotNullNorEmpty( string value, string parameterName ) - { - if ( value == null ) - { - throw new ArgumentNullException( parameterName ); - } - - if ( value.Length == 0 ) - { - throw new ArgumentException( - String.Format( CultureInfo.CurrentCulture, "'{0}' cannot be empty.", parameterName ), - parameterName - ); - } - } -#endif // DEBUG - private const string UnicodeTr15Annex7Idneifier = @"[\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}][\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\p{Cf}]*"; diff --git a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj index d4f614063..8eb1c27c8 100644 --- a/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj +++ b/test/MsgPack.UnitTest.BclExtensions.WinRT/MsgPack.UnitTest.BclExtensions.WinRT.csproj @@ -155,9 +155,9 @@ - - {a1b322fc-aa39-4894-afa8-ab427a3fba09} - NetStandardProjectBuilder + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization {fc521316-ebcd-4ef1-8235-c976b2a31eb0} diff --git a/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj b/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj index 711c60d05..a7afa5ac1 100644 --- a/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj +++ b/test/MsgPack.UnitTest.BclExtensions/MsgPack.UnitTest.BclExtensions.csproj @@ -57,6 +57,9 @@ + + Serialization\TempFileDependentAssemblyManager.cs + ArrayCodeDomBasedCustomCollectionSerializersTest.tt diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayCodeDomBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayCodeDomBasedCustomCollectionSerializersTest.cs index 0d68bfb1b..21ce1a184 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayCodeDomBasedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayCodeDomBasedCustomCollectionSerializersTest.cs @@ -28,10 +28,14 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +70,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +80,17 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +106,10 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayFieldBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayFieldBasedCustomCollectionSerializersTest.cs index 094e7e70a..fd16cf332 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayFieldBasedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayFieldBasedCustomCollectionSerializersTest.cs @@ -28,10 +28,12 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +68,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +78,15 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +102,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayReflectionBaedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayReflectionBaedCustomCollectionSerializersTest.cs index 5f1fd8455..b6931f691 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayReflectionBaedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/ArrayReflectionBaedCustomCollectionSerializersTest.cs @@ -28,10 +28,12 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +68,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +78,15 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +102,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/CustomCollectionSerializersTest.ttinclude b/test/MsgPack.UnitTest.BclExtensions/Serialization/CustomCollectionSerializersTest.ttinclude index af212611b..4fb70de1d 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/CustomCollectionSerializersTest.ttinclude +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/CustomCollectionSerializersTest.ttinclude @@ -1,5 +1,5 @@ <#+ -void Geneate( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump ) +void Geneate( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump, string language = "" ) { #> #region -- License Terms -- @@ -32,10 +32,14 @@ using System.Collections.ObjectModel; using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -52,7 +56,7 @@ using Is = NUnit.Framework.Is; namespace MsgPack.Serialization { [TestFixture] - public class <#= serializationMethod #><#= emitterFlavor #>ImmutableCollectionsTest + public class <#= serializationMethod #><#= language #><#= emitterFlavor #>ImmutableCollectionsTest { private MessagePackSerializer CreateTarget() { @@ -70,6 +74,7 @@ namespace MsgPack.Serialization [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -79,14 +84,24 @@ namespace MsgPack.Serialization Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +<#+ + if ( emitterFlavor == "CodeTreeBased" || emitterFlavor == "CodeDomBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new <#= language #><#= builderTypeName #>( t, c ) ); +<#+ + } +#> SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -102,9 +117,17 @@ namespace MsgPack.Serialization SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; +<#+ + if ( emitterFlavor == "CodeDomBased" || emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); +<#+ + } +#> } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapCodeDomBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapCodeDomBasedCustomCollectionSerializersTest.cs index fabcd4516..b16cd1787 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapCodeDomBasedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapCodeDomBasedCustomCollectionSerializersTest.cs @@ -28,10 +28,14 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +70,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +80,17 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +106,10 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapFieldBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapFieldBasedCustomCollectionSerializersTest.cs index b17b5d0e2..8f32afd9b 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapFieldBasedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapFieldBasedCustomCollectionSerializersTest.cs @@ -28,10 +28,12 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +68,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +78,15 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +102,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif diff --git a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapReflectionBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapReflectionBasedCustomCollectionSerializersTest.cs index ee1e08411..fcf8ac1d9 100644 --- a/test/MsgPack.UnitTest.BclExtensions/Serialization/MapReflectionBasedCustomCollectionSerializersTest.cs +++ b/test/MsgPack.UnitTest.BclExtensions/Serialization/MapReflectionBasedCustomCollectionSerializersTest.cs @@ -28,10 +28,12 @@ using System.Diagnostics; using System.IO; using System.Linq; -#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !AOT && !SILVERLIGHT #if !NETFX_CORE using Microsoft.FSharp.Collections; #endif // !NETFX_CORE @@ -66,6 +68,7 @@ private bool CanDump [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,14 +78,15 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); } [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -98,9 +102,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif diff --git a/test/MsgPack.UnitTest.CodeDom.Net35/MsgPack.UnitTest.CodeDom.Net35.csproj b/test/MsgPack.UnitTest.CodeDom.Net35/MsgPack.UnitTest.CodeDom.Net35.csproj index 692dcd8b4..41772c57b 100644 --- a/test/MsgPack.UnitTest.CodeDom.Net35/MsgPack.UnitTest.CodeDom.Net35.csproj +++ b/test/MsgPack.UnitTest.CodeDom.Net35/MsgPack.UnitTest.CodeDom.Net35.csproj @@ -69,6 +69,9 @@ _SetUpFixture.cs + + Serialization\TempFileDependentAssemblyManager.cs + diff --git a/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj b/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj index bf1ba1cfe..8da1f3a12 100644 --- a/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj +++ b/test/MsgPack.UnitTest.CodeDom/MsgPack.UnitTest.CodeDom.csproj @@ -55,6 +55,9 @@ + + Serialization\TempFileDependentAssemblyManager.cs + True diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs index e93e6f059..d980c1744 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs @@ -48,10 +48,14 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -120,11 +124,14 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -135,7 +142,10 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -146,6 +156,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -162,8 +174,10 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedEnumSerializationTest.cs index ac7392de5..f8160ac08 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedEnumSerializationTest.cs @@ -29,9 +29,14 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +65,11 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +79,10 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +93,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +109,10 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/CodeDomBasedNilImplicationTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/CodeDomBasedNilImplicationTest.cs index 3836a24f1..183894042 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/CodeDomBasedNilImplicationTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/CodeDomBasedNilImplicationTest.cs @@ -24,9 +24,14 @@ using System.IO; using System.Linq; using System.Runtime.Serialization; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -53,7 +58,7 @@ private MessagePackSerializer CreateTarget( SerializationContext context ) { return MessagePackSerializer.CreateInternal( context, PolymorphismSchema.Default ); } -#if !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT && !UNITY #if MSTEST [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] @@ -66,6 +71,7 @@ public void Initialize( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.Te #endif public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,8 +81,10 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) { @@ -87,6 +95,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled ) { try @@ -98,9 +107,10 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs index 4f816115c..52ac37279 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs @@ -49,10 +49,14 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -121,11 +125,14 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -136,7 +143,10 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -147,6 +157,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -163,8 +175,10 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedEnumSerializationTest.cs index 68a3c87b9..1720cae2e 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedEnumSerializationTest.cs @@ -29,9 +29,14 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +65,11 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +79,10 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +93,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +109,10 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest.CodeTree/MsgPack.UnitTest.CodeTree.csproj b/test/MsgPack.UnitTest.CodeTree/MsgPack.UnitTest.CodeTree.csproj new file mode 100644 index 000000000..429fa7221 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/MsgPack.UnitTest.CodeTree.csproj @@ -0,0 +1,414 @@ + + + + + Debug + AnyCPU + {D5A4E386-E418-4407-916E-A65092B78693} + Library + Properties + MsgPack + MsgPack.UnitTest.CodeTree + v4.6.1 + 512 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;FEATURE_TAP;NETSTANDARD1_3 + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE;FEATURE_TAP;NETSTANDARD1_3 + prompt + 4 + + + true + + + ..\..\src\MsgPack.snk + + + + ..\..\packages\FSharp.Core.4.0.0.1\lib\net40\FSharp.Core.dll + True + + + ..\..\packages\Microsoft.CodeAnalysis.Common.1.3.2\lib\net45\Microsoft.CodeAnalysis.dll + True + + + ..\..\packages\Microsoft.CodeAnalysis.CSharp.1.3.2\lib\net45\Microsoft.CodeAnalysis.CSharp.dll + True + + + ..\..\packages\Microsoft.CodeAnalysis.VisualBasic.1.3.2\lib\net45\Microsoft.CodeAnalysis.VisualBasic.dll + True + + + + ..\..\packages\NUnit.3.2.1\lib\net45\nunit.framework.dll + True + + + + ..\..\packages\System.AppContext.4.1.0\lib\net46\System.AppContext.dll + True + + + ..\..\packages\System.Collections.Immutable.1.2.0\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll + True + + + ..\..\packages\System.Collections.NonGeneric.4.0.1\lib\net46\System.Collections.NonGeneric.dll + True + + + ..\..\packages\System.Collections.Specialized.4.0.1\lib\net46\System.Collections.Specialized.dll + True + + + + ..\..\packages\System.Console.4.0.0\lib\net46\System.Console.dll + True + + + + ..\..\packages\System.Diagnostics.FileVersionInfo.4.0.0\lib\net46\System.Diagnostics.FileVersionInfo.dll + True + + + ..\..\packages\System.Diagnostics.Process.4.1.0\lib\net461\System.Diagnostics.Process.dll + True + + + ..\..\packages\System.Diagnostics.StackTrace.4.0.1\lib\net46\System.Diagnostics.StackTrace.dll + True + + + ..\..\packages\System.IO.FileSystem.4.0.1\lib\net46\System.IO.FileSystem.dll + True + + + ..\..\packages\System.IO.FileSystem.Primitives.4.0.1\lib\net46\System.IO.FileSystem.Primitives.dll + True + + + + ..\..\packages\System.Numerics.Vectors.4.1.1\lib\net46\System.Numerics.Vectors.dll + True + + + ..\..\packages\System.Reflection.Metadata.1.3.0\lib\portable-net45+win8\System.Reflection.Metadata.dll + True + + + + ..\..\packages\System.Runtime.Serialization.Primitives.4.1.1\lib\net46\System.Runtime.Serialization.Primitives.dll + True + + + ..\..\packages\System.Security.Cryptography.Algorithms.4.2.0\lib\net461\System.Security.Cryptography.Algorithms.dll + True + + + ..\..\packages\System.Security.Cryptography.Encoding.4.0.0\lib\net46\System.Security.Cryptography.Encoding.dll + True + + + ..\..\packages\System.Security.Cryptography.Primitives.4.0.0\lib\net46\System.Security.Cryptography.Primitives.dll + True + + + ..\..\packages\System.Security.Cryptography.X509Certificates.4.1.0\lib\net461\System.Security.Cryptography.X509Certificates.dll + True + + + ..\..\packages\System.Text.Encoding.CodePages.4.0.1\lib\net46\System.Text.Encoding.CodePages.dll + True + + + ..\..\packages\System.Threading.Thread.4.0.0\lib\net46\System.Threading.Thread.dll + True + + + + + ..\..\packages\System.Xml.XmlDocument.4.0.1\lib\net46\System.Xml.XmlDocument.dll + True + + + ..\..\packages\System.Xml.XPath.4.0.1\lib\net46\System.Xml.XPath.dll + True + + + ..\..\packages\System.Xml.XPath.XDocument.4.0.1\lib\net46\System.Xml.XPath.XDocument.dll + True + + + + + Image.cs + + + Serialization\AddOnlyCollection`1.cs + + + Serialization\AppendableReadOnlyCollections.cs + + + Serialization\ArraySegmentEqualityComparer`1.cs + + + Serialization\AutoMessagePackSerializerTest.Types.cs + + + Serialization\BaseCollections.cs + + + Serialization\ComplexType.cs + + + Serialization\ComplexTypeWithDataContract.cs + + + Serialization\ComplexTypeWithDataContractWithOrder.cs + + + Serialization\ComplexTypeWithNonSerialized.cs + + + Serialization\ComplexTypeWithOneBaseOrder.cs + + + Serialization\ComplexTypeWithoutAnyAttribute.cs + + + Serialization\ComplexTypeWithTwoMember.cs + + + Serialization\DataMemberAttributeNamedPropertyTestTarget.cs + + + Serialization\EnumSerializationTest.EnumDefinitions.cs + + + Serialization\IVerifiable.cs + + + Serialization\IVerifiable`1.cs + + + Serialization\NilImplicationTestTarget.cs + + + Serialization\SerializationTargets.cs + + + Serialization\SimpleCollection`1.cs + + + Serialization\StringKeyedCollection.cs + + + Serialization\TempFileDependentAssemblyManager.cs + + + Serialization\TestValueType.cs + + + Serialization\TypeWithDuplicatedMessagePackMemberAttributeMember.cs + + + Serialization\TypeWithInvalidMessagePackMemberAttributeMember.cs + + + Serialization\TypeWithMissingMessagePackMemberAttributeMember.cs + + + StreamExtensions.cs + + + + True + True + ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt + + + True + True + ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.tt + + + True + True + ArrayCSharpCodeTreeBasedEnumSerializationTest.tt + + + True + True + ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt + + + True + True + ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt + + + True + True + ArrayVisualBasicCodeTreeBasedEnumSerializationTest.tt + + + True + True + CSharpCodeTreeBasedNilImplicationTest.tt + + + True + True + MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt + + + True + True + MapCSharpCodeTreeBasedCustomCollectionSerializersTest.tt + + + True + True + MapCSharpCodeTreeBasedEnumSerializationTest.tt + + + True + True + MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt + + + True + True + MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt + + + True + True + MapVisualBasicCodeTreeBasedEnumSerializationTest.tt + + + True + True + VisualBasicCodeTreeBasedNilImplicationTest.tt + + + + + + MsgPack.snk + + + + + + + TextTemplatingFileGenerator + ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs + + + TextTemplatingFileGenerator + ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.cs + + + TextTemplatingFileGenerator + ArrayCSharpCodeTreeBasedEnumSerializationTest.cs + + + TextTemplatingFileGenerator + ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs + + + TextTemplatingFileGenerator + ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs + + + TextTemplatingFileGenerator + ArrayVisualBasicCodeTreeBasedEnumSerializationTest.cs + + + TextTemplatingFileGenerator + CSharpCodeTreeBasedNilImplicationTest.cs + + + TextTemplatingFileGenerator + MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs + + + TextTemplatingFileGenerator + MapCSharpCodeTreeBasedCustomCollectionSerializersTest.cs + + + TextTemplatingFileGenerator + MapCSharpCodeTreeBasedEnumSerializationTest.cs + + + TextTemplatingFileGenerator + MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs + + + TextTemplatingFileGenerator + MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs + + + TextTemplatingFileGenerator + MapVisualBasicCodeTreeBasedEnumSerializationTest.cs + + + TextTemplatingFileGenerator + VisualBasicCodeTreeBasedNilImplicationTest.cs + + + + + + + + + {efe532ea-77c8-4877-96c2-e79fd101b2ab} + MsgPack.CodeGeneration.Core + + + {b10240c1-bb07-47a3-b056-ce52b5194d86} + MsgPack.CodeGeneration.CSharp + + + {a88d64db-de14-4b77-80d8-b765f45ebb8b} + MsgPack.CodeGeneration.VisualBasic + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization + + + + + + + + + \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/Properties/AssemblyInfo.cs b/test/MsgPack.UnitTest.CodeTree/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..0d2b99424 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Properties/AssemblyInfo.cs @@ -0,0 +1,38 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2012 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Resources; + +[assembly: AssemblyTitle( "Unit test of MessagePack for CLI (Roslyn portion)" )] +[assembly: AssemblyDescription( "Unit test of MessagePack CLI binding Resolyn portion because of its dependencies" )] +[assembly: AssemblyConfiguration( "Develop" )] +[assembly: AssemblyProduct( "MessagePack" )] +[assembly: AssemblyCopyright( "Copyright © FUJIWARA, Yusuke 2016" )] + +[assembly: ComVisible( false )] +[assembly: CLSCompliant( true )] +[assembly: NeutralResourcesLanguage( "en-US" )] +[assembly: AssemblyVersion( "1.0.0.0" )] +[assembly: AssemblyFileVersion( "0.1.0.0" )] +[assembly: AssemblyInformationalVersion( "0.1" )] + diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs new file mode 100644 index 000000000..828d58dbd --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs @@ -0,0 +1,21770 @@ + + + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Contributors: +// Samuel Cragg +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +#pragma warning disable 3003 +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !NETFX_35 && !WINDOWS_PHONE +using System.Numerics; +#endif // !NETFX_35 && !WINDOWS_PHONE +using System.Reflection; +using System.Runtime.InteropServices.ComTypes; +using System.Runtime.Serialization; +using System.Text; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using CategoryAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCategoryAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +using Does = NUnit.Framework.Does; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 60000 )] + public class ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest + { + private static SerializationContext GetSerializationContext() + { +#if !UNITY + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; +#else + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + +#endif // !UNITY + } + + private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions ) + { + var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return context.GetSerializer( context ); + } + +#if UNITY + [TestFixtureSetUp] + public static void SetUpFixture() + { + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareType(); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + } +#endif // UNITY + + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + private void DoKnownCollectionTest( SerializationContext context ) + where T : new() + { + using ( var buffer = new MemoryStream() ) + { + CreateTarget( context ).Pack( buffer, new T() ); + } + } + + [Test] + public void TestUnpackTo() + { + var target = this.CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, new[] { 1, 2 } ); + buffer.Position = 0; + int[] result = new int[ 2 ]; + using ( var unpacker = Unpacker.Create( buffer, false ) ) + { + unpacker.Read(); + target.UnpackTo( unpacker, result ); + Assert.That( result, Is.EqualTo( new[] { 1, 2 } ) ); + } + } + } + + [Test] + public void TestInt32() + { + TestCore( 1, stream => Unpacking.UnpackInt32( stream ), null ); + } + + [Test] + public void TestInt64() + { + TestCore( Int32.MaxValue + 1L, stream => Unpacking.UnpackInt64( stream ), null ); + } + + [Test] + public void TestString() + { + TestCore( "abc", stream => Unpacking.UnpackString( stream ), null ); + } + + [Test] + public void TestDateTime() + { + TestCore( + DateTime.Now, + stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeOffset() + { + TestCore( + DateTimeOffset.Now, + stream => + { + var array = Unpacking.UnpackArray( stream ); + return new DateTimeOffset( DateTime.FromBinary( array[ 0 ].AsInt64() ), TimeSpan.FromMinutes( array[ 1 ].AsInt16() ) ); + }, + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeClassic() + { + TestCore( + DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetClassic() + { + TestCore( + DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.DateTime.ToUniversalTime(), y.DateTime.ToUniversalTime() ), + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeNullableChangeOnDemand() + { + TestCore( + ( DateTime? )DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetNullableChangeOnDemand() + { + TestCore( + ( DateTimeOffset? )DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.Value.DateTime.ToUniversalTime(), y.Value.DateTime.ToUniversalTime() ), + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + private static bool CompareDateTime( DateTime x, DateTime y ) + { + return x.Date == y.Date && x.Hour == y.Hour && x.Minute == y.Minute && x.Second == y.Second && x.Millisecond == y.Millisecond; + } + + private static bool CompareDateTime( DateTime? x, DateTime? y ) + { + return CompareDateTime( x.Value, y.Value ); + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + + [Test] + public void TestUri() + { + TestCore( new Uri( "http://www.example.com" ), stream => new Uri( Unpacking.UnpackString( stream ) ), null ); + } + + [Test] + public void TestComplexObject_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObject_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestCoreWithVerify( target, context ); + } + +#if FEATURE_TAP + [Test] + public async Task TestComplexObjectAsync_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public async Task TestComplexObjectAsync_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private async Task TestComplexObjectAsyncCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + await TestCoreWithVerifyAsync( target, context ); + } +#endif // FEATURE_TAP + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithoutAnyAttribute( SerializationContext context ) + { + var target = new ComplexTypeWithoutAnyAttribute() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithMissingMessagePackMemberAttributeMember() + { + this.TestTypeWithMissingMessagePackMemberAttributeMemberCore( GetSerializationContext() ); + } + + private void TestTypeWithMissingMessagePackMemberAttributeMemberCore( SerializationContext context ) + { + var target = new TypeWithMissingMessagePackMemberAttributeMember(); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithInvalidMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestTypeWithDuplicatedMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithDataContractCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContract() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithDataContractWithOrderCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContractWithOrder() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithNonSerializedCore( SerializationContext context ) + { + var target = new ComplexTypeWithNonSerialized() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestDataMemberAttributeOrderWithOneBase() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseAsync() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserializeAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithZeroBase_ProtoBufCompatible_Fail() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + Assert.Throws( + () => this.CreateTarget( context ) + ); + } + + [Test] + public void TestDataMemberAttributeNamedProperties() + { + var context = GetSerializationContext(); + if ( context.SerializationMethod == SerializationMethod.Array ) + { + // Nothing to test. + return; + } + + var value = new DataMemberAttributeNamedPropertyTestTarget() { Member = "A Member" }; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var asDictionary = Unpacking.UnpackDictionary( buffer ); + + Assert.That( asDictionary[ "Alias" ] == value.Member ); + + buffer.Position = 0; + + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.Member, Is.EqualTo( value.Member ) ); + } + } + + [Test] + public void TestEnum() + { + TestCore( DayOfWeek.Sunday, stream => ( DayOfWeek )Enum.Parse( typeof( DayOfWeek ), Unpacking.UnpackString( stream ) ), ( x, y ) => x == y ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestNameValueCollection() + { + var target = new NameValueCollection(); + target.Add( String.Empty, "Empty-1" ); + target.Add( String.Empty, "Empty-2" ); + target.Add( "1", "1-1" ); + target.Add( "1", "1-2" ); + target.Add( "1", "1-3" ); + target.Add( "null", null ); // This value will not be packed. + target.Add( "Empty", String.Empty ); + target.Add( "2", "2" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, target ); + stream.Position = 0; + NameValueCollection result = serializer.Unpack( stream ); + Assert.That( result.GetValues( String.Empty ), Is.EquivalentTo( new[] { "Empty-1", "Empty-2" } ) ); + Assert.That( result.GetValues( "1" ), Is.EquivalentTo( new[] { "1-1", "1-2", "1-3" } ) ); + Assert.That( result.GetValues( "null" ), Is.Null ); + Assert.That( result.GetValues( "Empty" ), Is.EquivalentTo( new string[] { String.Empty } ) ); + Assert.That( result.GetValues( "2" ), Is.EquivalentTo( new string[] { "2" } ) ); + // null only value is not packed. + Assert.That( result.Count, Is.EqualTo( target.Count - 1 ) ); + } + } + + [Test] + public void TestNameValueCollection_NullKey() + { + var target = new NameValueCollection(); + target.Add( null, "null" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + Assert.Throws( () => serializer.Pack( stream, target ) ); + } + } +#endif + + [Test] + public void TestByteArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1, 2, 3, 4 } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackBinary( stream ).ToArray(), Is.EqualTo( new byte[] { 1, 2, 3, 4 } ) ); + } + } + + [Test] + public void TestCharArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new char[] { 'a', 'b', 'c', 'd' } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( "abcd" ) ); + } + } + +#if !NETFX_35 + [Test] + public void TestTuple1() + { + TestTupleCore( new Tuple( 1 ) ); + } + + [Test] + public void TestTuple7() + { + TestTupleCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public void TestTuple8() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public void TestTuple14() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public void TestTuple15() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private void TestTupleCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, expected ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( expected ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestTuple1Async() + { + await TestTupleAsyncCore( new Tuple( 1 ) ); + } + + [Test] + public async Task TestTuple7Async() + { + await TestTupleAsyncCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public async Task TestTuple8Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public async Task TestTuple14Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public async Task TestTuple15Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private async Task TestTupleAsyncCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, expected ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( expected ) ); + } + } +#endif // FEATURE_TAP +#endif // !NETFX_35 + + [Test] + public void TestEmptyBytes() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyBytes_Classic() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = this.CreateTarget( context ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyString() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, String.Empty ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( String.Empty ) ); + } + } + + [Test] + public void TestEmptyIntArray() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new int[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new int[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyKeyValuePairArray() + { + var serializer = this.CreateTarget[]>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new KeyValuePair[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new KeyValuePair[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyMap() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new Dictionary() ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new Dictionary() ) ); + } + } + + [Test] + public void TestNullable() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + serializer.Pack( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( null ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestNullableAsync() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + await serializer.PackAsync( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( null ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestValueType_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestValueTypeAsync_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + await serializer.PackAsync( stream, value ); + stream.Position = 0; + var result = await serializer.UnpackAsync( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } +#endif // FEATURE_TAP + + // Issue81 + [Test] + public void TestMultiDimensionalArray() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } + +#if FEATURE_TAP + // Issue81 + [Test] + public async Task TestMultiDimensionalArrayAsync() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, array ); + stream.Position = 0; + + var result = await serializer.UnpackAsync( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestMultiDimensionalArrayComprex() + { + var array = new int [ 2, 3, 4 ]; + array[ 0, 0, 0 ] = 0; + array[ 0, 0, 1 ] = 1; + array[ 0, 0, 2 ] = 2; + array[ 0, 0, 3 ] = 3; + array[ 0, 1, 0 ] = 10; + array[ 0, 1, 1 ] = 11; + array[ 0, 1, 2 ] = 12; + array[ 0, 1, 3 ] = 13; + array[ 0, 2, 0 ] = 20; + array[ 0, 2, 1 ] = 21; + array[ 0, 2, 2 ] = 22; + array[ 0, 2, 3 ] = 23; + array[ 1, 0, 0 ] = 100; + array[ 1, 0, 1 ] = 101; + array[ 1, 0, 2 ] = 102; + array[ 1, 0, 3 ] = 103; + array[ 1, 1, 0 ] = 110; + array[ 1, 1, 1 ] = 111; + array[ 1, 1, 2 ] = 112; + array[ 1, 1, 3 ] = 113; + array[ 1, 2, 0 ] = 120; + array[ 1, 2, 1 ] = 121; + array[ 1, 2, 2 ] = 122; + array[ 1, 2, 3 ] = 123; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 3 ) ); + Assert.That( result.Length, Is.EqualTo( 24 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 3 ) ); + Assert.That( result.GetLength( 2 ), Is.EqualTo( 4 ) ); + Assert.That( result[ 0, 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 0, 0, 2 ], Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0, 3 ], Is.EqualTo( 3 ) ); + Assert.That( result[ 0, 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 0, 1, 1 ], Is.EqualTo( 11 ) ); + Assert.That( result[ 0, 1, 2 ], Is.EqualTo( 12 ) ); + Assert.That( result[ 0, 1, 3 ], Is.EqualTo( 13 ) ); + Assert.That( result[ 0, 2, 0 ], Is.EqualTo( 20 ) ); + Assert.That( result[ 0, 2, 1 ], Is.EqualTo( 21 ) ); + Assert.That( result[ 0, 2, 2 ], Is.EqualTo( 22 ) ); + Assert.That( result[ 0, 2, 3 ], Is.EqualTo( 23 ) ); + Assert.That( result[ 1, 0, 0 ], Is.EqualTo( 100 ) ); + Assert.That( result[ 1, 0, 1 ], Is.EqualTo( 101 ) ); + Assert.That( result[ 1, 0, 2 ], Is.EqualTo( 102 ) ); + Assert.That( result[ 1, 0, 3 ], Is.EqualTo( 103 ) ); + Assert.That( result[ 1, 1, 0 ], Is.EqualTo( 110 ) ); + Assert.That( result[ 1, 1, 1 ], Is.EqualTo( 111 ) ); + Assert.That( result[ 1, 1, 2 ], Is.EqualTo( 112 ) ); + Assert.That( result[ 1, 1, 3 ], Is.EqualTo( 113 ) ); + Assert.That( result[ 1, 2, 0 ], Is.EqualTo( 120 ) ); + Assert.That( result[ 1, 2, 1 ], Is.EqualTo( 121 ) ); + Assert.That( result[ 1, 2, 2 ], Is.EqualTo( 122 ) ); + Assert.That( result[ 1, 2, 3 ], Is.EqualTo( 123 ) ); + } + } + + [Test] +#if UNITY_WORKAROUND + [Ignore( "Unity's Array.SetValue is buggy for non-SZArray" )] +#endif // UNITY_WORKAROUND + public void TestNonZeroBoundArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2 }, new [] { 1 } ); + array.SetValue( 1, 1 ); + array.SetValue( 2, 2 ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); +#if !SILVERLIGHT + Assert.That( result, Is.TypeOf( array.GetType() ) ); +#else + // Silverlight does not support lower bound settings, so sz array will return. + Assert.That( result, Is.TypeOf() ); +#endif // !SILVERLIGHT + Assert.That( result.Rank, Is.EqualTo( 1 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 2 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 3 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetValue( 2 ), Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestNonZeroBoundMultidimensionalArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2, 2 }, new [] { 1, 1 } ); + array.SetValue( 11, new [] { 1, 1 } ); + array.SetValue( 12, new [] { 1, 2 } ); + array.SetValue( 21, new [] { 2, 1 } ); + array.SetValue( 22, new [] { 2, 2 } ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf( array.GetType() ) ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 9 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1, 1 ), Is.EqualTo( 11 ) ); + Assert.That( result.GetValue( 1, 2 ), Is.EqualTo( 12 ) ); + Assert.That( result.GetValue( 2, 1 ), Is.EqualTo( 21 ) ); + Assert.That( result.GetValue( 2, 2 ), Is.EqualTo( 22 ) ); + } + } + + + [Test] + public void TestHasInitOnlyFieldWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherNameConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherNameConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( 0 ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherTypeConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherTypeConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( "0" ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAttribute_Preferred() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithConstructorAttribute( 1, false ); + Assert.That( value.IsAttributePreferred, Is.False ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1 ) ); + Assert.That( result.IsAttributePreferred, Is.True ); + } + } + + [Test] + public void TestConstrutorDeserializationWithMultipleAttributes_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + + [Test] + public void TestOptionalConstructorByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( byte )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorSByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( sbyte )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( short )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ushort )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( uint )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2L ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ulong )2L ) ); + } + } + + [Test] + public void TestOptionalConstructorSingle_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2f ) ); + } + } + + [Test] + public void TestOptionalConstructorDouble_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2 ) ); + } + } + + [Test] + public void TestOptionalConstructorDecimal_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2m ) ); + } + } + + [Test] + public void TestOptionalConstructorBoolean_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( true ) ); + } + } + + [Test] + public void TestOptionalConstructorChar_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 'A' ) ); + } + } + + [Test] + public void TestOptionalConstructorString_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestCollection_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new Collection() { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIListValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new ListValueType( 3 ) { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIDictionaryValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new DictionaryValueType( 3 ) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EquivalentTo( Enumerable.Range( 1, 3 ).Select( i => new KeyValuePair( i, i ) ).ToArray() ) ); + } + } + + [Test] + public void TestPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.Unpack( stream ), "Round-trip should not be succeeded." ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + + [Test] + public void TestUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(), "Round-trip should not be succeeded." ); + } + } + + [Test] + public void TestAsyncUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustAsyncUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new PackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( PackableUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new AsyncPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( AsyncPackableUnpackable.Dummy ) ); + } + } + + [Test] + public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new FullPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestBinary_ClassicContext() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.MinimumFixedRaw + 1, 1 } ) ); + } + } + + [Test] + public void TestBinary_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) ); + } + } + [Test] + public void TestExt_ClassicContext() + { + var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_DefaultContext() + { + var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None; + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_Default_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_WithoutRegistration_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Unregister( typeof( IList<> ) ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistration_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList<> ), typeof( Collection<> ) ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistrationForSpecific_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( Collection ) ); + var serializer1 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer1.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer1.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + + // check other types are not affected + var serializer2 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractStringCollection() { Collection = new[] { "1", "2" } }; + serializer2.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer2.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( "1" ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( "2" ) ); + } + } + + [Test] + public void TestAbstractTypes_NotACollection_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + +#if !NETFX_35 && !UNITY + [Test] + public void TestReadOnlyCollectionInterfaceDefault() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + null + ); + } + + [Test] + public void TestReadOnlyCollectionInterfaceExplicit() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyCollection ), typeof( AppendableReadOnlyCollection ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyList ), typeof( AppendableReadOnlyList ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyDictionary ), typeof( AppendableReadOnlyDictionary ) ) + ); + } + + private static void TestCollectionInterfaceCore( byte[] data, Action assertion, Action registration ) + { + using ( var buffer = new MemoryStream(data) ) + { + var serializer = MessagePackSerializer.Get( NewSerializationContext( PackerCompatibilityOptions.None ) ); + var result = serializer.Unpack( buffer ); + assertion( result ); + } + } +#endif // !NETFX_35 && !UNITY + + private void TestCore( T value, Func unpacking, Func comparer ) + { + TestCore( value, unpacking, comparer, null ); + } + + private void TestCore( T value, Func unpacking, Func comparer, Action contextAdjuster ) + { + var safeComparer = comparer ?? EqualityComparer.Default.Equals; + var context = GetSerializationContext(); + if ( contextAdjuster != null ) + { + contextAdjuster( context ); + } + + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T intermediate = unpacking( buffer ); + Assert.That( safeComparer( intermediate, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, intermediate ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + Assert.That( safeComparer( unpacked, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, unpacked ); + } + } + + private void TestCoreWithVerify( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#if FEATURE_TAP + + private async Task TestCoreWithVerifyAsync( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ); + buffer.Position = 0; + T unpacked = await target.UnpackAsync( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_Plain() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, hasEnumerable ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestIssue25_PlainAsync() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, hasEnumerable ); + buffer.Position = 0; + var result = await target.UnpackAsync( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_SelfComposite() + { + SerializationContext serializationContext = + SerializationContext.Default; + try + { + + serializationContext.Serializers.Register( new PersonSerializer() ); + serializationContext.Serializers.Register( new ChildrenSerializer() ); + + object[] array = new object[] { new Person { Name = "Joe" }, 3 }; + + MessagePackSerializer context = + serializationContext.GetSerializer(); + + byte[] packed = context.PackSingleObject( array ); + object[] unpacked = context.UnpackSingleObject( packed ); + + Assert.That( unpacked.Length, Is.EqualTo( 2 ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Name" ].AsString(), Is.EqualTo( "Joe" ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Children" ].IsNil ); + Assert.That( ( MessagePackObject )unpacked[ 1 ], Is.EqualTo( new MessagePackObject( 3 ) ) ); + } + finally + { + SerializationContext.Default = new SerializationContext(); + } + } + +#region -- ReadOnly / Private Members -- + + // ReSharper disable UnusedMember.Local + // member names + private const string PublicProperty = "PublicProperty"; + private const string PublicReadOnlyProperty = "PublicReadOnlyProperty"; + private const string NonPublicProperty = "NonPublicProperty"; + private const string PublicPropertyPlain = "PublicPropertyPlain"; + private const string PublicReadOnlyPropertyPlain = "PublicReadOnlyPropertyPlain"; + private const string NonPublicPropertyPlain = "NonPublicPropertyPlain"; + private const string CollectionReadOnlyProperty = "CollectionReadOnlyProperty"; + private const string NonPublicCollectionProperty = "NonPublicCollectionProperty"; + private const string NonPublicCollectionField = "NonPublicCollectionField"; + private const string NonPublicCollectionReadOnlyProperty = "NonPublicCollectionReadOnlyProperty"; + private const string NonPublicCollectionReadOnlyField = "NonPublicCollectionReadOnlyField"; + private const string NonPublicDictionaryProperty = "NonPublicDictionaryProperty"; + private const string NonPublicDictionaryField = "NonPublicDictionaryField"; + private const string NonPublicDictionaryReadOnlyProperty = "NonPublicDictionaryReadOnlyProperty"; + private const string NonPublicDictionaryReadOnlyField = "NonPublicDictionaryReadOnlyField"; + private const string NonPublicIDictionaryProperty = "NonPublicIDictionaryProperty"; + private const string NonPublicIDictionaryField = "NonPublicIDictionaryField"; + private const string NonPublicIDictionaryReadOnlyProperty = "NonPublicIDictionaryReadOnlyProperty"; + private const string NonPublicIDictionaryReadOnlyField = "NonPublicIDictionaryReadOnlyField"; + private const string PublicField = "PublicField"; + private const string PublicReadOnlyField = "PublicReadOnlyField"; + private const string NonPublicField = "NonPublicField"; + private const string PublicFieldPlain = "PublicFieldPlain"; + private const string PublicReadOnlyFieldPlain = "PublicReadOnlyFieldPlain"; + private const string NonPublicFieldPlain = "NonPublicFieldPlain"; +#if !NETFX_CORE && !SILVERLIGHT + private const string NonSerializedPublicField = "NonSerializedPublicField"; + private const string NonSerializedPublicReadOnlyField = "NonSerializedPublicReadOnlyField"; + private const string NonSerializedNonPublicField = "NonSerializedNonPublicField"; + private const string NonSerializedPublicFieldPlain = "NonSerializedPublicFieldPlain"; + private const string NonSerializedPublicReadOnlyFieldPlain = "NonSerializedPublicReadOnlyFieldPlain"; + private const string NonSerializedNonPublicFieldPlain = "NonSerializedNonPublicFieldPlain"; +#endif // !NETFX_CORE && !SILVERLIGHT + // ReSharper restore UnusedMember.Local + + [Test] + public void TestNonPublicWritableMember_PlainOldCliClass() + { + var target = new PlainClass(); + target.InitializeCollectionMembers(); + TestNonPublicWritableMemberCore( target, PublicProperty, PublicField, CollectionReadOnlyProperty ); + } + + [Test] + public void TestNonPublicWritableMember_MessagePackMember() + { + var target = new AnnotatedClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + [Test] + public void TestNonPublicWritableMember_DataContract() + { + // includes issue33 + var target = new DataMamberClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + private void TestNonPublicWritableMemberCore( T original, params string[] expectedMemberNames ) + { + var serializer = CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, original ); + buffer.Position = 0; + var actual = serializer.Unpack( buffer ); + + foreach ( var memberName in expectedMemberNames ) + { + Func getter = null; +#if !NETFX_CORE + var property = typeof( T ).GetProperty( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var property = typeof( T ).GetRuntimeProperties().SingleOrDefault( p => p.Name == memberName ); +#endif + if ( property != null ) + { +#if !UNITY + getter = obj => property.GetValue( obj, null ); +#else + getter = obj => property.GetGetMethod( true ).InvokePreservingExceptionType( obj ); +#endif // !UNITY + } + else + { +#if !NETFX_CORE + var field = typeof( T ).GetField( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var field = typeof( T ).GetRuntimeFields().SingleOrDefault( f => f.Name == memberName ); +#endif + if ( field == null ) + { + Assert.Fail( memberName + " is not found." ); + } + + getter = obj => field.GetValue( obj ); + } + + // Naive, but OK + if ( memberName.Contains( "IDictionary" ) ) + { + Func> toDictionary = + hashTable => + ( ( System.Collections.IEnumerable )hashTable ) + .OfType() + .ToDictionary( + de => de.Key.ToString(), + de => + ( de.Value is MessagePackObject ) + ? ( int )( MessagePackObject )de.Value + : ( int )de.Value + ); + + Assert.That( toDictionary( getter( actual ) ), Is.EqualTo( toDictionary( getter( original ) ) ), typeof(T) + "." + memberName ); + } + else + { + Assert.That( getter( actual ), Is.EqualTo( getter( original ) ), typeof(T) + "." + memberName ); + } + } + } + } + +#endregion -- ReadOnly / Private Members -- + +#region -- IPackabke/IUnpackable -- + + // Issue 150 + [Test] + public void TestExplicitlyImplementedPackableUnpackable() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new PackableUnpackableImplementedExplictly(); + obj.Data = "ABC"; + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + Assert.That( actual.Data, Is.EqualTo( PackableUnpackableImplementedExplictly.UnpackingPrefix + PackableUnpackableImplementedExplictly.PackingPrefix + obj.Data ) ); + } + } + + // Issue153 + + + [Test] + public void TestEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP + +#endregion -- IPackabke/IUnpackable -- + +#region -- Exclusion -- + + private void TestIgnoreCore( Action setter, Action assertion ) + where T : new() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new T(); + setter( obj ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + assertion( obj, actual ); + } + } + + private void TestIgnoreCore() + where TException : Exception + { + Assert.Throws( () => GetSerializationContext().GetSerializer() ); + } + + [Test] + public void TestIgnore_Normal() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotIgnored = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotIgnored, Is.EqualTo( expected.NotIgnored ) ); + } + ); + } + + [Test] + public void TestIgnore_ExcludedOnly() + { + TestIgnoreCore(); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionMixed() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotMarked = "ABC"; + target.Marked = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotMarked, Is.Null ); + Assert.That( actual.Marked, Is.EqualTo( expected.Marked ) ); + } + ); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionSimulatously() + { + TestIgnoreCore(); + } + + + public class OnlyExcluded + { + [MessagePackIgnore] + public string Ignored { get; set; } + } + + public class Excluded + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotIgnored { get; set; } + } + + public class ExclusionAndInclusionMixed + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotMarked { get; set; } + + [MessagePackMember( 0 )] + public string Marked { get; set; } + } + + public class ExclusionAndInclusionSimulatously + { + [MessagePackMember( 0 )] + public string Marked { get; set; } + + [MessagePackIgnore] + [MessagePackMember( 1 )] + public string DoubleMarked { get; set; } + } + +#endregion -- Exclusion -- + +#if !UNITY + // Mono 2.7.3 AOT fails when these classes are used... + // Issue 119 +#region -- Generic -- + + [Test] + public void TestGenericDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericValueClass + { + GenericField = 1, + GenericProperty = 2 + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericReferenceClass + { + GenericField = "1", + GenericProperty = "2" + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordValueClass( 1, 2 ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordReferenceClass( "1", "2" ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + +#endregion -- Generic -- + +#region -- Nullable -- + // Issue #121 + + [Test] + public void TestNullable_Primitive_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DateTime.UtcNow.Millisecond; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Primitive_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( int? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = TimeSpan.FromSeconds( DateTime.UtcNow.Millisecond ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( TimeSpan? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DayOfWeek.Monday; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( DayOfWeek? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } +#endregion -- Nullable -- + +#endif // !UNITY + + + // Related to issue #62 -- internal types handling is not consistent at first. + + [Test] + public void TestNonPublicType_Plain_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_MessagePackMember_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_DataContract_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + // Issue 170 + [Test] + public void TestStaticMembersDoNotCausePrepareError() + { + MessagePackSerializer.Get().PackSingleObject( new ClassHasStaticField() ); + } + +#pragma warning disable 649 + internal class NonPublic + { + public int Value; + } + + internal class NonPublicWithMessagePackMember + { + [MessagePackMember( 0 )] + public int Value; + } + + [DataContract] + internal class NonPublicWithDataContract + { + [DataMember] + public int Value; + } +#pragma warning restore 649 + + // issue #63 + [Test] + public void TestManyMembers() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + var target = new WithManyMembers(); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + +#pragma warning disable 659 + public class WithManyMembers + { + private readonly int[] _backingField = Enumerable.Range( 0, SByte.MaxValue + 2 ).ToArray(); + + public int Member0 + { + get { return this._backingField[ 0 ]; } + set { this._backingField[ 0 ] = value; } + } + public int Member1 + { + get { return this._backingField[ 1 ]; } + set { this._backingField[ 1 ] = value; } + } + public int Member2 + { + get { return this._backingField[ 2 ]; } + set { this._backingField[ 2 ] = value; } + } + public int Member3 + { + get { return this._backingField[ 3 ]; } + set { this._backingField[ 3 ] = value; } + } + public int Member4 + { + get { return this._backingField[ 4 ]; } + set { this._backingField[ 4 ] = value; } + } + public int Member5 + { + get { return this._backingField[ 5 ]; } + set { this._backingField[ 5 ] = value; } + } + public int Member6 + { + get { return this._backingField[ 6 ]; } + set { this._backingField[ 6 ] = value; } + } + public int Member7 + { + get { return this._backingField[ 7 ]; } + set { this._backingField[ 7 ] = value; } + } + public int Member8 + { + get { return this._backingField[ 8 ]; } + set { this._backingField[ 8 ] = value; } + } + public int Member9 + { + get { return this._backingField[ 9 ]; } + set { this._backingField[ 9 ] = value; } + } + public int Member10 + { + get { return this._backingField[ 10 ]; } + set { this._backingField[ 10 ] = value; } + } + public int Member11 + { + get { return this._backingField[ 11 ]; } + set { this._backingField[ 11 ] = value; } + } + public int Member12 + { + get { return this._backingField[ 12 ]; } + set { this._backingField[ 12 ] = value; } + } + public int Member13 + { + get { return this._backingField[ 13 ]; } + set { this._backingField[ 13 ] = value; } + } + public int Member14 + { + get { return this._backingField[ 14 ]; } + set { this._backingField[ 14 ] = value; } + } + public int Member15 + { + get { return this._backingField[ 15 ]; } + set { this._backingField[ 15 ] = value; } + } + public int Member16 + { + get { return this._backingField[ 16 ]; } + set { this._backingField[ 16 ] = value; } + } + public int Member17 + { + get { return this._backingField[ 17 ]; } + set { this._backingField[ 17 ] = value; } + } + public int Member18 + { + get { return this._backingField[ 18 ]; } + set { this._backingField[ 18 ] = value; } + } + public int Member19 + { + get { return this._backingField[ 19 ]; } + set { this._backingField[ 19 ] = value; } + } + public int Member20 + { + get { return this._backingField[ 20 ]; } + set { this._backingField[ 20 ] = value; } + } + public int Member21 + { + get { return this._backingField[ 21 ]; } + set { this._backingField[ 21 ] = value; } + } + public int Member22 + { + get { return this._backingField[ 22 ]; } + set { this._backingField[ 22 ] = value; } + } + public int Member23 + { + get { return this._backingField[ 23 ]; } + set { this._backingField[ 23 ] = value; } + } + public int Member24 + { + get { return this._backingField[ 24 ]; } + set { this._backingField[ 24 ] = value; } + } + public int Member25 + { + get { return this._backingField[ 25 ]; } + set { this._backingField[ 25 ] = value; } + } + public int Member26 + { + get { return this._backingField[ 26 ]; } + set { this._backingField[ 26 ] = value; } + } + public int Member27 + { + get { return this._backingField[ 27 ]; } + set { this._backingField[ 27 ] = value; } + } + public int Member28 + { + get { return this._backingField[ 28 ]; } + set { this._backingField[ 28 ] = value; } + } + public int Member29 + { + get { return this._backingField[ 29 ]; } + set { this._backingField[ 29 ] = value; } + } + public int Member30 + { + get { return this._backingField[ 30 ]; } + set { this._backingField[ 30 ] = value; } + } + public int Member31 + { + get { return this._backingField[ 31 ]; } + set { this._backingField[ 31 ] = value; } + } + public int Member32 + { + get { return this._backingField[ 32 ]; } + set { this._backingField[ 32 ] = value; } + } + public int Member33 + { + get { return this._backingField[ 33 ]; } + set { this._backingField[ 33 ] = value; } + } + public int Member34 + { + get { return this._backingField[ 34 ]; } + set { this._backingField[ 34 ] = value; } + } + public int Member35 + { + get { return this._backingField[ 35 ]; } + set { this._backingField[ 35 ] = value; } + } + public int Member36 + { + get { return this._backingField[ 36 ]; } + set { this._backingField[ 36 ] = value; } + } + public int Member37 + { + get { return this._backingField[ 37 ]; } + set { this._backingField[ 37 ] = value; } + } + public int Member38 + { + get { return this._backingField[ 38 ]; } + set { this._backingField[ 38 ] = value; } + } + public int Member39 + { + get { return this._backingField[ 39 ]; } + set { this._backingField[ 39 ] = value; } + } + public int Member40 + { + get { return this._backingField[ 40 ]; } + set { this._backingField[ 40 ] = value; } + } + public int Member41 + { + get { return this._backingField[ 41 ]; } + set { this._backingField[ 41 ] = value; } + } + public int Member42 + { + get { return this._backingField[ 42 ]; } + set { this._backingField[ 42 ] = value; } + } + public int Member43 + { + get { return this._backingField[ 43 ]; } + set { this._backingField[ 43 ] = value; } + } + public int Member44 + { + get { return this._backingField[ 44 ]; } + set { this._backingField[ 44 ] = value; } + } + public int Member45 + { + get { return this._backingField[ 45 ]; } + set { this._backingField[ 45 ] = value; } + } + public int Member46 + { + get { return this._backingField[ 46 ]; } + set { this._backingField[ 46 ] = value; } + } + public int Member47 + { + get { return this._backingField[ 47 ]; } + set { this._backingField[ 47 ] = value; } + } + public int Member48 + { + get { return this._backingField[ 48 ]; } + set { this._backingField[ 48 ] = value; } + } + public int Member49 + { + get { return this._backingField[ 49 ]; } + set { this._backingField[ 49 ] = value; } + } + public int Member50 + { + get { return this._backingField[ 50 ]; } + set { this._backingField[ 50 ] = value; } + } + public int Member51 + { + get { return this._backingField[ 51 ]; } + set { this._backingField[ 51 ] = value; } + } + public int Member52 + { + get { return this._backingField[ 52 ]; } + set { this._backingField[ 52 ] = value; } + } + public int Member53 + { + get { return this._backingField[ 53 ]; } + set { this._backingField[ 53 ] = value; } + } + public int Member54 + { + get { return this._backingField[ 54 ]; } + set { this._backingField[ 54 ] = value; } + } + public int Member55 + { + get { return this._backingField[ 55 ]; } + set { this._backingField[ 55 ] = value; } + } + public int Member56 + { + get { return this._backingField[ 56 ]; } + set { this._backingField[ 56 ] = value; } + } + public int Member57 + { + get { return this._backingField[ 57 ]; } + set { this._backingField[ 57 ] = value; } + } + public int Member58 + { + get { return this._backingField[ 58 ]; } + set { this._backingField[ 58 ] = value; } + } + public int Member59 + { + get { return this._backingField[ 59 ]; } + set { this._backingField[ 59 ] = value; } + } + public int Member60 + { + get { return this._backingField[ 60 ]; } + set { this._backingField[ 60 ] = value; } + } + public int Member61 + { + get { return this._backingField[ 61 ]; } + set { this._backingField[ 61 ] = value; } + } + public int Member62 + { + get { return this._backingField[ 62 ]; } + set { this._backingField[ 62 ] = value; } + } + public int Member63 + { + get { return this._backingField[ 63 ]; } + set { this._backingField[ 63 ] = value; } + } + public int Member64 + { + get { return this._backingField[ 64 ]; } + set { this._backingField[ 64 ] = value; } + } + public int Member65 + { + get { return this._backingField[ 65 ]; } + set { this._backingField[ 65 ] = value; } + } + public int Member66 + { + get { return this._backingField[ 66 ]; } + set { this._backingField[ 66 ] = value; } + } + public int Member67 + { + get { return this._backingField[ 67 ]; } + set { this._backingField[ 67 ] = value; } + } + public int Member68 + { + get { return this._backingField[ 68 ]; } + set { this._backingField[ 68 ] = value; } + } + public int Member69 + { + get { return this._backingField[ 69 ]; } + set { this._backingField[ 69 ] = value; } + } + public int Member70 + { + get { return this._backingField[ 70 ]; } + set { this._backingField[ 70 ] = value; } + } + public int Member71 + { + get { return this._backingField[ 71 ]; } + set { this._backingField[ 71 ] = value; } + } + public int Member72 + { + get { return this._backingField[ 72 ]; } + set { this._backingField[ 72 ] = value; } + } + public int Member73 + { + get { return this._backingField[ 73 ]; } + set { this._backingField[ 73 ] = value; } + } + public int Member74 + { + get { return this._backingField[ 74 ]; } + set { this._backingField[ 74 ] = value; } + } + public int Member75 + { + get { return this._backingField[ 75 ]; } + set { this._backingField[ 75 ] = value; } + } + public int Member76 + { + get { return this._backingField[ 76 ]; } + set { this._backingField[ 76 ] = value; } + } + public int Member77 + { + get { return this._backingField[ 77 ]; } + set { this._backingField[ 77 ] = value; } + } + public int Member78 + { + get { return this._backingField[ 78 ]; } + set { this._backingField[ 78 ] = value; } + } + public int Member79 + { + get { return this._backingField[ 79 ]; } + set { this._backingField[ 79 ] = value; } + } + public int Member80 + { + get { return this._backingField[ 80 ]; } + set { this._backingField[ 80 ] = value; } + } + public int Member81 + { + get { return this._backingField[ 81 ]; } + set { this._backingField[ 81 ] = value; } + } + public int Member82 + { + get { return this._backingField[ 82 ]; } + set { this._backingField[ 82 ] = value; } + } + public int Member83 + { + get { return this._backingField[ 83 ]; } + set { this._backingField[ 83 ] = value; } + } + public int Member84 + { + get { return this._backingField[ 84 ]; } + set { this._backingField[ 84 ] = value; } + } + public int Member85 + { + get { return this._backingField[ 85 ]; } + set { this._backingField[ 85 ] = value; } + } + public int Member86 + { + get { return this._backingField[ 86 ]; } + set { this._backingField[ 86 ] = value; } + } + public int Member87 + { + get { return this._backingField[ 87 ]; } + set { this._backingField[ 87 ] = value; } + } + public int Member88 + { + get { return this._backingField[ 88 ]; } + set { this._backingField[ 88 ] = value; } + } + public int Member89 + { + get { return this._backingField[ 89 ]; } + set { this._backingField[ 89 ] = value; } + } + public int Member90 + { + get { return this._backingField[ 90 ]; } + set { this._backingField[ 90 ] = value; } + } + public int Member91 + { + get { return this._backingField[ 91 ]; } + set { this._backingField[ 91 ] = value; } + } + public int Member92 + { + get { return this._backingField[ 92 ]; } + set { this._backingField[ 92 ] = value; } + } + public int Member93 + { + get { return this._backingField[ 93 ]; } + set { this._backingField[ 93 ] = value; } + } + public int Member94 + { + get { return this._backingField[ 94 ]; } + set { this._backingField[ 94 ] = value; } + } + public int Member95 + { + get { return this._backingField[ 95 ]; } + set { this._backingField[ 95 ] = value; } + } + public int Member96 + { + get { return this._backingField[ 96 ]; } + set { this._backingField[ 96 ] = value; } + } + public int Member97 + { + get { return this._backingField[ 97 ]; } + set { this._backingField[ 97 ] = value; } + } + public int Member98 + { + get { return this._backingField[ 98 ]; } + set { this._backingField[ 98 ] = value; } + } + public int Member99 + { + get { return this._backingField[ 99 ]; } + set { this._backingField[ 99 ] = value; } + } + public int Member100 + { + get { return this._backingField[ 100 ]; } + set { this._backingField[ 100 ] = value; } + } + public int Member101 + { + get { return this._backingField[ 101 ]; } + set { this._backingField[ 101 ] = value; } + } + public int Member102 + { + get { return this._backingField[ 102 ]; } + set { this._backingField[ 102 ] = value; } + } + public int Member103 + { + get { return this._backingField[ 103 ]; } + set { this._backingField[ 103 ] = value; } + } + public int Member104 + { + get { return this._backingField[ 104 ]; } + set { this._backingField[ 104 ] = value; } + } + public int Member105 + { + get { return this._backingField[ 105 ]; } + set { this._backingField[ 105 ] = value; } + } + public int Member106 + { + get { return this._backingField[ 106 ]; } + set { this._backingField[ 106 ] = value; } + } + public int Member107 + { + get { return this._backingField[ 107 ]; } + set { this._backingField[ 107 ] = value; } + } + public int Member108 + { + get { return this._backingField[ 108 ]; } + set { this._backingField[ 108 ] = value; } + } + public int Member109 + { + get { return this._backingField[ 109 ]; } + set { this._backingField[ 109 ] = value; } + } + public int Member110 + { + get { return this._backingField[ 110 ]; } + set { this._backingField[ 110 ] = value; } + } + public int Member111 + { + get { return this._backingField[ 111 ]; } + set { this._backingField[ 111 ] = value; } + } + public int Member112 + { + get { return this._backingField[ 112 ]; } + set { this._backingField[ 112 ] = value; } + } + public int Member113 + { + get { return this._backingField[ 113 ]; } + set { this._backingField[ 113 ] = value; } + } + public int Member114 + { + get { return this._backingField[ 114 ]; } + set { this._backingField[ 114 ] = value; } + } + public int Member115 + { + get { return this._backingField[ 115 ]; } + set { this._backingField[ 115 ] = value; } + } + public int Member116 + { + get { return this._backingField[ 116 ]; } + set { this._backingField[ 116 ] = value; } + } + public int Member117 + { + get { return this._backingField[ 117 ]; } + set { this._backingField[ 117 ] = value; } + } + public int Member118 + { + get { return this._backingField[ 118 ]; } + set { this._backingField[ 118 ] = value; } + } + public int Member119 + { + get { return this._backingField[ 119 ]; } + set { this._backingField[ 119 ] = value; } + } + public int Member120 + { + get { return this._backingField[ 120 ]; } + set { this._backingField[ 120 ] = value; } + } + public int Member121 + { + get { return this._backingField[ 121 ]; } + set { this._backingField[ 121 ] = value; } + } + public int Member122 + { + get { return this._backingField[ 122 ]; } + set { this._backingField[ 122 ] = value; } + } + public int Member123 + { + get { return this._backingField[ 123 ]; } + set { this._backingField[ 123 ] = value; } + } + public int Member124 + { + get { return this._backingField[ 124 ]; } + set { this._backingField[ 124 ] = value; } + } + public int Member125 + { + get { return this._backingField[ 125 ]; } + set { this._backingField[ 125 ] = value; } + } + public int Member126 + { + get { return this._backingField[ 126 ]; } + set { this._backingField[ 126 ] = value; } + } + public int Member127 + { + get { return this._backingField[ 127 ]; } + set { this._backingField[ 127 ] = value; } + } + public int Member128 + { + get { return this._backingField[ 128 ]; } + set { this._backingField[ 128 ] = value; } + } + + public override bool Equals( object obj ) + { + var other = obj as WithManyMembers; + if ( other == null ) + { + return false; + } + + return this._backingField == other._backingField || this._backingField.SequenceEqual( other._backingField ); + } + } +#pragma warning restore 659 + +#region issue #169 + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new GenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new NonGenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + +#endregion issue #169 + + #region -- Asymmetric -- + [Test] + public void TestAsymmetric_PackOnly_NoSettableNoConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableNoConstructorsForAsymmetricTest().Initialize( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoSettableMultipleConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableMultipleConstructorsForAsymmetricTest( "A", 0 ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoDefaultConstructor_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoDefaultConstructorForAsymmetricTest( 'A' ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableDictionaryForAsymmetricTest( new KeyValuePair( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericDictionaryForAsymmetricTest( new DictionaryEntry( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + + [Test] + public void TestAsymmetric_PackOnly_UnsettableArrayMemberObject_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnsettableArrayMemberObjectForAsymmetricTest(), + SerializerCapabilities.PackTo, + new byte[] { 0x92, 0x91, 0xA1, ( byte )'A', 0x91, 0xA1, ( byte )'A' } + ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized ) + { + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, true ); + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, false ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized, bool avoidsGenericSerializer ) + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowAsymmetricSerializer = true; + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + + var serializer = this.CreateTarget( context ); + Assert.That( serializer.Capabilities, Is.EqualTo( expectedCapabilities ) ); + + var obj = factory(); + using ( var buffer = new MemoryStream() ) + { + if ( ( expectedCapabilities & SerializerCapabilities.PackTo ) != 0 ) + { + serializer.Pack( buffer, obj ); + Assert.That( buffer.ToArray(), Is.EqualTo( serialized ), "{0} != {1}", BitConverter.ToString( buffer.ToArray() ), BitConverter.ToString( serialized ) ); + } + else if ( ( expectedCapabilities & SerializerCapabilities.UnpackFrom ) != 0 ) + { + buffer.Write( serialized, 0, serialized.Length ); + buffer.Position = 0; + var unpacked = serializer.Unpack( buffer ); + Assert.That( obj, Is.EqualTo( unpacked ) ); + } + } + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Asymmetric -- + + #region -- Object Packing/Unpacking -- + + [Test] + public void TestToFromMessagePackObject_Complex() + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestToFromMessagePackObjectCore( + target, + mpo => + { + Assert.That( mpo.IsArray ); + var asList = mpo.AsList(); + Assert.That( asList.Count, Is.EqualTo( 5 ) ); + + Assert.That( asList[ 0 ].IsTypeOf().Value ); + Assert.That( asList[ 0 ].AsString(), Is.EqualTo( target.Source.ToString() ) ); + + Assert.That( asList[ 1 ].IsTypeOf().Value ); + Assert.That( asList[ 1 ].AsBinary(), Is.EqualTo( target.Data ) ); + + Assert.That( asList[ 2 ].IsTypeOf().Value ); + Assert.That( asList[ 2 ].AsInt64(), Is.EqualTo( target.TimeStamp.ToBinary() ) ); + + Assert.That( asList[ 3 ].IsDictionary ); + Assert.That( asList[ 3 ].AsDictionary().Single().Key.AsInt64(), Is.EqualTo( target.History.Single().Key.ToBinary() ) ); + Assert.That( asList[ 3 ].AsDictionary().Single().Value.AsString(), Is.EqualTo( target.History.Single().Value ) ); + + Assert.That( asList[ 4 ].IsArray ); + Assert.That( asList[ 4 ].AsList().Single().AsInt32(), Is.EqualTo( target.Points.Single() ) ); + } + ); + } + + [Test] + public void TestToFromMessagePackObject_ComplexGenerated() + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + // This test does not check packed result -- it is verfied with previous test and seems overkill. + this.TestToFromMessagePackObjectCore( target, _ => {} ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion ) + where T : IVerifiable + { + this.TestToFromMessagePackObjectCore( value, mpoAssertion, true ); + this.TestToFromMessagePackObjectCore( value, mpoAssertion, false ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion, bool avoidsGenericSerializer ) + where T : IVerifiable + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + var serializer = this.CreateTarget( context ); + var mpo = serializer.ToMessagePackObject( value ); + mpoAssertion( mpo ); + var result = serializer.FromMessagePackObject( mpo ); + result.Verify( value ); + + var mpoLoose = ( ( MessagePackSerializer )serializer ).ToMessagePackObject( value ); + mpoAssertion( mpoLoose ); + var resultLoose = ( ( MessagePackSerializer )serializer ).FromMessagePackObject( mpoLoose ); + Assert.That( resultLoose, Is.TypeOf() ); + ( ( T )resultLoose ).Verify( value ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Object Packing/Unpacking -- + #region -- Polymorphism -- + #region ---- KnownType ---- + + #region ------ KnownType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.NormalTypes ------ + + #region ------ KnownType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.CollectionTypes ------ + + #region ------ KnownType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ KnownType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- KnownType ---- + #region ---- RuntimeType ---- + + #region ------ RuntimeType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.NormalTypes ------ + + #region ------ RuntimeType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.CollectionTypes ------ + + #region ------ RuntimeType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ RuntimeType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- RuntimeType ---- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + target.NormalVanilla = "ABC"; + target.NormalRuntime = new FileEntry { Name = "File", Size = 1 }; + target.NormalKnown = new FileEntry { Name = "File", Size = 2 }; + target.ObjectRuntime = new FileEntry { Name = "File", Size = 3 }; + target.ObjectRuntimeOmittedType = new MsgPack.UnitTest.TestTypes.OmittedType { Value = "ABC" }; + target.ListVanilla = new List { "ABC" }; + target.ListKnownItem = new List { new FileEntry { Name = "File", Size = 1 } }; + target.ListKnwonContainerRuntimeItem = new List { new FileEntry { Name = "File", Size = 2 } }; + target.ListObjectRuntimeItem = new List { new FileEntry { Name = "File", Size = 3 } }; + target.DictionaryVanilla = new Dictionary { { "Key", "ABC" } }; + target.DictionaryKnownValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 1 } } }; + target.DictionaryKnownContainerRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 2 } } }; + target.DictionaryObjectRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 3 } } }; +#if !NETFX_35 && !UNITY + target.Tuple = Tuple.Create( "ABC", new FileEntry { Name = "File", Size = 1 }, new FileEntry { Name = "File", Size = 3 }, new FileEntry { Name = "File", Size = 3 } ); +#endif // !NETFX_35 && !UNITY + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.EqualTo( target.NormalVanilla ), "NormalVanilla" ); + Assert.That( result.NormalVanilla, Is.InstanceOf( target.NormalVanilla.GetType() ), "NormalVanilla" ); + Assert.That( result.NormalRuntime, Is.EqualTo( target.NormalRuntime ), "NormalRuntime" ); + Assert.That( result.NormalRuntime, Is.InstanceOf( target.NormalRuntime.GetType() ), "NormalRuntime" ); + Assert.That( result.NormalKnown, Is.EqualTo( target.NormalKnown ), "NormalKnown" ); + Assert.That( result.NormalKnown, Is.InstanceOf( target.NormalKnown.GetType() ), "NormalKnown" ); + Assert.That( result.ObjectRuntime, Is.EqualTo( target.ObjectRuntime ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntime, Is.InstanceOf( target.ObjectRuntime.GetType() ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.EqualTo( target.ObjectRuntimeOmittedType ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.InstanceOf( target.ObjectRuntimeOmittedType.GetType() ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ListVanilla, Is.EqualTo( target.ListVanilla ), "ListVanilla" ); + Assert.That( result.ListVanilla, Is.InstanceOf( target.ListVanilla.GetType() ), "ListVanilla" ); + Assert.That( result.ListKnownItem, Is.EqualTo( target.ListKnownItem ), "ListKnownItem" ); + Assert.That( result.ListKnownItem, Is.InstanceOf( target.ListKnownItem.GetType() ), "ListKnownItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.EqualTo( target.ListKnwonContainerRuntimeItem ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.InstanceOf( target.ListKnwonContainerRuntimeItem.GetType() ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.EqualTo( target.ListObjectRuntimeItem ), "ListObjectRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.InstanceOf( target.ListObjectRuntimeItem.GetType() ), "ListObjectRuntimeItem" ); + Assert.That( result.DictionaryVanilla, Is.EqualTo( target.DictionaryVanilla ), "DictionaryVanilla" ); + Assert.That( result.DictionaryVanilla, Is.InstanceOf( target.DictionaryVanilla.GetType() ), "DictionaryVanilla" ); + Assert.That( result.DictionaryKnownValue, Is.EqualTo( target.DictionaryKnownValue ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownValue, Is.InstanceOf( target.DictionaryKnownValue.GetType() ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.EqualTo( target.DictionaryKnownContainerRuntimeValue ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.InstanceOf( target.DictionaryKnownContainerRuntimeValue.GetType() ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.EqualTo( target.DictionaryObjectRuntimeValue ), "DictionaryObjectRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.InstanceOf( target.DictionaryObjectRuntimeValue.GetType() ), "DictionaryObjectRuntimeValue" ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.EqualTo( target.Tuple ), "Tuple" ); + Assert.That( result.Tuple, Is.InstanceOf( target.Tuple.GetType() ), "Tuple" ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.Null ); + Assert.That( result.NormalRuntime, Is.Null ); + Assert.That( result.NormalKnown, Is.Null ); + Assert.That( result.ObjectRuntime, Is.Null ); + Assert.That( result.ObjectRuntimeOmittedType, Is.Null ); + Assert.That( result.ListVanilla, Is.Null ); + Assert.That( result.ListKnownItem, Is.Null ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.Null ); + Assert.That( result.ListObjectRuntimeItem, Is.Null ); + Assert.That( result.DictionaryVanilla, Is.Null ); + Assert.That( result.DictionaryKnownValue, Is.Null ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.Null ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.Null ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.Null ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } +#if !NETFX_35 && !UNITY + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTupleAbstractType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new TupleAbstractType { Value = Tuple.Create( new FileEntry { Name = "1", Size = 1 } as AbstractFileSystemEntry, new FileEntry { Name = "2", Size = 2 } as IFileSystemEntry, new FileEntry { Name = "3", Size = 3 } as AbstractFileSystemEntry, new FileEntry { Name = "4", Size = 4 } as IFileSystemEntry ) }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + // Issue 137 + [Test] + [Category( "PolymorphicSerialization" )] + public void TestGlobalNamespace() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#if FEATURE_TAP + [Test] + [Category( "PolymorphicSerialization" )] + public async Task TestGlobalNamespaceAsync() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + await serializer.PackAsync( buffer, target ); + buffer.Position = 0; + var result = await serializer.UnpackAsync( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#endif // FEATURE_TAP + +#region -- Polymorphic Attributes in Type and Member -- + + private static void SetUpDefaultCollectionsForPolymorphism( SerializationContext context ) + { + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicCollection ), typeof( KnownTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicCollection ), typeof( RuntimeTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicDictionary ), typeof( KnownTypePolymorphicDictionary ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicDictionary ), typeof( RuntimeTypePolymorphicDictionary ) ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphismAttributesInType() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + } + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + +#endregion -- Polymorphic Attributes in Type and Member -- + +#region -- TypeVerifier cases -- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoMethods_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoMethods { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseVoidReturnMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierVoidReturnMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseExtraParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierExtraParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierDoesNotLoadTypeItself() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + using ( var packer = Packer.Create( buffer ) ) + { + Polymorphic.TypeInfoEncoder.Encode( packer, typeof( DangerousClass ) ); + packer.PackArrayHeader( 1 ); + packer.PackString( "Foo" ); // Value + buffer.Position = 0; + var ex = Assert.Catch( () => serializer.Unpack( buffer ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "Type verifier rejects type " ) ); +#else + Assert.That( ex.Message.StartsWith( "Type verifier rejects type " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + +#endregion -- TypeVerifier cases -- + + + #endregion -- Polymorphism -- + [Test] + public void TestNullField() + { + this.TestCoreWithAutoVerify( default( object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( default( object ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestTrueField() + { + this.TestCoreWithAutoVerify( true, GetSerializationContext() ); + } + + [Test] + public void TestTrueFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( true, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestFalseField() + { + this.TestCoreWithAutoVerify( false, GetSerializationContext() ); + } + + [Test] + public void TestFalseFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( false, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyByteField() + { + this.TestCoreWithAutoVerify( 1, GetSerializationContext() ); + } + + [Test] + public void TestTinyByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 1, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteField() + { + this.TestCoreWithAutoVerify( 0x80, GetSerializationContext() ); + } + + [Test] + public void TestByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x80, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxByteField() + { + this.TestCoreWithAutoVerify( 0xff, GetSerializationContext() ); + } + + [Test] + public void TestMaxByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16Field() + { + this.TestCoreWithAutoVerify( 0x100, GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16Field() + { + this.TestCoreWithAutoVerify( 0xffff, GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xffff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32Field() + { + this.TestCoreWithAutoVerify( 0x10000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x10000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64Field() + { + this.TestCoreWithAutoVerify( 0x100000000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100000000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeField() + { + this.TestCoreWithAutoVerify( DateTime.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTime.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( DateTimeOffset.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTimeOffset.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriField() + { + this.TestCoreWithAutoVerify( new Uri( "http://example.com/" ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Uri( "http://example.com/" ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldNull() + { + this.TestCoreWithAutoVerify( default( Uri ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Uri[] ), GetSerializationContext() ); + } + + [Test] + public void TestVersionField() + { + this.TestCoreWithAutoVerify( new Version( 1, 2, 3, 4 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3, 4 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEField() + { + this.TestCoreWithAutoVerify( ToFileTime( DateTime.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( ToFileTime( DateTime.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanField() + { + this.TestCoreWithAutoVerify( TimeSpan.FromMilliseconds( 123456789 ), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( TimeSpan.FromMilliseconds( 123456789 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestGuidField() + { + this.TestCoreWithAutoVerify( Guid.NewGuid(), GetSerializationContext() ); + } + + [Test] + public void TestGuidFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Guid.NewGuid(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharField() + { + this.TestCoreWithAutoVerify( '　', GetSerializationContext() ); + } + + [Test] + public void TestCharFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( '　', 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDecimalField() + { + this.TestCoreWithAutoVerify( 123456789.0987654321m, GetSerializationContext() ); + } + + [Test] + public void TestDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 123456789.0987654321m, 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestBigIntegerField() + { + this.TestCoreWithAutoVerify( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestBigIntegerFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestComplexField() + { + this.TestCoreWithAutoVerify( new Complex( 1.3, 2.4 ), GetSerializationContext() ); + } + + [Test] + public void TestComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Complex( 1.3, 2.4 ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestDictionaryEntryField() + { + this.TestCoreWithAutoVerify( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryEntryFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestKeyValuePairStringComplexField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestStringField() + { + this.TestCoreWithAutoVerify( "StringValue", GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "StringValue", 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldNull() + { + this.TestCoreWithAutoVerify( default( String ), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( String[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayField() + { + this.TestCoreWithAutoVerify( new Byte[]{ 1, 2, 3, 4 }, GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Byte[]{ 1, 2, 3, 4 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Byte[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Byte[][] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayField() + { + this.TestCoreWithAutoVerify( "ABCD".ToCharArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "ABCD".ToCharArray(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Char[] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Char[][] ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32Field() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectField() + { + this.TestCoreWithAutoVerify( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple ), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestImage_Field() + { + this.TestCoreWithAutoVerify( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image ), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image[] ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectField() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayField() + { + this.TestCoreWithAutoVerify( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[][] ), GetSerializationContext() ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestArrayListField() + { + this.TestCoreWithAutoVerify( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldNull() + { + this.TestCoreWithAutoVerify( default( ArrayList ), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ArrayList[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestHashtableField() + { + this.TestCoreWithAutoVerify( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldNull() + { + this.TestCoreWithAutoVerify( default( Hashtable ), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Hashtable[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[][] ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList ), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestCoreWithAutoVerify( T value, SerializationContext context ) + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + AutoMessagePackSerializerTest.Verify( value, unpacked ); + } + } + + private void TestCoreWithVerifiable( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( value ); + } + } + + private void TestCoreWithVerifiable( T[] value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T[] unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.Length, Is.EqualTo( value.Length ) ); + for( int i = 0; i < unpacked.Length; i ++ ) + { + try + { + unpacked[ i ].Verify( value[ i ] ); + } +#if MSTEST + catch( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException ae ) + { + throw new Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#else + catch( AssertionException ae ) + { + throw new AssertionException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#endif + } + } + } + + private static FILETIME ToFileTime( DateTime dateTime ) + { + var fileTime = dateTime.ToFileTimeUtc(); + return new FILETIME(){ dwHighDateTime = unchecked( ( int )( fileTime >> 32 ) ), dwLowDateTime = unchecked( ( int )( fileTime & 0xffffffff ) ) }; + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt new file mode 100644 index 000000000..d4d24f96b --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt @@ -0,0 +1,17 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.ttinclude" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.Types.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Linq" #> +<# +Geneate( "Array", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "CSharp" ); +GenerateTypes(); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.cs new file mode 100644 index 000000000..a0f2bb62c --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.cs @@ -0,0 +1,721 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +#if !NETFX_CORE +using System.Collections; +#endif +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !AOT && !SILVERLIGHT +#if !NETFX_CORE +using Microsoft.FSharp.Collections; +#endif // !NETFX_CORE +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class ArrayCSharpCodeTreeBasedImmutableCollectionsTest + { + private MessagePackSerializer CreateTarget() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context.GetSerializer( PolymorphismSchema.Default ); + } + + private bool CanDump + { + get { return true; } + } + +#if !NETFX_CORE + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif + + [Test] + public void QueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Queue(); + value.Enqueue( 1 ); + value.Enqueue( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void StackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Stack(); + value.Push( 1 ); + value.Push( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + +#if !NETFX_CORE + [Test] + public void NonGenericQueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Queue(); + value.Enqueue( ( MessagePackObject )1 ); + value.Enqueue( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void NonGenericStackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Stack(); + value.Push( ( MessagePackObject )1 ); + value.Push( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } +#endif // !NETFX_CORE + + + [Test] + public void ImmutableArrayTest_0_Success() + { + var collection = ImmutableArray.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_1_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_2_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_0_Success() + { + var collection = ImmutableList.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_1_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_2_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_0_Success() + { + var collection = ImmutableStack.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_1_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_2_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + collection = collection.Push( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_0_Success() + { + var collection = ImmutableQueue.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_1_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_2_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + collection = collection.Enqueue( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_0_Success() + { + var collection = ImmutableHashSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_1_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_2_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_0_Success() + { + var collection = ImmutableSortedSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_1_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_2_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_0_Success() + { + var collection = ImmutableDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_1_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_2_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_0_Success() + { + var collection = ImmutableSortedDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_1_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_2_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#if !NETFX_CORE + + + [Test] + public void FSharpListTest_0_Success() + { + var collection = FSharpList.Empty; + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_1_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_2_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + collection = new FSharpList( 1, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_0_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_1_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_2_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_0_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_1_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_2_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#endif // !NETFX_CORE + + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.tt new file mode 100644 index 000000000..f3c9a70e1 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedCustomCollectionSerializersTest.tt @@ -0,0 +1,15 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest.BclExtensions\Serialization\CustomCollectionSerializersTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "Array", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "CSharp" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.cs new file mode 100644 index 000000000..244f17adc --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.cs @@ -0,0 +1,1344 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2014-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP + +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT + +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 30000 )] + public class ArrayCSharpCodeTreeBasedEnumSerializerTest + { + private SerializationContext GetSerializationContext() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) + { + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( value.ToString() ) ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + // Properties are sorted by lexical order + var index = Array.IndexOf( typeof( T ).GetProperties().OrderBy( p => p.Name ).ToArray(), propertyInfo ); + var result = Unpacking.UnpackArray( stream ); + Assert.That( +#if !UNITY + result[ index ].Equals( propertyInfo.GetValue( value, null ).ToString() ), + result[ index ] + " == " + propertyInfo.GetValue( value, null ) +#else + result[ index ].Equals( propertyInfo.GetGetMethod().Invoke( value, null ).ToString() ), + result[ index ] + " == " + propertyInfo.GetGetMethod().Invoke( value, null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByName( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByNameAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#endif // FEATURE_TAP + + private static void TestEnumForByUnderlyingValueCore( Stream stream, T value, T deserialized, string property ) + { + + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + var result = Unpacking.UnpackObject( stream ); + Assert.That( + result.ToString().Equals( ( ( IFormattable )value ).ToString( "D", null ) ), + result + " == " + ( ( IFormattable )value ).ToString( "D", null ) + ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackArray( stream ); + // Properties are sorted by lexical order + var index = Array.IndexOf( typeof( T ).GetProperties().OrderBy( p => p.Name ).ToArray(), propertyInfo ); + Assert.That( +#if !UNITY + result[ index ].ToString().Equals( ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) ), + result[ index ] + " == " + ( ( IFormattable )propertyInfo.GetValue( value , null) ).ToString( "D", null ) +#else + result[ index ].ToString().Equals( ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) ), + result[ index ] + " == " + ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value , null) ).ToString( "D", null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByUnderlyingValue( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByUnderlyingValueAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumDefault.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumDefault.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumByName.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumByName.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByUnderlyingValueAsync( context, EnumByUnderlyingValue.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + // Issue #184 + [Test] + public void TestEnumKeyTransformer_Default_AsIs() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Default_AsIs_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper_Async() + { + var context = GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestEnumKeyCore( SerializationContext context, string expected, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = MidpointRounding.ToEven; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var stringValue = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsString(); + + Assert.That( stringValue, Is.EqualTo( expected ) ); + + buffer.Position = 0; + + MidpointRounding deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized, Is.EqualTo( obj ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.tt new file mode 100644 index 000000000..319c1a2dc --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayCSharpCodeTreeBasedEnumSerializationTest.tt @@ -0,0 +1,10 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\EnumSerializationTest.ttinclude" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<# +GenerateCore( "Array", "CodeTreeBased", true, false, "CSharp" ); +#> \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs new file mode 100644 index 000000000..bebfee39f --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs @@ -0,0 +1,21770 @@ + + + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Contributors: +// Samuel Cragg +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +#pragma warning disable 3003 +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !NETFX_35 && !WINDOWS_PHONE +using System.Numerics; +#endif // !NETFX_35 && !WINDOWS_PHONE +using System.Reflection; +using System.Runtime.InteropServices.ComTypes; +using System.Runtime.Serialization; +using System.Text; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using CategoryAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCategoryAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +using Does = NUnit.Framework.Does; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 60000 )] + public class ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest + { + private static SerializationContext GetSerializationContext() + { +#if !UNITY + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; +#else + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + +#endif // !UNITY + } + + private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions ) + { + var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return context.GetSerializer( context ); + } + +#if UNITY + [TestFixtureSetUp] + public static void SetUpFixture() + { + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareType(); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + } +#endif // UNITY + + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + private void DoKnownCollectionTest( SerializationContext context ) + where T : new() + { + using ( var buffer = new MemoryStream() ) + { + CreateTarget( context ).Pack( buffer, new T() ); + } + } + + [Test] + public void TestUnpackTo() + { + var target = this.CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, new[] { 1, 2 } ); + buffer.Position = 0; + int[] result = new int[ 2 ]; + using ( var unpacker = Unpacker.Create( buffer, false ) ) + { + unpacker.Read(); + target.UnpackTo( unpacker, result ); + Assert.That( result, Is.EqualTo( new[] { 1, 2 } ) ); + } + } + } + + [Test] + public void TestInt32() + { + TestCore( 1, stream => Unpacking.UnpackInt32( stream ), null ); + } + + [Test] + public void TestInt64() + { + TestCore( Int32.MaxValue + 1L, stream => Unpacking.UnpackInt64( stream ), null ); + } + + [Test] + public void TestString() + { + TestCore( "abc", stream => Unpacking.UnpackString( stream ), null ); + } + + [Test] + public void TestDateTime() + { + TestCore( + DateTime.Now, + stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeOffset() + { + TestCore( + DateTimeOffset.Now, + stream => + { + var array = Unpacking.UnpackArray( stream ); + return new DateTimeOffset( DateTime.FromBinary( array[ 0 ].AsInt64() ), TimeSpan.FromMinutes( array[ 1 ].AsInt16() ) ); + }, + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeClassic() + { + TestCore( + DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetClassic() + { + TestCore( + DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.DateTime.ToUniversalTime(), y.DateTime.ToUniversalTime() ), + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeNullableChangeOnDemand() + { + TestCore( + ( DateTime? )DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetNullableChangeOnDemand() + { + TestCore( + ( DateTimeOffset? )DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.Value.DateTime.ToUniversalTime(), y.Value.DateTime.ToUniversalTime() ), + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + private static bool CompareDateTime( DateTime x, DateTime y ) + { + return x.Date == y.Date && x.Hour == y.Hour && x.Minute == y.Minute && x.Second == y.Second && x.Millisecond == y.Millisecond; + } + + private static bool CompareDateTime( DateTime? x, DateTime? y ) + { + return CompareDateTime( x.Value, y.Value ); + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + + [Test] + public void TestUri() + { + TestCore( new Uri( "http://www.example.com" ), stream => new Uri( Unpacking.UnpackString( stream ) ), null ); + } + + [Test] + public void TestComplexObject_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObject_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestCoreWithVerify( target, context ); + } + +#if FEATURE_TAP + [Test] + public async Task TestComplexObjectAsync_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public async Task TestComplexObjectAsync_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private async Task TestComplexObjectAsyncCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + await TestCoreWithVerifyAsync( target, context ); + } +#endif // FEATURE_TAP + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithoutAnyAttribute( SerializationContext context ) + { + var target = new ComplexTypeWithoutAnyAttribute() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithMissingMessagePackMemberAttributeMember() + { + this.TestTypeWithMissingMessagePackMemberAttributeMemberCore( GetSerializationContext() ); + } + + private void TestTypeWithMissingMessagePackMemberAttributeMemberCore( SerializationContext context ) + { + var target = new TypeWithMissingMessagePackMemberAttributeMember(); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithInvalidMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestTypeWithDuplicatedMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithDataContractCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContract() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithDataContractWithOrderCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContractWithOrder() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithNonSerializedCore( SerializationContext context ) + { + var target = new ComplexTypeWithNonSerialized() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestDataMemberAttributeOrderWithOneBase() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseAsync() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserializeAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithZeroBase_ProtoBufCompatible_Fail() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + Assert.Throws( + () => this.CreateTarget( context ) + ); + } + + [Test] + public void TestDataMemberAttributeNamedProperties() + { + var context = GetSerializationContext(); + if ( context.SerializationMethod == SerializationMethod.Array ) + { + // Nothing to test. + return; + } + + var value = new DataMemberAttributeNamedPropertyTestTarget() { Member = "A Member" }; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var asDictionary = Unpacking.UnpackDictionary( buffer ); + + Assert.That( asDictionary[ "Alias" ] == value.Member ); + + buffer.Position = 0; + + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.Member, Is.EqualTo( value.Member ) ); + } + } + + [Test] + public void TestEnum() + { + TestCore( DayOfWeek.Sunday, stream => ( DayOfWeek )Enum.Parse( typeof( DayOfWeek ), Unpacking.UnpackString( stream ) ), ( x, y ) => x == y ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestNameValueCollection() + { + var target = new NameValueCollection(); + target.Add( String.Empty, "Empty-1" ); + target.Add( String.Empty, "Empty-2" ); + target.Add( "1", "1-1" ); + target.Add( "1", "1-2" ); + target.Add( "1", "1-3" ); + target.Add( "null", null ); // This value will not be packed. + target.Add( "Empty", String.Empty ); + target.Add( "2", "2" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, target ); + stream.Position = 0; + NameValueCollection result = serializer.Unpack( stream ); + Assert.That( result.GetValues( String.Empty ), Is.EquivalentTo( new[] { "Empty-1", "Empty-2" } ) ); + Assert.That( result.GetValues( "1" ), Is.EquivalentTo( new[] { "1-1", "1-2", "1-3" } ) ); + Assert.That( result.GetValues( "null" ), Is.Null ); + Assert.That( result.GetValues( "Empty" ), Is.EquivalentTo( new string[] { String.Empty } ) ); + Assert.That( result.GetValues( "2" ), Is.EquivalentTo( new string[] { "2" } ) ); + // null only value is not packed. + Assert.That( result.Count, Is.EqualTo( target.Count - 1 ) ); + } + } + + [Test] + public void TestNameValueCollection_NullKey() + { + var target = new NameValueCollection(); + target.Add( null, "null" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + Assert.Throws( () => serializer.Pack( stream, target ) ); + } + } +#endif + + [Test] + public void TestByteArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1, 2, 3, 4 } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackBinary( stream ).ToArray(), Is.EqualTo( new byte[] { 1, 2, 3, 4 } ) ); + } + } + + [Test] + public void TestCharArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new char[] { 'a', 'b', 'c', 'd' } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( "abcd" ) ); + } + } + +#if !NETFX_35 + [Test] + public void TestTuple1() + { + TestTupleCore( new Tuple( 1 ) ); + } + + [Test] + public void TestTuple7() + { + TestTupleCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public void TestTuple8() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public void TestTuple14() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public void TestTuple15() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private void TestTupleCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, expected ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( expected ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestTuple1Async() + { + await TestTupleAsyncCore( new Tuple( 1 ) ); + } + + [Test] + public async Task TestTuple7Async() + { + await TestTupleAsyncCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public async Task TestTuple8Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public async Task TestTuple14Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public async Task TestTuple15Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private async Task TestTupleAsyncCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, expected ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( expected ) ); + } + } +#endif // FEATURE_TAP +#endif // !NETFX_35 + + [Test] + public void TestEmptyBytes() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyBytes_Classic() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = this.CreateTarget( context ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyString() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, String.Empty ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( String.Empty ) ); + } + } + + [Test] + public void TestEmptyIntArray() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new int[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new int[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyKeyValuePairArray() + { + var serializer = this.CreateTarget[]>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new KeyValuePair[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new KeyValuePair[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyMap() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new Dictionary() ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new Dictionary() ) ); + } + } + + [Test] + public void TestNullable() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + serializer.Pack( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( null ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestNullableAsync() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + await serializer.PackAsync( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( null ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestValueType_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestValueTypeAsync_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + await serializer.PackAsync( stream, value ); + stream.Position = 0; + var result = await serializer.UnpackAsync( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } +#endif // FEATURE_TAP + + // Issue81 + [Test] + public void TestMultiDimensionalArray() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } + +#if FEATURE_TAP + // Issue81 + [Test] + public async Task TestMultiDimensionalArrayAsync() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, array ); + stream.Position = 0; + + var result = await serializer.UnpackAsync( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestMultiDimensionalArrayComprex() + { + var array = new int [ 2, 3, 4 ]; + array[ 0, 0, 0 ] = 0; + array[ 0, 0, 1 ] = 1; + array[ 0, 0, 2 ] = 2; + array[ 0, 0, 3 ] = 3; + array[ 0, 1, 0 ] = 10; + array[ 0, 1, 1 ] = 11; + array[ 0, 1, 2 ] = 12; + array[ 0, 1, 3 ] = 13; + array[ 0, 2, 0 ] = 20; + array[ 0, 2, 1 ] = 21; + array[ 0, 2, 2 ] = 22; + array[ 0, 2, 3 ] = 23; + array[ 1, 0, 0 ] = 100; + array[ 1, 0, 1 ] = 101; + array[ 1, 0, 2 ] = 102; + array[ 1, 0, 3 ] = 103; + array[ 1, 1, 0 ] = 110; + array[ 1, 1, 1 ] = 111; + array[ 1, 1, 2 ] = 112; + array[ 1, 1, 3 ] = 113; + array[ 1, 2, 0 ] = 120; + array[ 1, 2, 1 ] = 121; + array[ 1, 2, 2 ] = 122; + array[ 1, 2, 3 ] = 123; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 3 ) ); + Assert.That( result.Length, Is.EqualTo( 24 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 3 ) ); + Assert.That( result.GetLength( 2 ), Is.EqualTo( 4 ) ); + Assert.That( result[ 0, 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 0, 0, 2 ], Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0, 3 ], Is.EqualTo( 3 ) ); + Assert.That( result[ 0, 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 0, 1, 1 ], Is.EqualTo( 11 ) ); + Assert.That( result[ 0, 1, 2 ], Is.EqualTo( 12 ) ); + Assert.That( result[ 0, 1, 3 ], Is.EqualTo( 13 ) ); + Assert.That( result[ 0, 2, 0 ], Is.EqualTo( 20 ) ); + Assert.That( result[ 0, 2, 1 ], Is.EqualTo( 21 ) ); + Assert.That( result[ 0, 2, 2 ], Is.EqualTo( 22 ) ); + Assert.That( result[ 0, 2, 3 ], Is.EqualTo( 23 ) ); + Assert.That( result[ 1, 0, 0 ], Is.EqualTo( 100 ) ); + Assert.That( result[ 1, 0, 1 ], Is.EqualTo( 101 ) ); + Assert.That( result[ 1, 0, 2 ], Is.EqualTo( 102 ) ); + Assert.That( result[ 1, 0, 3 ], Is.EqualTo( 103 ) ); + Assert.That( result[ 1, 1, 0 ], Is.EqualTo( 110 ) ); + Assert.That( result[ 1, 1, 1 ], Is.EqualTo( 111 ) ); + Assert.That( result[ 1, 1, 2 ], Is.EqualTo( 112 ) ); + Assert.That( result[ 1, 1, 3 ], Is.EqualTo( 113 ) ); + Assert.That( result[ 1, 2, 0 ], Is.EqualTo( 120 ) ); + Assert.That( result[ 1, 2, 1 ], Is.EqualTo( 121 ) ); + Assert.That( result[ 1, 2, 2 ], Is.EqualTo( 122 ) ); + Assert.That( result[ 1, 2, 3 ], Is.EqualTo( 123 ) ); + } + } + + [Test] +#if UNITY_WORKAROUND + [Ignore( "Unity's Array.SetValue is buggy for non-SZArray" )] +#endif // UNITY_WORKAROUND + public void TestNonZeroBoundArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2 }, new [] { 1 } ); + array.SetValue( 1, 1 ); + array.SetValue( 2, 2 ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); +#if !SILVERLIGHT + Assert.That( result, Is.TypeOf( array.GetType() ) ); +#else + // Silverlight does not support lower bound settings, so sz array will return. + Assert.That( result, Is.TypeOf() ); +#endif // !SILVERLIGHT + Assert.That( result.Rank, Is.EqualTo( 1 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 2 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 3 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetValue( 2 ), Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestNonZeroBoundMultidimensionalArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2, 2 }, new [] { 1, 1 } ); + array.SetValue( 11, new [] { 1, 1 } ); + array.SetValue( 12, new [] { 1, 2 } ); + array.SetValue( 21, new [] { 2, 1 } ); + array.SetValue( 22, new [] { 2, 2 } ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf( array.GetType() ) ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 9 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1, 1 ), Is.EqualTo( 11 ) ); + Assert.That( result.GetValue( 1, 2 ), Is.EqualTo( 12 ) ); + Assert.That( result.GetValue( 2, 1 ), Is.EqualTo( 21 ) ); + Assert.That( result.GetValue( 2, 2 ), Is.EqualTo( 22 ) ); + } + } + + + [Test] + public void TestHasInitOnlyFieldWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackArrayHeader( 2 ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherNameConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherNameConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( 0 ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherTypeConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherTypeConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( "0" ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAttribute_Preferred() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithConstructorAttribute( 1, false ); + Assert.That( value.IsAttributePreferred, Is.False ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1 ) ); + Assert.That( result.IsAttributePreferred, Is.True ); + } + } + + [Test] + public void TestConstrutorDeserializationWithMultipleAttributes_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + + [Test] + public void TestOptionalConstructorByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( byte )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorSByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( sbyte )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( short )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ushort )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( uint )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2L ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ulong )2L ) ); + } + } + + [Test] + public void TestOptionalConstructorSingle_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2f ) ); + } + } + + [Test] + public void TestOptionalConstructorDouble_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2 ) ); + } + } + + [Test] + public void TestOptionalConstructorDecimal_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2m ) ); + } + } + + [Test] + public void TestOptionalConstructorBoolean_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( true ) ); + } + } + + [Test] + public void TestOptionalConstructorChar_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 'A' ) ); + } + } + + [Test] + public void TestOptionalConstructorString_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x90 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestCollection_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new Collection() { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIListValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new ListValueType( 3 ) { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIDictionaryValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new DictionaryValueType( 3 ) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EquivalentTo( Enumerable.Range( 1, 3 ).Select( i => new KeyValuePair( i, i ) ).ToArray() ) ); + } + } + + [Test] + public void TestPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.Unpack( stream ), "Round-trip should not be succeeded." ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + + [Test] + public void TestUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(), "Round-trip should not be succeeded." ); + } + } + + [Test] + public void TestAsyncUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustAsyncUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new PackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( PackableUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new AsyncPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( AsyncPackableUnpackable.Dummy ) ); + } + } + + [Test] + public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new FullPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestBinary_ClassicContext() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.MinimumFixedRaw + 1, 1 } ) ); + } + } + + [Test] + public void TestBinary_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) ); + } + } + [Test] + public void TestExt_ClassicContext() + { + var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_DefaultContext() + { + var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None; + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_Default_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_WithoutRegistration_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Unregister( typeof( IList<> ) ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistration_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList<> ), typeof( Collection<> ) ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistrationForSpecific_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( Collection ) ); + var serializer1 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer1.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer1.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + + // check other types are not affected + var serializer2 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractStringCollection() { Collection = new[] { "1", "2" } }; + serializer2.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer2.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( "1" ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( "2" ) ); + } + } + + [Test] + public void TestAbstractTypes_NotACollection_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + +#if !NETFX_35 && !UNITY + [Test] + public void TestReadOnlyCollectionInterfaceDefault() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + null + ); + } + + [Test] + public void TestReadOnlyCollectionInterfaceExplicit() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyCollection ), typeof( AppendableReadOnlyCollection ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyList ), typeof( AppendableReadOnlyList ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyDictionary ), typeof( AppendableReadOnlyDictionary ) ) + ); + } + + private static void TestCollectionInterfaceCore( byte[] data, Action assertion, Action registration ) + { + using ( var buffer = new MemoryStream(data) ) + { + var serializer = MessagePackSerializer.Get( NewSerializationContext( PackerCompatibilityOptions.None ) ); + var result = serializer.Unpack( buffer ); + assertion( result ); + } + } +#endif // !NETFX_35 && !UNITY + + private void TestCore( T value, Func unpacking, Func comparer ) + { + TestCore( value, unpacking, comparer, null ); + } + + private void TestCore( T value, Func unpacking, Func comparer, Action contextAdjuster ) + { + var safeComparer = comparer ?? EqualityComparer.Default.Equals; + var context = GetSerializationContext(); + if ( contextAdjuster != null ) + { + contextAdjuster( context ); + } + + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T intermediate = unpacking( buffer ); + Assert.That( safeComparer( intermediate, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, intermediate ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + Assert.That( safeComparer( unpacked, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, unpacked ); + } + } + + private void TestCoreWithVerify( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#if FEATURE_TAP + + private async Task TestCoreWithVerifyAsync( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ); + buffer.Position = 0; + T unpacked = await target.UnpackAsync( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_Plain() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, hasEnumerable ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestIssue25_PlainAsync() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, hasEnumerable ); + buffer.Position = 0; + var result = await target.UnpackAsync( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_SelfComposite() + { + SerializationContext serializationContext = + SerializationContext.Default; + try + { + + serializationContext.Serializers.Register( new PersonSerializer() ); + serializationContext.Serializers.Register( new ChildrenSerializer() ); + + object[] array = new object[] { new Person { Name = "Joe" }, 3 }; + + MessagePackSerializer context = + serializationContext.GetSerializer(); + + byte[] packed = context.PackSingleObject( array ); + object[] unpacked = context.UnpackSingleObject( packed ); + + Assert.That( unpacked.Length, Is.EqualTo( 2 ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Name" ].AsString(), Is.EqualTo( "Joe" ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Children" ].IsNil ); + Assert.That( ( MessagePackObject )unpacked[ 1 ], Is.EqualTo( new MessagePackObject( 3 ) ) ); + } + finally + { + SerializationContext.Default = new SerializationContext(); + } + } + +#region -- ReadOnly / Private Members -- + + // ReSharper disable UnusedMember.Local + // member names + private const string PublicProperty = "PublicProperty"; + private const string PublicReadOnlyProperty = "PublicReadOnlyProperty"; + private const string NonPublicProperty = "NonPublicProperty"; + private const string PublicPropertyPlain = "PublicPropertyPlain"; + private const string PublicReadOnlyPropertyPlain = "PublicReadOnlyPropertyPlain"; + private const string NonPublicPropertyPlain = "NonPublicPropertyPlain"; + private const string CollectionReadOnlyProperty = "CollectionReadOnlyProperty"; + private const string NonPublicCollectionProperty = "NonPublicCollectionProperty"; + private const string NonPublicCollectionField = "NonPublicCollectionField"; + private const string NonPublicCollectionReadOnlyProperty = "NonPublicCollectionReadOnlyProperty"; + private const string NonPublicCollectionReadOnlyField = "NonPublicCollectionReadOnlyField"; + private const string NonPublicDictionaryProperty = "NonPublicDictionaryProperty"; + private const string NonPublicDictionaryField = "NonPublicDictionaryField"; + private const string NonPublicDictionaryReadOnlyProperty = "NonPublicDictionaryReadOnlyProperty"; + private const string NonPublicDictionaryReadOnlyField = "NonPublicDictionaryReadOnlyField"; + private const string NonPublicIDictionaryProperty = "NonPublicIDictionaryProperty"; + private const string NonPublicIDictionaryField = "NonPublicIDictionaryField"; + private const string NonPublicIDictionaryReadOnlyProperty = "NonPublicIDictionaryReadOnlyProperty"; + private const string NonPublicIDictionaryReadOnlyField = "NonPublicIDictionaryReadOnlyField"; + private const string PublicField = "PublicField"; + private const string PublicReadOnlyField = "PublicReadOnlyField"; + private const string NonPublicField = "NonPublicField"; + private const string PublicFieldPlain = "PublicFieldPlain"; + private const string PublicReadOnlyFieldPlain = "PublicReadOnlyFieldPlain"; + private const string NonPublicFieldPlain = "NonPublicFieldPlain"; +#if !NETFX_CORE && !SILVERLIGHT + private const string NonSerializedPublicField = "NonSerializedPublicField"; + private const string NonSerializedPublicReadOnlyField = "NonSerializedPublicReadOnlyField"; + private const string NonSerializedNonPublicField = "NonSerializedNonPublicField"; + private const string NonSerializedPublicFieldPlain = "NonSerializedPublicFieldPlain"; + private const string NonSerializedPublicReadOnlyFieldPlain = "NonSerializedPublicReadOnlyFieldPlain"; + private const string NonSerializedNonPublicFieldPlain = "NonSerializedNonPublicFieldPlain"; +#endif // !NETFX_CORE && !SILVERLIGHT + // ReSharper restore UnusedMember.Local + + [Test] + public void TestNonPublicWritableMember_PlainOldCliClass() + { + var target = new PlainClass(); + target.InitializeCollectionMembers(); + TestNonPublicWritableMemberCore( target, PublicProperty, PublicField, CollectionReadOnlyProperty ); + } + + [Test] + public void TestNonPublicWritableMember_MessagePackMember() + { + var target = new AnnotatedClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + [Test] + public void TestNonPublicWritableMember_DataContract() + { + // includes issue33 + var target = new DataMamberClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + private void TestNonPublicWritableMemberCore( T original, params string[] expectedMemberNames ) + { + var serializer = CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, original ); + buffer.Position = 0; + var actual = serializer.Unpack( buffer ); + + foreach ( var memberName in expectedMemberNames ) + { + Func getter = null; +#if !NETFX_CORE + var property = typeof( T ).GetProperty( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var property = typeof( T ).GetRuntimeProperties().SingleOrDefault( p => p.Name == memberName ); +#endif + if ( property != null ) + { +#if !UNITY + getter = obj => property.GetValue( obj, null ); +#else + getter = obj => property.GetGetMethod( true ).InvokePreservingExceptionType( obj ); +#endif // !UNITY + } + else + { +#if !NETFX_CORE + var field = typeof( T ).GetField( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var field = typeof( T ).GetRuntimeFields().SingleOrDefault( f => f.Name == memberName ); +#endif + if ( field == null ) + { + Assert.Fail( memberName + " is not found." ); + } + + getter = obj => field.GetValue( obj ); + } + + // Naive, but OK + if ( memberName.Contains( "IDictionary" ) ) + { + Func> toDictionary = + hashTable => + ( ( System.Collections.IEnumerable )hashTable ) + .OfType() + .ToDictionary( + de => de.Key.ToString(), + de => + ( de.Value is MessagePackObject ) + ? ( int )( MessagePackObject )de.Value + : ( int )de.Value + ); + + Assert.That( toDictionary( getter( actual ) ), Is.EqualTo( toDictionary( getter( original ) ) ), typeof(T) + "." + memberName ); + } + else + { + Assert.That( getter( actual ), Is.EqualTo( getter( original ) ), typeof(T) + "." + memberName ); + } + } + } + } + +#endregion -- ReadOnly / Private Members -- + +#region -- IPackabke/IUnpackable -- + + // Issue 150 + [Test] + public void TestExplicitlyImplementedPackableUnpackable() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new PackableUnpackableImplementedExplictly(); + obj.Data = "ABC"; + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + Assert.That( actual.Data, Is.EqualTo( PackableUnpackableImplementedExplictly.UnpackingPrefix + PackableUnpackableImplementedExplictly.PackingPrefix + obj.Data ) ); + } + } + + // Issue153 + + + [Test] + public void TestEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP + +#endregion -- IPackabke/IUnpackable -- + +#region -- Exclusion -- + + private void TestIgnoreCore( Action setter, Action assertion ) + where T : new() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new T(); + setter( obj ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + assertion( obj, actual ); + } + } + + private void TestIgnoreCore() + where TException : Exception + { + Assert.Throws( () => GetSerializationContext().GetSerializer() ); + } + + [Test] + public void TestIgnore_Normal() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotIgnored = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotIgnored, Is.EqualTo( expected.NotIgnored ) ); + } + ); + } + + [Test] + public void TestIgnore_ExcludedOnly() + { + TestIgnoreCore(); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionMixed() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotMarked = "ABC"; + target.Marked = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotMarked, Is.Null ); + Assert.That( actual.Marked, Is.EqualTo( expected.Marked ) ); + } + ); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionSimulatously() + { + TestIgnoreCore(); + } + + + public class OnlyExcluded + { + [MessagePackIgnore] + public string Ignored { get; set; } + } + + public class Excluded + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotIgnored { get; set; } + } + + public class ExclusionAndInclusionMixed + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotMarked { get; set; } + + [MessagePackMember( 0 )] + public string Marked { get; set; } + } + + public class ExclusionAndInclusionSimulatously + { + [MessagePackMember( 0 )] + public string Marked { get; set; } + + [MessagePackIgnore] + [MessagePackMember( 1 )] + public string DoubleMarked { get; set; } + } + +#endregion -- Exclusion -- + +#if !UNITY + // Mono 2.7.3 AOT fails when these classes are used... + // Issue 119 +#region -- Generic -- + + [Test] + public void TestGenericDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericValueClass + { + GenericField = 1, + GenericProperty = 2 + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericReferenceClass + { + GenericField = "1", + GenericProperty = "2" + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordValueClass( 1, 2 ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordReferenceClass( "1", "2" ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + +#endregion -- Generic -- + +#region -- Nullable -- + // Issue #121 + + [Test] + public void TestNullable_Primitive_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DateTime.UtcNow.Millisecond; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Primitive_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( int? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = TimeSpan.FromSeconds( DateTime.UtcNow.Millisecond ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( TimeSpan? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DayOfWeek.Monday; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( DayOfWeek? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } +#endregion -- Nullable -- + +#endif // !UNITY + + + // Related to issue #62 -- internal types handling is not consistent at first. + + [Test] + public void TestNonPublicType_Plain_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_MessagePackMember_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_DataContract_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + // Issue 170 + [Test] + public void TestStaticMembersDoNotCausePrepareError() + { + MessagePackSerializer.Get().PackSingleObject( new ClassHasStaticField() ); + } + +#pragma warning disable 649 + internal class NonPublic + { + public int Value; + } + + internal class NonPublicWithMessagePackMember + { + [MessagePackMember( 0 )] + public int Value; + } + + [DataContract] + internal class NonPublicWithDataContract + { + [DataMember] + public int Value; + } +#pragma warning restore 649 + + // issue #63 + [Test] + public void TestManyMembers() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + var target = new WithManyMembers(); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + +#pragma warning disable 659 + public class WithManyMembers + { + private readonly int[] _backingField = Enumerable.Range( 0, SByte.MaxValue + 2 ).ToArray(); + + public int Member0 + { + get { return this._backingField[ 0 ]; } + set { this._backingField[ 0 ] = value; } + } + public int Member1 + { + get { return this._backingField[ 1 ]; } + set { this._backingField[ 1 ] = value; } + } + public int Member2 + { + get { return this._backingField[ 2 ]; } + set { this._backingField[ 2 ] = value; } + } + public int Member3 + { + get { return this._backingField[ 3 ]; } + set { this._backingField[ 3 ] = value; } + } + public int Member4 + { + get { return this._backingField[ 4 ]; } + set { this._backingField[ 4 ] = value; } + } + public int Member5 + { + get { return this._backingField[ 5 ]; } + set { this._backingField[ 5 ] = value; } + } + public int Member6 + { + get { return this._backingField[ 6 ]; } + set { this._backingField[ 6 ] = value; } + } + public int Member7 + { + get { return this._backingField[ 7 ]; } + set { this._backingField[ 7 ] = value; } + } + public int Member8 + { + get { return this._backingField[ 8 ]; } + set { this._backingField[ 8 ] = value; } + } + public int Member9 + { + get { return this._backingField[ 9 ]; } + set { this._backingField[ 9 ] = value; } + } + public int Member10 + { + get { return this._backingField[ 10 ]; } + set { this._backingField[ 10 ] = value; } + } + public int Member11 + { + get { return this._backingField[ 11 ]; } + set { this._backingField[ 11 ] = value; } + } + public int Member12 + { + get { return this._backingField[ 12 ]; } + set { this._backingField[ 12 ] = value; } + } + public int Member13 + { + get { return this._backingField[ 13 ]; } + set { this._backingField[ 13 ] = value; } + } + public int Member14 + { + get { return this._backingField[ 14 ]; } + set { this._backingField[ 14 ] = value; } + } + public int Member15 + { + get { return this._backingField[ 15 ]; } + set { this._backingField[ 15 ] = value; } + } + public int Member16 + { + get { return this._backingField[ 16 ]; } + set { this._backingField[ 16 ] = value; } + } + public int Member17 + { + get { return this._backingField[ 17 ]; } + set { this._backingField[ 17 ] = value; } + } + public int Member18 + { + get { return this._backingField[ 18 ]; } + set { this._backingField[ 18 ] = value; } + } + public int Member19 + { + get { return this._backingField[ 19 ]; } + set { this._backingField[ 19 ] = value; } + } + public int Member20 + { + get { return this._backingField[ 20 ]; } + set { this._backingField[ 20 ] = value; } + } + public int Member21 + { + get { return this._backingField[ 21 ]; } + set { this._backingField[ 21 ] = value; } + } + public int Member22 + { + get { return this._backingField[ 22 ]; } + set { this._backingField[ 22 ] = value; } + } + public int Member23 + { + get { return this._backingField[ 23 ]; } + set { this._backingField[ 23 ] = value; } + } + public int Member24 + { + get { return this._backingField[ 24 ]; } + set { this._backingField[ 24 ] = value; } + } + public int Member25 + { + get { return this._backingField[ 25 ]; } + set { this._backingField[ 25 ] = value; } + } + public int Member26 + { + get { return this._backingField[ 26 ]; } + set { this._backingField[ 26 ] = value; } + } + public int Member27 + { + get { return this._backingField[ 27 ]; } + set { this._backingField[ 27 ] = value; } + } + public int Member28 + { + get { return this._backingField[ 28 ]; } + set { this._backingField[ 28 ] = value; } + } + public int Member29 + { + get { return this._backingField[ 29 ]; } + set { this._backingField[ 29 ] = value; } + } + public int Member30 + { + get { return this._backingField[ 30 ]; } + set { this._backingField[ 30 ] = value; } + } + public int Member31 + { + get { return this._backingField[ 31 ]; } + set { this._backingField[ 31 ] = value; } + } + public int Member32 + { + get { return this._backingField[ 32 ]; } + set { this._backingField[ 32 ] = value; } + } + public int Member33 + { + get { return this._backingField[ 33 ]; } + set { this._backingField[ 33 ] = value; } + } + public int Member34 + { + get { return this._backingField[ 34 ]; } + set { this._backingField[ 34 ] = value; } + } + public int Member35 + { + get { return this._backingField[ 35 ]; } + set { this._backingField[ 35 ] = value; } + } + public int Member36 + { + get { return this._backingField[ 36 ]; } + set { this._backingField[ 36 ] = value; } + } + public int Member37 + { + get { return this._backingField[ 37 ]; } + set { this._backingField[ 37 ] = value; } + } + public int Member38 + { + get { return this._backingField[ 38 ]; } + set { this._backingField[ 38 ] = value; } + } + public int Member39 + { + get { return this._backingField[ 39 ]; } + set { this._backingField[ 39 ] = value; } + } + public int Member40 + { + get { return this._backingField[ 40 ]; } + set { this._backingField[ 40 ] = value; } + } + public int Member41 + { + get { return this._backingField[ 41 ]; } + set { this._backingField[ 41 ] = value; } + } + public int Member42 + { + get { return this._backingField[ 42 ]; } + set { this._backingField[ 42 ] = value; } + } + public int Member43 + { + get { return this._backingField[ 43 ]; } + set { this._backingField[ 43 ] = value; } + } + public int Member44 + { + get { return this._backingField[ 44 ]; } + set { this._backingField[ 44 ] = value; } + } + public int Member45 + { + get { return this._backingField[ 45 ]; } + set { this._backingField[ 45 ] = value; } + } + public int Member46 + { + get { return this._backingField[ 46 ]; } + set { this._backingField[ 46 ] = value; } + } + public int Member47 + { + get { return this._backingField[ 47 ]; } + set { this._backingField[ 47 ] = value; } + } + public int Member48 + { + get { return this._backingField[ 48 ]; } + set { this._backingField[ 48 ] = value; } + } + public int Member49 + { + get { return this._backingField[ 49 ]; } + set { this._backingField[ 49 ] = value; } + } + public int Member50 + { + get { return this._backingField[ 50 ]; } + set { this._backingField[ 50 ] = value; } + } + public int Member51 + { + get { return this._backingField[ 51 ]; } + set { this._backingField[ 51 ] = value; } + } + public int Member52 + { + get { return this._backingField[ 52 ]; } + set { this._backingField[ 52 ] = value; } + } + public int Member53 + { + get { return this._backingField[ 53 ]; } + set { this._backingField[ 53 ] = value; } + } + public int Member54 + { + get { return this._backingField[ 54 ]; } + set { this._backingField[ 54 ] = value; } + } + public int Member55 + { + get { return this._backingField[ 55 ]; } + set { this._backingField[ 55 ] = value; } + } + public int Member56 + { + get { return this._backingField[ 56 ]; } + set { this._backingField[ 56 ] = value; } + } + public int Member57 + { + get { return this._backingField[ 57 ]; } + set { this._backingField[ 57 ] = value; } + } + public int Member58 + { + get { return this._backingField[ 58 ]; } + set { this._backingField[ 58 ] = value; } + } + public int Member59 + { + get { return this._backingField[ 59 ]; } + set { this._backingField[ 59 ] = value; } + } + public int Member60 + { + get { return this._backingField[ 60 ]; } + set { this._backingField[ 60 ] = value; } + } + public int Member61 + { + get { return this._backingField[ 61 ]; } + set { this._backingField[ 61 ] = value; } + } + public int Member62 + { + get { return this._backingField[ 62 ]; } + set { this._backingField[ 62 ] = value; } + } + public int Member63 + { + get { return this._backingField[ 63 ]; } + set { this._backingField[ 63 ] = value; } + } + public int Member64 + { + get { return this._backingField[ 64 ]; } + set { this._backingField[ 64 ] = value; } + } + public int Member65 + { + get { return this._backingField[ 65 ]; } + set { this._backingField[ 65 ] = value; } + } + public int Member66 + { + get { return this._backingField[ 66 ]; } + set { this._backingField[ 66 ] = value; } + } + public int Member67 + { + get { return this._backingField[ 67 ]; } + set { this._backingField[ 67 ] = value; } + } + public int Member68 + { + get { return this._backingField[ 68 ]; } + set { this._backingField[ 68 ] = value; } + } + public int Member69 + { + get { return this._backingField[ 69 ]; } + set { this._backingField[ 69 ] = value; } + } + public int Member70 + { + get { return this._backingField[ 70 ]; } + set { this._backingField[ 70 ] = value; } + } + public int Member71 + { + get { return this._backingField[ 71 ]; } + set { this._backingField[ 71 ] = value; } + } + public int Member72 + { + get { return this._backingField[ 72 ]; } + set { this._backingField[ 72 ] = value; } + } + public int Member73 + { + get { return this._backingField[ 73 ]; } + set { this._backingField[ 73 ] = value; } + } + public int Member74 + { + get { return this._backingField[ 74 ]; } + set { this._backingField[ 74 ] = value; } + } + public int Member75 + { + get { return this._backingField[ 75 ]; } + set { this._backingField[ 75 ] = value; } + } + public int Member76 + { + get { return this._backingField[ 76 ]; } + set { this._backingField[ 76 ] = value; } + } + public int Member77 + { + get { return this._backingField[ 77 ]; } + set { this._backingField[ 77 ] = value; } + } + public int Member78 + { + get { return this._backingField[ 78 ]; } + set { this._backingField[ 78 ] = value; } + } + public int Member79 + { + get { return this._backingField[ 79 ]; } + set { this._backingField[ 79 ] = value; } + } + public int Member80 + { + get { return this._backingField[ 80 ]; } + set { this._backingField[ 80 ] = value; } + } + public int Member81 + { + get { return this._backingField[ 81 ]; } + set { this._backingField[ 81 ] = value; } + } + public int Member82 + { + get { return this._backingField[ 82 ]; } + set { this._backingField[ 82 ] = value; } + } + public int Member83 + { + get { return this._backingField[ 83 ]; } + set { this._backingField[ 83 ] = value; } + } + public int Member84 + { + get { return this._backingField[ 84 ]; } + set { this._backingField[ 84 ] = value; } + } + public int Member85 + { + get { return this._backingField[ 85 ]; } + set { this._backingField[ 85 ] = value; } + } + public int Member86 + { + get { return this._backingField[ 86 ]; } + set { this._backingField[ 86 ] = value; } + } + public int Member87 + { + get { return this._backingField[ 87 ]; } + set { this._backingField[ 87 ] = value; } + } + public int Member88 + { + get { return this._backingField[ 88 ]; } + set { this._backingField[ 88 ] = value; } + } + public int Member89 + { + get { return this._backingField[ 89 ]; } + set { this._backingField[ 89 ] = value; } + } + public int Member90 + { + get { return this._backingField[ 90 ]; } + set { this._backingField[ 90 ] = value; } + } + public int Member91 + { + get { return this._backingField[ 91 ]; } + set { this._backingField[ 91 ] = value; } + } + public int Member92 + { + get { return this._backingField[ 92 ]; } + set { this._backingField[ 92 ] = value; } + } + public int Member93 + { + get { return this._backingField[ 93 ]; } + set { this._backingField[ 93 ] = value; } + } + public int Member94 + { + get { return this._backingField[ 94 ]; } + set { this._backingField[ 94 ] = value; } + } + public int Member95 + { + get { return this._backingField[ 95 ]; } + set { this._backingField[ 95 ] = value; } + } + public int Member96 + { + get { return this._backingField[ 96 ]; } + set { this._backingField[ 96 ] = value; } + } + public int Member97 + { + get { return this._backingField[ 97 ]; } + set { this._backingField[ 97 ] = value; } + } + public int Member98 + { + get { return this._backingField[ 98 ]; } + set { this._backingField[ 98 ] = value; } + } + public int Member99 + { + get { return this._backingField[ 99 ]; } + set { this._backingField[ 99 ] = value; } + } + public int Member100 + { + get { return this._backingField[ 100 ]; } + set { this._backingField[ 100 ] = value; } + } + public int Member101 + { + get { return this._backingField[ 101 ]; } + set { this._backingField[ 101 ] = value; } + } + public int Member102 + { + get { return this._backingField[ 102 ]; } + set { this._backingField[ 102 ] = value; } + } + public int Member103 + { + get { return this._backingField[ 103 ]; } + set { this._backingField[ 103 ] = value; } + } + public int Member104 + { + get { return this._backingField[ 104 ]; } + set { this._backingField[ 104 ] = value; } + } + public int Member105 + { + get { return this._backingField[ 105 ]; } + set { this._backingField[ 105 ] = value; } + } + public int Member106 + { + get { return this._backingField[ 106 ]; } + set { this._backingField[ 106 ] = value; } + } + public int Member107 + { + get { return this._backingField[ 107 ]; } + set { this._backingField[ 107 ] = value; } + } + public int Member108 + { + get { return this._backingField[ 108 ]; } + set { this._backingField[ 108 ] = value; } + } + public int Member109 + { + get { return this._backingField[ 109 ]; } + set { this._backingField[ 109 ] = value; } + } + public int Member110 + { + get { return this._backingField[ 110 ]; } + set { this._backingField[ 110 ] = value; } + } + public int Member111 + { + get { return this._backingField[ 111 ]; } + set { this._backingField[ 111 ] = value; } + } + public int Member112 + { + get { return this._backingField[ 112 ]; } + set { this._backingField[ 112 ] = value; } + } + public int Member113 + { + get { return this._backingField[ 113 ]; } + set { this._backingField[ 113 ] = value; } + } + public int Member114 + { + get { return this._backingField[ 114 ]; } + set { this._backingField[ 114 ] = value; } + } + public int Member115 + { + get { return this._backingField[ 115 ]; } + set { this._backingField[ 115 ] = value; } + } + public int Member116 + { + get { return this._backingField[ 116 ]; } + set { this._backingField[ 116 ] = value; } + } + public int Member117 + { + get { return this._backingField[ 117 ]; } + set { this._backingField[ 117 ] = value; } + } + public int Member118 + { + get { return this._backingField[ 118 ]; } + set { this._backingField[ 118 ] = value; } + } + public int Member119 + { + get { return this._backingField[ 119 ]; } + set { this._backingField[ 119 ] = value; } + } + public int Member120 + { + get { return this._backingField[ 120 ]; } + set { this._backingField[ 120 ] = value; } + } + public int Member121 + { + get { return this._backingField[ 121 ]; } + set { this._backingField[ 121 ] = value; } + } + public int Member122 + { + get { return this._backingField[ 122 ]; } + set { this._backingField[ 122 ] = value; } + } + public int Member123 + { + get { return this._backingField[ 123 ]; } + set { this._backingField[ 123 ] = value; } + } + public int Member124 + { + get { return this._backingField[ 124 ]; } + set { this._backingField[ 124 ] = value; } + } + public int Member125 + { + get { return this._backingField[ 125 ]; } + set { this._backingField[ 125 ] = value; } + } + public int Member126 + { + get { return this._backingField[ 126 ]; } + set { this._backingField[ 126 ] = value; } + } + public int Member127 + { + get { return this._backingField[ 127 ]; } + set { this._backingField[ 127 ] = value; } + } + public int Member128 + { + get { return this._backingField[ 128 ]; } + set { this._backingField[ 128 ] = value; } + } + + public override bool Equals( object obj ) + { + var other = obj as WithManyMembers; + if ( other == null ) + { + return false; + } + + return this._backingField == other._backingField || this._backingField.SequenceEqual( other._backingField ); + } + } +#pragma warning restore 659 + +#region issue #169 + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new GenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new NonGenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + +#endregion issue #169 + + #region -- Asymmetric -- + [Test] + public void TestAsymmetric_PackOnly_NoSettableNoConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableNoConstructorsForAsymmetricTest().Initialize( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoSettableMultipleConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableMultipleConstructorsForAsymmetricTest( "A", 0 ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoDefaultConstructor_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoDefaultConstructorForAsymmetricTest( 'A' ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableDictionaryForAsymmetricTest( new KeyValuePair( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericDictionaryForAsymmetricTest( new DictionaryEntry( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + + [Test] + public void TestAsymmetric_PackOnly_UnsettableArrayMemberObject_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnsettableArrayMemberObjectForAsymmetricTest(), + SerializerCapabilities.PackTo, + new byte[] { 0x92, 0x91, 0xA1, ( byte )'A', 0x91, 0xA1, ( byte )'A' } + ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized ) + { + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, true ); + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, false ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized, bool avoidsGenericSerializer ) + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowAsymmetricSerializer = true; + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + + var serializer = this.CreateTarget( context ); + Assert.That( serializer.Capabilities, Is.EqualTo( expectedCapabilities ) ); + + var obj = factory(); + using ( var buffer = new MemoryStream() ) + { + if ( ( expectedCapabilities & SerializerCapabilities.PackTo ) != 0 ) + { + serializer.Pack( buffer, obj ); + Assert.That( buffer.ToArray(), Is.EqualTo( serialized ), "{0} != {1}", BitConverter.ToString( buffer.ToArray() ), BitConverter.ToString( serialized ) ); + } + else if ( ( expectedCapabilities & SerializerCapabilities.UnpackFrom ) != 0 ) + { + buffer.Write( serialized, 0, serialized.Length ); + buffer.Position = 0; + var unpacked = serializer.Unpack( buffer ); + Assert.That( obj, Is.EqualTo( unpacked ) ); + } + } + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Asymmetric -- + + #region -- Object Packing/Unpacking -- + + [Test] + public void TestToFromMessagePackObject_Complex() + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestToFromMessagePackObjectCore( + target, + mpo => + { + Assert.That( mpo.IsArray ); + var asList = mpo.AsList(); + Assert.That( asList.Count, Is.EqualTo( 5 ) ); + + Assert.That( asList[ 0 ].IsTypeOf().Value ); + Assert.That( asList[ 0 ].AsString(), Is.EqualTo( target.Source.ToString() ) ); + + Assert.That( asList[ 1 ].IsTypeOf().Value ); + Assert.That( asList[ 1 ].AsBinary(), Is.EqualTo( target.Data ) ); + + Assert.That( asList[ 2 ].IsTypeOf().Value ); + Assert.That( asList[ 2 ].AsInt64(), Is.EqualTo( target.TimeStamp.ToBinary() ) ); + + Assert.That( asList[ 3 ].IsDictionary ); + Assert.That( asList[ 3 ].AsDictionary().Single().Key.AsInt64(), Is.EqualTo( target.History.Single().Key.ToBinary() ) ); + Assert.That( asList[ 3 ].AsDictionary().Single().Value.AsString(), Is.EqualTo( target.History.Single().Value ) ); + + Assert.That( asList[ 4 ].IsArray ); + Assert.That( asList[ 4 ].AsList().Single().AsInt32(), Is.EqualTo( target.Points.Single() ) ); + } + ); + } + + [Test] + public void TestToFromMessagePackObject_ComplexGenerated() + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + // This test does not check packed result -- it is verfied with previous test and seems overkill. + this.TestToFromMessagePackObjectCore( target, _ => {} ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion ) + where T : IVerifiable + { + this.TestToFromMessagePackObjectCore( value, mpoAssertion, true ); + this.TestToFromMessagePackObjectCore( value, mpoAssertion, false ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion, bool avoidsGenericSerializer ) + where T : IVerifiable + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + var serializer = this.CreateTarget( context ); + var mpo = serializer.ToMessagePackObject( value ); + mpoAssertion( mpo ); + var result = serializer.FromMessagePackObject( mpo ); + result.Verify( value ); + + var mpoLoose = ( ( MessagePackSerializer )serializer ).ToMessagePackObject( value ); + mpoAssertion( mpoLoose ); + var resultLoose = ( ( MessagePackSerializer )serializer ).FromMessagePackObject( mpoLoose ); + Assert.That( resultLoose, Is.TypeOf() ); + ( ( T )resultLoose ).Verify( value ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Object Packing/Unpacking -- + #region -- Polymorphism -- + #region ---- KnownType ---- + + #region ------ KnownType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.NormalTypes ------ + + #region ------ KnownType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.CollectionTypes ------ + + #region ------ KnownType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ KnownType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- KnownType ---- + #region ---- RuntimeType ---- + + #region ------ RuntimeType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.NormalTypes ------ + + #region ------ RuntimeType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.CollectionTypes ------ + + #region ------ RuntimeType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ RuntimeType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- RuntimeType ---- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + target.NormalVanilla = "ABC"; + target.NormalRuntime = new FileEntry { Name = "File", Size = 1 }; + target.NormalKnown = new FileEntry { Name = "File", Size = 2 }; + target.ObjectRuntime = new FileEntry { Name = "File", Size = 3 }; + target.ObjectRuntimeOmittedType = new MsgPack.UnitTest.TestTypes.OmittedType { Value = "ABC" }; + target.ListVanilla = new List { "ABC" }; + target.ListKnownItem = new List { new FileEntry { Name = "File", Size = 1 } }; + target.ListKnwonContainerRuntimeItem = new List { new FileEntry { Name = "File", Size = 2 } }; + target.ListObjectRuntimeItem = new List { new FileEntry { Name = "File", Size = 3 } }; + target.DictionaryVanilla = new Dictionary { { "Key", "ABC" } }; + target.DictionaryKnownValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 1 } } }; + target.DictionaryKnownContainerRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 2 } } }; + target.DictionaryObjectRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 3 } } }; +#if !NETFX_35 && !UNITY + target.Tuple = Tuple.Create( "ABC", new FileEntry { Name = "File", Size = 1 }, new FileEntry { Name = "File", Size = 3 }, new FileEntry { Name = "File", Size = 3 } ); +#endif // !NETFX_35 && !UNITY + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.EqualTo( target.NormalVanilla ), "NormalVanilla" ); + Assert.That( result.NormalVanilla, Is.InstanceOf( target.NormalVanilla.GetType() ), "NormalVanilla" ); + Assert.That( result.NormalRuntime, Is.EqualTo( target.NormalRuntime ), "NormalRuntime" ); + Assert.That( result.NormalRuntime, Is.InstanceOf( target.NormalRuntime.GetType() ), "NormalRuntime" ); + Assert.That( result.NormalKnown, Is.EqualTo( target.NormalKnown ), "NormalKnown" ); + Assert.That( result.NormalKnown, Is.InstanceOf( target.NormalKnown.GetType() ), "NormalKnown" ); + Assert.That( result.ObjectRuntime, Is.EqualTo( target.ObjectRuntime ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntime, Is.InstanceOf( target.ObjectRuntime.GetType() ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.EqualTo( target.ObjectRuntimeOmittedType ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.InstanceOf( target.ObjectRuntimeOmittedType.GetType() ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ListVanilla, Is.EqualTo( target.ListVanilla ), "ListVanilla" ); + Assert.That( result.ListVanilla, Is.InstanceOf( target.ListVanilla.GetType() ), "ListVanilla" ); + Assert.That( result.ListKnownItem, Is.EqualTo( target.ListKnownItem ), "ListKnownItem" ); + Assert.That( result.ListKnownItem, Is.InstanceOf( target.ListKnownItem.GetType() ), "ListKnownItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.EqualTo( target.ListKnwonContainerRuntimeItem ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.InstanceOf( target.ListKnwonContainerRuntimeItem.GetType() ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.EqualTo( target.ListObjectRuntimeItem ), "ListObjectRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.InstanceOf( target.ListObjectRuntimeItem.GetType() ), "ListObjectRuntimeItem" ); + Assert.That( result.DictionaryVanilla, Is.EqualTo( target.DictionaryVanilla ), "DictionaryVanilla" ); + Assert.That( result.DictionaryVanilla, Is.InstanceOf( target.DictionaryVanilla.GetType() ), "DictionaryVanilla" ); + Assert.That( result.DictionaryKnownValue, Is.EqualTo( target.DictionaryKnownValue ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownValue, Is.InstanceOf( target.DictionaryKnownValue.GetType() ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.EqualTo( target.DictionaryKnownContainerRuntimeValue ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.InstanceOf( target.DictionaryKnownContainerRuntimeValue.GetType() ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.EqualTo( target.DictionaryObjectRuntimeValue ), "DictionaryObjectRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.InstanceOf( target.DictionaryObjectRuntimeValue.GetType() ), "DictionaryObjectRuntimeValue" ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.EqualTo( target.Tuple ), "Tuple" ); + Assert.That( result.Tuple, Is.InstanceOf( target.Tuple.GetType() ), "Tuple" ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.Null ); + Assert.That( result.NormalRuntime, Is.Null ); + Assert.That( result.NormalKnown, Is.Null ); + Assert.That( result.ObjectRuntime, Is.Null ); + Assert.That( result.ObjectRuntimeOmittedType, Is.Null ); + Assert.That( result.ListVanilla, Is.Null ); + Assert.That( result.ListKnownItem, Is.Null ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.Null ); + Assert.That( result.ListObjectRuntimeItem, Is.Null ); + Assert.That( result.DictionaryVanilla, Is.Null ); + Assert.That( result.DictionaryKnownValue, Is.Null ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.Null ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.Null ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.Null ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } +#if !NETFX_35 && !UNITY + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTupleAbstractType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new TupleAbstractType { Value = Tuple.Create( new FileEntry { Name = "1", Size = 1 } as AbstractFileSystemEntry, new FileEntry { Name = "2", Size = 2 } as IFileSystemEntry, new FileEntry { Name = "3", Size = 3 } as AbstractFileSystemEntry, new FileEntry { Name = "4", Size = 4 } as IFileSystemEntry ) }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + // Issue 137 + [Test] + [Category( "PolymorphicSerialization" )] + public void TestGlobalNamespace() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#if FEATURE_TAP + [Test] + [Category( "PolymorphicSerialization" )] + public async Task TestGlobalNamespaceAsync() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + await serializer.PackAsync( buffer, target ); + buffer.Position = 0; + var result = await serializer.UnpackAsync( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#endif // FEATURE_TAP + +#region -- Polymorphic Attributes in Type and Member -- + + private static void SetUpDefaultCollectionsForPolymorphism( SerializationContext context ) + { + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicCollection ), typeof( KnownTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicCollection ), typeof( RuntimeTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicDictionary ), typeof( KnownTypePolymorphicDictionary ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicDictionary ), typeof( RuntimeTypePolymorphicDictionary ) ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphismAttributesInType() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + } + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + +#endregion -- Polymorphic Attributes in Type and Member -- + +#region -- TypeVerifier cases -- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoMethods_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoMethods { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseVoidReturnMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierVoidReturnMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseExtraParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierExtraParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierDoesNotLoadTypeItself() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + using ( var packer = Packer.Create( buffer ) ) + { + Polymorphic.TypeInfoEncoder.Encode( packer, typeof( DangerousClass ) ); + packer.PackArrayHeader( 1 ); + packer.PackString( "Foo" ); // Value + buffer.Position = 0; + var ex = Assert.Catch( () => serializer.Unpack( buffer ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "Type verifier rejects type " ) ); +#else + Assert.That( ex.Message.StartsWith( "Type verifier rejects type " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + +#endregion -- TypeVerifier cases -- + + + #endregion -- Polymorphism -- + [Test] + public void TestNullField() + { + this.TestCoreWithAutoVerify( default( object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( default( object ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestTrueField() + { + this.TestCoreWithAutoVerify( true, GetSerializationContext() ); + } + + [Test] + public void TestTrueFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( true, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestFalseField() + { + this.TestCoreWithAutoVerify( false, GetSerializationContext() ); + } + + [Test] + public void TestFalseFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( false, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyByteField() + { + this.TestCoreWithAutoVerify( 1, GetSerializationContext() ); + } + + [Test] + public void TestTinyByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 1, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteField() + { + this.TestCoreWithAutoVerify( 0x80, GetSerializationContext() ); + } + + [Test] + public void TestByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x80, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxByteField() + { + this.TestCoreWithAutoVerify( 0xff, GetSerializationContext() ); + } + + [Test] + public void TestMaxByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16Field() + { + this.TestCoreWithAutoVerify( 0x100, GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16Field() + { + this.TestCoreWithAutoVerify( 0xffff, GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xffff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32Field() + { + this.TestCoreWithAutoVerify( 0x10000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x10000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64Field() + { + this.TestCoreWithAutoVerify( 0x100000000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100000000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeField() + { + this.TestCoreWithAutoVerify( DateTime.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTime.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( DateTimeOffset.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTimeOffset.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriField() + { + this.TestCoreWithAutoVerify( new Uri( "http://example.com/" ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Uri( "http://example.com/" ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldNull() + { + this.TestCoreWithAutoVerify( default( Uri ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Uri[] ), GetSerializationContext() ); + } + + [Test] + public void TestVersionField() + { + this.TestCoreWithAutoVerify( new Version( 1, 2, 3, 4 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3, 4 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEField() + { + this.TestCoreWithAutoVerify( ToFileTime( DateTime.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( ToFileTime( DateTime.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanField() + { + this.TestCoreWithAutoVerify( TimeSpan.FromMilliseconds( 123456789 ), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( TimeSpan.FromMilliseconds( 123456789 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestGuidField() + { + this.TestCoreWithAutoVerify( Guid.NewGuid(), GetSerializationContext() ); + } + + [Test] + public void TestGuidFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Guid.NewGuid(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharField() + { + this.TestCoreWithAutoVerify( '　', GetSerializationContext() ); + } + + [Test] + public void TestCharFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( '　', 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDecimalField() + { + this.TestCoreWithAutoVerify( 123456789.0987654321m, GetSerializationContext() ); + } + + [Test] + public void TestDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 123456789.0987654321m, 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestBigIntegerField() + { + this.TestCoreWithAutoVerify( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestBigIntegerFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestComplexField() + { + this.TestCoreWithAutoVerify( new Complex( 1.3, 2.4 ), GetSerializationContext() ); + } + + [Test] + public void TestComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Complex( 1.3, 2.4 ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestDictionaryEntryField() + { + this.TestCoreWithAutoVerify( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryEntryFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestKeyValuePairStringComplexField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestStringField() + { + this.TestCoreWithAutoVerify( "StringValue", GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "StringValue", 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldNull() + { + this.TestCoreWithAutoVerify( default( String ), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( String[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayField() + { + this.TestCoreWithAutoVerify( new Byte[]{ 1, 2, 3, 4 }, GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Byte[]{ 1, 2, 3, 4 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Byte[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Byte[][] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayField() + { + this.TestCoreWithAutoVerify( "ABCD".ToCharArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "ABCD".ToCharArray(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Char[] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Char[][] ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32Field() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectField() + { + this.TestCoreWithAutoVerify( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple ), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestImage_Field() + { + this.TestCoreWithAutoVerify( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image ), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image[] ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectField() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayField() + { + this.TestCoreWithAutoVerify( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[][] ), GetSerializationContext() ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestArrayListField() + { + this.TestCoreWithAutoVerify( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldNull() + { + this.TestCoreWithAutoVerify( default( ArrayList ), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ArrayList[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestHashtableField() + { + this.TestCoreWithAutoVerify( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldNull() + { + this.TestCoreWithAutoVerify( default( Hashtable ), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Hashtable[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[][] ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList ), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestCoreWithAutoVerify( T value, SerializationContext context ) + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + AutoMessagePackSerializerTest.Verify( value, unpacked ); + } + } + + private void TestCoreWithVerifiable( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( value ); + } + } + + private void TestCoreWithVerifiable( T[] value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T[] unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.Length, Is.EqualTo( value.Length ) ); + for( int i = 0; i < unpacked.Length; i ++ ) + { + try + { + unpacked[ i ].Verify( value[ i ] ); + } +#if MSTEST + catch( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException ae ) + { + throw new Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#else + catch( AssertionException ae ) + { + throw new AssertionException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#endif + } + } + } + + private static FILETIME ToFileTime( DateTime dateTime ) + { + var fileTime = dateTime.ToFileTimeUtc(); + return new FILETIME(){ dwHighDateTime = unchecked( ( int )( fileTime >> 32 ) ), dwLowDateTime = unchecked( ( int )( fileTime & 0xffffffff ) ) }; + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt new file mode 100644 index 000000000..184ffebeb --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt @@ -0,0 +1,17 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.ttinclude" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.Types.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Linq" #> +<# +Geneate( "Array", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "VisualBasic" ); +GenerateTypes(); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs new file mode 100644 index 000000000..9e674c1ac --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs @@ -0,0 +1,721 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +#if !NETFX_CORE +using System.Collections; +#endif +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !AOT && !SILVERLIGHT +#if !NETFX_CORE +using Microsoft.FSharp.Collections; +#endif // !NETFX_CORE +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class ArrayVisualBasicCodeTreeBasedImmutableCollectionsTest + { + private MessagePackSerializer CreateTarget() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context.GetSerializer( PolymorphismSchema.Default ); + } + + private bool CanDump + { + get { return true; } + } + +#if !NETFX_CORE + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif + + [Test] + public void QueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Queue(); + value.Enqueue( 1 ); + value.Enqueue( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void StackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Stack(); + value.Push( 1 ); + value.Push( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + +#if !NETFX_CORE + [Test] + public void NonGenericQueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Queue(); + value.Enqueue( ( MessagePackObject )1 ); + value.Enqueue( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void NonGenericStackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Stack(); + value.Push( ( MessagePackObject )1 ); + value.Push( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } +#endif // !NETFX_CORE + + + [Test] + public void ImmutableArrayTest_0_Success() + { + var collection = ImmutableArray.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_1_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_2_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_0_Success() + { + var collection = ImmutableList.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_1_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_2_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_0_Success() + { + var collection = ImmutableStack.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_1_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_2_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + collection = collection.Push( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_0_Success() + { + var collection = ImmutableQueue.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_1_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_2_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + collection = collection.Enqueue( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_0_Success() + { + var collection = ImmutableHashSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_1_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_2_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_0_Success() + { + var collection = ImmutableSortedSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_1_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_2_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_0_Success() + { + var collection = ImmutableDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_1_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_2_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_0_Success() + { + var collection = ImmutableSortedDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_1_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_2_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#if !NETFX_CORE + + + [Test] + public void FSharpListTest_0_Success() + { + var collection = FSharpList.Empty; + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_1_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_2_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + collection = new FSharpList( 1, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_0_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_1_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_2_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_0_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_1_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_2_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#endif // !NETFX_CORE + + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt new file mode 100644 index 000000000..cec2b90a7 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt @@ -0,0 +1,15 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest.BclExtensions\Serialization\CustomCollectionSerializersTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "Array", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "VisualBasic" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.cs new file mode 100644 index 000000000..4819d8ab1 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.cs @@ -0,0 +1,1344 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2014-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP + +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT + +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 30000 )] + public class ArrayVisualBasicCodeTreeBasedEnumSerializerTest + { + private SerializationContext GetSerializationContext() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Array }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) + { + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( value.ToString() ) ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + // Properties are sorted by lexical order + var index = Array.IndexOf( typeof( T ).GetProperties().OrderBy( p => p.Name ).ToArray(), propertyInfo ); + var result = Unpacking.UnpackArray( stream ); + Assert.That( +#if !UNITY + result[ index ].Equals( propertyInfo.GetValue( value, null ).ToString() ), + result[ index ] + " == " + propertyInfo.GetValue( value, null ) +#else + result[ index ].Equals( propertyInfo.GetGetMethod().Invoke( value, null ).ToString() ), + result[ index ] + " == " + propertyInfo.GetGetMethod().Invoke( value, null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByName( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByNameAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#endif // FEATURE_TAP + + private static void TestEnumForByUnderlyingValueCore( Stream stream, T value, T deserialized, string property ) + { + + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + var result = Unpacking.UnpackObject( stream ); + Assert.That( + result.ToString().Equals( ( ( IFormattable )value ).ToString( "D", null ) ), + result + " == " + ( ( IFormattable )value ).ToString( "D", null ) + ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackArray( stream ); + // Properties are sorted by lexical order + var index = Array.IndexOf( typeof( T ).GetProperties().OrderBy( p => p.Name ).ToArray(), propertyInfo ); + Assert.That( +#if !UNITY + result[ index ].ToString().Equals( ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) ), + result[ index ] + " == " + ( ( IFormattable )propertyInfo.GetValue( value , null) ).ToString( "D", null ) +#else + result[ index ].ToString().Equals( ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) ), + result[ index ] + " == " + ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value , null) ).ToString( "D", null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByUnderlyingValue( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByUnderlyingValueAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumDefault.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumDefault.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumByName.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumByName.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByUnderlyingValueAsync( context, EnumByUnderlyingValue.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + // Issue #184 + [Test] + public void TestEnumKeyTransformer_Default_AsIs() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Default_AsIs_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper_Async() + { + var context = GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestEnumKeyCore( SerializationContext context, string expected, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = MidpointRounding.ToEven; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var stringValue = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsString(); + + Assert.That( stringValue, Is.EqualTo( expected ) ); + + buffer.Position = 0; + + MidpointRounding deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized, Is.EqualTo( obj ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.tt new file mode 100644 index 000000000..7cfb0d225 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/ArrayVisualBasicCodeTreeBasedEnumSerializationTest.tt @@ -0,0 +1,10 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\EnumSerializationTest.ttinclude" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<# +GenerateCore( "Array", "CodeTreeBased", true, false, "VisualBasic" ); +#> \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.cs new file mode 100644 index 000000000..cb2d70a35 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.cs @@ -0,0 +1,588 @@ + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.Serialization; +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class CSharpCodeTreeBasedNilImplicationTest + { + private SerializationContext CreateSerializationContext() + { + var context = new SerializationContext(); + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return MessagePackSerializer.CreateInternal( context, PolymorphismSchema.Default ); + } +#if !SILVERLIGHT && !AOT && !UNITY + +#if MSTEST + [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] + public void Initialize( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestContext c ) + { + this.SetUp(); + } +#else + [SetUp] +#endif + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled ) + { + try + { + SerializerDebugging.Dump(); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + // ------ Creation ------ + + [Test] + public void TestCreation_ValueType_OnlyNullIsInvalid() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + Assert.Throws( + () => CreateTarget( this.CreateSerializationContext() ) + ); + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_ReferenceType_AllOk() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_NullableValueType_AllOk() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_ReadOnlyCollectionProperty_OnlyNullIsInvalid() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + Assert.Throws( + () => CreateTarget( this.CreateSerializationContext() ) + ); + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + // ------ Packing ------ + + private void TestPackFail( + SerializationMethod method, + Func inputFactory + ) + where T : new() + where TException : Exception + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + Assert.Throws( () => seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ) ); + } + } + + // Packing null ValueType is not possible. + + [Test] + public void TestPack_ReadOnlyCollectionProperty_Prohibit_Fail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReadOnlyCollectionPropertyProhibit { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReadOnlyCollectionProperty_Prohibit_Fail_Map() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReadOnlyCollectionPropertyProhibit { Prohibit = null } + ); + } + + [Test] + public void TestPack_NullableValueType_ProhibitWillFail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { Prohibit = null } + ); + } + + [Test] + public void TestPack_NullableValueType_ProhibitWillFail_Map() + { + TestPackFail( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReferenceType_ProhibitWillFail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReferenceType_ProhibitWillFail_Map() + { + TestPackFail( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { Prohibit = null } + ); + } + + // ------ Unpacking ------ + + + private void TestUnpackSuccess( + SerializationMethod method, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, () => new T(), null, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func inputFactory, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, inputFactory, null, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func packedStreamFactory, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, () => new T(), packedStreamFactory, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func inputFactory, + Func packedStreamFactory, + Action assertion + ) + where T : new() + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + if ( packedStreamFactory != null ) + { + var bytes = packedStreamFactory(); + buffer.Write( bytes, 0, bytes.Length ); + } + else + { + seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ); + } + + buffer.Position = 0; + assertion( seraizlier.Unpack( buffer ), new T() ); + } + } + + private void TestUnpackFail( + SerializationMethod method, + Func packedStreamFactory + ) + where T : new() + where TException : Exception + { + this.TestUnpackingFail( method, null, packedStreamFactory ); + } + + private void TestUnpackingFail( + SerializationMethod method, + Func inputFactory, + Func packedStreamFactory + ) + where T : new() + where TException : Exception + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + if ( packedStreamFactory != null ) + { + var bytes = packedStreamFactory(); + buffer.Write( bytes, 0, bytes.Length ); + } + else + { + seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ); + } + + buffer.Position = 0; + Assert.Throws( () => seraizlier.Unpack( buffer ) ); + } + } + + [Test] + public void TestUnpack_ValueType_MemberDefault_Preserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ValueType_MemberDefault_Preserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ValueType_Prohibit_Fail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ValueType_Prohibit_Fail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => new byte[] { 0x81, ( byte )( 0xA0 + "Prohibit".Length ) }.Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray() + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_MemberDefault_Preserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_MemberDefault_Preserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new byte[] { 0x81, ( byte )( 0xA0 + ( "MemberDefault".Length ) ) }.Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray(), + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_Prohibit_Fail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_Prohibit_Fail_Map() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x81, ( byte )( 0xA0 + ( "Prohibit".Length ) ) }.Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray() + ); + } + + [Test] + public void TestUnpack_NullableValueType_MemberDefaultWillBePreserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_MemberDefaultWillBePreserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_NullWillBeNull_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_NullWillBeNull_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_ProhibitWillFail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x93, 0xC0, 0xC0, 0xC0 } + ); + } + + [Test] + public void TestUnpack_NullableValueType_ProhibitWillFail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => + new byte[] { 0x83 } + .Concat( new[] { ( byte )( 0xA0 + ( "MemberDefault".Length ) ) } ) + .Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Null".Length ) ) } ) + .Concat( "Null".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Prohibit".Length ) ) } ) + .Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .ToArray() + ); + } + + [Test] + public void TestUnpack_ReferenceType_MemberDefaultWillBePreserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_MemberDefaultWillBePreserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_NullWillBeNull_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_NullWillBeNull_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_ProhibitWillFail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x93, 0xC0, 0xC0, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ReferenceType_ProhibitWillFail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => + new byte[] { 0x83 } + .Concat( new[] { ( byte )( 0xA0 + ( "MemberDefault".Length ) ) } ) + .Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Null".Length ) ) } ) + .Concat( "Null".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Prohibit".Length ) ) } ) + .Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .ToArray() + ); + } + + [Test] + public void TestElelementMissingInTheFirstPlace_Map_MissingMembersAreSkipped() + { + using ( var buffer = new MemoryStream() ) + { + var valueOfValue1 = "123"; + using ( var packer = Packer.Create( buffer, false ) ) + { + packer.PackMapHeader( 1 ); + packer.PackString( "Value1" ); + packer.PackString( valueOfValue1 ); + } + + buffer.Position = 0; + + var context = this.CreateSerializationContext(); + context.SerializationMethod = SerializationMethod.Map; + var target = CreateTarget( context ); + var result = target.Unpack( buffer ); + + Assert.That( result.Value1, Is.EqualTo( valueOfValue1 ) ); + Assert.That( result.Value2, Is.EqualTo( new ComplexTypeWithTwoMember().Value2 ) ); + } + } + + [Test] + public void TestElelementTooManyInTheFirstPlace_Map_ExtrasAreIgnored() + { + using ( var buffer = new MemoryStream() ) + { + const string valueOfValue1 = "123"; + const string valueOfValue2 = "234"; + const string valueOfValue3 = "345"; + using ( var packer = Packer.Create( buffer, false ) ) + { + packer.PackMapHeader( 3 ); + packer.PackString( "Value1" ); + packer.PackString( valueOfValue1 ); + packer.PackString( "Value2" ); + packer.PackString( valueOfValue2 ); + packer.PackString( "Value3" ); + packer.PackString( valueOfValue3 ); + } + + buffer.Position = 0; + + var context = this.CreateSerializationContext(); + context.SerializationMethod = SerializationMethod.Map; + var target = CreateTarget( context ); + var result = target.Unpack( buffer ); + + Assert.That( result.Value1, Is.EqualTo( valueOfValue1 ) ); + Assert.That( result.Value2, Is.EqualTo( valueOfValue2 ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.tt new file mode 100644 index 000000000..9b9bc3219 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/CSharpCodeTreeBasedNilImplicationTest.tt @@ -0,0 +1,14 @@ +<#@ template hostSpecific="false" #> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\NilImplicationTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Windows.Forms" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "CodeTreeBased", "CSharp" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs new file mode 100644 index 000000000..0e65278c8 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.cs @@ -0,0 +1,22081 @@ + + + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Contributors: +// Samuel Cragg +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +#pragma warning disable 3003 +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !NETFX_35 && !WINDOWS_PHONE +using System.Numerics; +#endif // !NETFX_35 && !WINDOWS_PHONE +using System.Reflection; +using System.Runtime.InteropServices.ComTypes; +using System.Runtime.Serialization; +using System.Text; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using CategoryAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCategoryAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +using Does = NUnit.Framework.Does; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 60000 )] + public class MapCSharpCodeTreeBasedAutoMessagePackSerializerTest + { + private static SerializationContext GetSerializationContext() + { +#if !UNITY + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; +#else + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + +#endif // !UNITY + } + + private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions ) + { + var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return context.GetSerializer( context ); + } + +#if UNITY + [TestFixtureSetUp] + public static void SetUpFixture() + { + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareType(); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + } +#endif // UNITY + + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + private void DoKnownCollectionTest( SerializationContext context ) + where T : new() + { + using ( var buffer = new MemoryStream() ) + { + CreateTarget( context ).Pack( buffer, new T() ); + } + } + + [Test] + public void TestUnpackTo() + { + var target = this.CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, new[] { 1, 2 } ); + buffer.Position = 0; + int[] result = new int[ 2 ]; + using ( var unpacker = Unpacker.Create( buffer, false ) ) + { + unpacker.Read(); + target.UnpackTo( unpacker, result ); + Assert.That( result, Is.EqualTo( new[] { 1, 2 } ) ); + } + } + } + + [Test] + public void TestInt32() + { + TestCore( 1, stream => Unpacking.UnpackInt32( stream ), null ); + } + + [Test] + public void TestInt64() + { + TestCore( Int32.MaxValue + 1L, stream => Unpacking.UnpackInt64( stream ), null ); + } + + [Test] + public void TestString() + { + TestCore( "abc", stream => Unpacking.UnpackString( stream ), null ); + } + + [Test] + public void TestDateTime() + { + TestCore( + DateTime.Now, + stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeOffset() + { + TestCore( + DateTimeOffset.Now, + stream => + { + var array = Unpacking.UnpackArray( stream ); + return new DateTimeOffset( DateTime.FromBinary( array[ 0 ].AsInt64() ), TimeSpan.FromMinutes( array[ 1 ].AsInt16() ) ); + }, + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeClassic() + { + TestCore( + DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetClassic() + { + TestCore( + DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.DateTime.ToUniversalTime(), y.DateTime.ToUniversalTime() ), + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeNullableChangeOnDemand() + { + TestCore( + ( DateTime? )DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetNullableChangeOnDemand() + { + TestCore( + ( DateTimeOffset? )DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.Value.DateTime.ToUniversalTime(), y.Value.DateTime.ToUniversalTime() ), + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + private static bool CompareDateTime( DateTime x, DateTime y ) + { + return x.Date == y.Date && x.Hour == y.Hour && x.Minute == y.Minute && x.Second == y.Second && x.Millisecond == y.Millisecond; + } + + private static bool CompareDateTime( DateTime? x, DateTime? y ) + { + return CompareDateTime( x.Value, y.Value ); + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + + [Test] + public void TestUri() + { + TestCore( new Uri( "http://www.example.com" ), stream => new Uri( Unpacking.UnpackString( stream ) ), null ); + } + + [Test] + public void TestComplexObject_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObject_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestCoreWithVerify( target, context ); + } + +#if FEATURE_TAP + [Test] + public async Task TestComplexObjectAsync_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public async Task TestComplexObjectAsync_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private async Task TestComplexObjectAsyncCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + await TestCoreWithVerifyAsync( target, context ); + } +#endif // FEATURE_TAP + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithoutAnyAttribute( SerializationContext context ) + { + var target = new ComplexTypeWithoutAnyAttribute() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithMissingMessagePackMemberAttributeMember() + { + this.TestTypeWithMissingMessagePackMemberAttributeMemberCore( GetSerializationContext() ); + } + + private void TestTypeWithMissingMessagePackMemberAttributeMemberCore( SerializationContext context ) + { + var target = new TypeWithMissingMessagePackMemberAttributeMember(); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithInvalidMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestTypeWithDuplicatedMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithDataContractCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContract() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithDataContractWithOrderCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContractWithOrder() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithNonSerializedCore( SerializationContext context ) + { + var target = new ComplexTypeWithNonSerialized() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestDataMemberAttributeOrderWithOneBase() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseAsync() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserializeAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithZeroBase_ProtoBufCompatible_Fail() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + Assert.Throws( + () => this.CreateTarget( context ) + ); + } + + [Test] + public void TestDataMemberAttributeNamedProperties() + { + var context = GetSerializationContext(); + if ( context.SerializationMethod == SerializationMethod.Array ) + { + // Nothing to test. + return; + } + + var value = new DataMemberAttributeNamedPropertyTestTarget() { Member = "A Member" }; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var asDictionary = Unpacking.UnpackDictionary( buffer ); + + Assert.That( asDictionary[ "Alias" ] == value.Member ); + + buffer.Position = 0; + + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.Member, Is.EqualTo( value.Member ) ); + } + } + + [Test] + public void TestEnum() + { + TestCore( DayOfWeek.Sunday, stream => ( DayOfWeek )Enum.Parse( typeof( DayOfWeek ), Unpacking.UnpackString( stream ) ), ( x, y ) => x == y ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestNameValueCollection() + { + var target = new NameValueCollection(); + target.Add( String.Empty, "Empty-1" ); + target.Add( String.Empty, "Empty-2" ); + target.Add( "1", "1-1" ); + target.Add( "1", "1-2" ); + target.Add( "1", "1-3" ); + target.Add( "null", null ); // This value will not be packed. + target.Add( "Empty", String.Empty ); + target.Add( "2", "2" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, target ); + stream.Position = 0; + NameValueCollection result = serializer.Unpack( stream ); + Assert.That( result.GetValues( String.Empty ), Is.EquivalentTo( new[] { "Empty-1", "Empty-2" } ) ); + Assert.That( result.GetValues( "1" ), Is.EquivalentTo( new[] { "1-1", "1-2", "1-3" } ) ); + Assert.That( result.GetValues( "null" ), Is.Null ); + Assert.That( result.GetValues( "Empty" ), Is.EquivalentTo( new string[] { String.Empty } ) ); + Assert.That( result.GetValues( "2" ), Is.EquivalentTo( new string[] { "2" } ) ); + // null only value is not packed. + Assert.That( result.Count, Is.EqualTo( target.Count - 1 ) ); + } + } + + [Test] + public void TestNameValueCollection_NullKey() + { + var target = new NameValueCollection(); + target.Add( null, "null" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + Assert.Throws( () => serializer.Pack( stream, target ) ); + } + } +#endif + + [Test] + public void TestByteArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1, 2, 3, 4 } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackBinary( stream ).ToArray(), Is.EqualTo( new byte[] { 1, 2, 3, 4 } ) ); + } + } + + [Test] + public void TestCharArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new char[] { 'a', 'b', 'c', 'd' } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( "abcd" ) ); + } + } + +#if !NETFX_35 + [Test] + public void TestTuple1() + { + TestTupleCore( new Tuple( 1 ) ); + } + + [Test] + public void TestTuple7() + { + TestTupleCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public void TestTuple8() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public void TestTuple14() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public void TestTuple15() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private void TestTupleCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, expected ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( expected ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestTuple1Async() + { + await TestTupleAsyncCore( new Tuple( 1 ) ); + } + + [Test] + public async Task TestTuple7Async() + { + await TestTupleAsyncCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public async Task TestTuple8Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public async Task TestTuple14Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public async Task TestTuple15Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private async Task TestTupleAsyncCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, expected ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( expected ) ); + } + } +#endif // FEATURE_TAP +#endif // !NETFX_35 + + [Test] + public void TestEmptyBytes() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyBytes_Classic() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = this.CreateTarget( context ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyString() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, String.Empty ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( String.Empty ) ); + } + } + + [Test] + public void TestEmptyIntArray() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new int[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new int[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyKeyValuePairArray() + { + var serializer = this.CreateTarget[]>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new KeyValuePair[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new KeyValuePair[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyMap() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new Dictionary() ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new Dictionary() ) ); + } + } + + [Test] + public void TestNullable() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + serializer.Pack( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( null ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestNullableAsync() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + await serializer.PackAsync( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( null ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestValueType_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestValueTypeAsync_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + await serializer.PackAsync( stream, value ); + stream.Position = 0; + var result = await serializer.UnpackAsync( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } +#endif // FEATURE_TAP + + // Issue81 + [Test] + public void TestMultiDimensionalArray() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } + +#if FEATURE_TAP + // Issue81 + [Test] + public async Task TestMultiDimensionalArrayAsync() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, array ); + stream.Position = 0; + + var result = await serializer.UnpackAsync( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestMultiDimensionalArrayComprex() + { + var array = new int [ 2, 3, 4 ]; + array[ 0, 0, 0 ] = 0; + array[ 0, 0, 1 ] = 1; + array[ 0, 0, 2 ] = 2; + array[ 0, 0, 3 ] = 3; + array[ 0, 1, 0 ] = 10; + array[ 0, 1, 1 ] = 11; + array[ 0, 1, 2 ] = 12; + array[ 0, 1, 3 ] = 13; + array[ 0, 2, 0 ] = 20; + array[ 0, 2, 1 ] = 21; + array[ 0, 2, 2 ] = 22; + array[ 0, 2, 3 ] = 23; + array[ 1, 0, 0 ] = 100; + array[ 1, 0, 1 ] = 101; + array[ 1, 0, 2 ] = 102; + array[ 1, 0, 3 ] = 103; + array[ 1, 1, 0 ] = 110; + array[ 1, 1, 1 ] = 111; + array[ 1, 1, 2 ] = 112; + array[ 1, 1, 3 ] = 113; + array[ 1, 2, 0 ] = 120; + array[ 1, 2, 1 ] = 121; + array[ 1, 2, 2 ] = 122; + array[ 1, 2, 3 ] = 123; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 3 ) ); + Assert.That( result.Length, Is.EqualTo( 24 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 3 ) ); + Assert.That( result.GetLength( 2 ), Is.EqualTo( 4 ) ); + Assert.That( result[ 0, 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 0, 0, 2 ], Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0, 3 ], Is.EqualTo( 3 ) ); + Assert.That( result[ 0, 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 0, 1, 1 ], Is.EqualTo( 11 ) ); + Assert.That( result[ 0, 1, 2 ], Is.EqualTo( 12 ) ); + Assert.That( result[ 0, 1, 3 ], Is.EqualTo( 13 ) ); + Assert.That( result[ 0, 2, 0 ], Is.EqualTo( 20 ) ); + Assert.That( result[ 0, 2, 1 ], Is.EqualTo( 21 ) ); + Assert.That( result[ 0, 2, 2 ], Is.EqualTo( 22 ) ); + Assert.That( result[ 0, 2, 3 ], Is.EqualTo( 23 ) ); + Assert.That( result[ 1, 0, 0 ], Is.EqualTo( 100 ) ); + Assert.That( result[ 1, 0, 1 ], Is.EqualTo( 101 ) ); + Assert.That( result[ 1, 0, 2 ], Is.EqualTo( 102 ) ); + Assert.That( result[ 1, 0, 3 ], Is.EqualTo( 103 ) ); + Assert.That( result[ 1, 1, 0 ], Is.EqualTo( 110 ) ); + Assert.That( result[ 1, 1, 1 ], Is.EqualTo( 111 ) ); + Assert.That( result[ 1, 1, 2 ], Is.EqualTo( 112 ) ); + Assert.That( result[ 1, 1, 3 ], Is.EqualTo( 113 ) ); + Assert.That( result[ 1, 2, 0 ], Is.EqualTo( 120 ) ); + Assert.That( result[ 1, 2, 1 ], Is.EqualTo( 121 ) ); + Assert.That( result[ 1, 2, 2 ], Is.EqualTo( 122 ) ); + Assert.That( result[ 1, 2, 3 ], Is.EqualTo( 123 ) ); + } + } + + [Test] +#if UNITY_WORKAROUND + [Ignore( "Unity's Array.SetValue is buggy for non-SZArray" )] +#endif // UNITY_WORKAROUND + public void TestNonZeroBoundArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2 }, new [] { 1 } ); + array.SetValue( 1, 1 ); + array.SetValue( 2, 2 ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); +#if !SILVERLIGHT + Assert.That( result, Is.TypeOf( array.GetType() ) ); +#else + // Silverlight does not support lower bound settings, so sz array will return. + Assert.That( result, Is.TypeOf() ); +#endif // !SILVERLIGHT + Assert.That( result.Rank, Is.EqualTo( 1 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 2 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 3 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetValue( 2 ), Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestNonZeroBoundMultidimensionalArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2, 2 }, new [] { 1, 1 } ); + array.SetValue( 11, new [] { 1, 1 } ); + array.SetValue( 12, new [] { 1, 2 } ); + array.SetValue( 21, new [] { 2, 1 } ); + array.SetValue( 22, new [] { 2, 2 } ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf( array.GetType() ) ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 9 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1, 1 ), Is.EqualTo( 11 ) ); + Assert.That( result.GetValue( 1, 2 ), Is.EqualTo( 12 ) ); + Assert.That( result.GetValue( 2, 1 ), Is.EqualTo( 21 ) ); + Assert.That( result.GetValue( 2, 2 ), Is.EqualTo( 22 ) ); + } + } + + + [Test] + public void TestHasInitOnlyFieldWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherNameConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherNameConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( 0 ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherTypeConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherTypeConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( "0" ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAttribute_Preferred() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithConstructorAttribute( 1, false ); + Assert.That( value.IsAttributePreferred, Is.False ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1 ) ); + Assert.That( result.IsAttributePreferred, Is.True ); + } + } + + [Test] + public void TestConstrutorDeserializationWithMultipleAttributes_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + + [Test] + public void TestOptionalConstructorByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( byte )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorSByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( sbyte )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( short )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ushort )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( uint )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2L ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ulong )2L ) ); + } + } + + [Test] + public void TestOptionalConstructorSingle_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2f ) ); + } + } + + [Test] + public void TestOptionalConstructorDouble_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2 ) ); + } + } + + [Test] + public void TestOptionalConstructorDecimal_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2m ) ); + } + } + + [Test] + public void TestOptionalConstructorBoolean_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( true ) ); + } + } + + [Test] + public void TestOptionalConstructorChar_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 'A' ) ); + } + } + + [Test] + public void TestOptionalConstructorString_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestCollection_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new Collection() { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIListValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new ListValueType( 3 ) { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIDictionaryValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new DictionaryValueType( 3 ) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EquivalentTo( Enumerable.Range( 1, 3 ).Select( i => new KeyValuePair( i, i ) ).ToArray() ) ); + } + } + + [Test] + public void TestPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.Unpack( stream ), "Round-trip should not be succeeded." ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + + [Test] + public void TestUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(), "Round-trip should not be succeeded." ); + } + } + + [Test] + public void TestAsyncUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustAsyncUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new PackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( PackableUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new AsyncPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( AsyncPackableUnpackable.Dummy ) ); + } + } + + [Test] + public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new FullPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestBinary_ClassicContext() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.MinimumFixedRaw + 1, 1 } ) ); + } + } + + [Test] + public void TestBinary_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) ); + } + } + [Test] + public void TestExt_ClassicContext() + { + var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_DefaultContext() + { + var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None; + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_Default_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_WithoutRegistration_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Unregister( typeof( IList<> ) ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistration_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList<> ), typeof( Collection<> ) ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistrationForSpecific_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( Collection ) ); + var serializer1 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer1.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer1.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + + // check other types are not affected + var serializer2 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractStringCollection() { Collection = new[] { "1", "2" } }; + serializer2.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer2.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( "1" ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( "2" ) ); + } + } + + [Test] + public void TestAbstractTypes_NotACollection_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + +#if !NETFX_35 && !UNITY + [Test] + public void TestReadOnlyCollectionInterfaceDefault() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + null + ); + } + + [Test] + public void TestReadOnlyCollectionInterfaceExplicit() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyCollection ), typeof( AppendableReadOnlyCollection ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyList ), typeof( AppendableReadOnlyList ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyDictionary ), typeof( AppendableReadOnlyDictionary ) ) + ); + } + + private static void TestCollectionInterfaceCore( byte[] data, Action assertion, Action registration ) + { + using ( var buffer = new MemoryStream(data) ) + { + var serializer = MessagePackSerializer.Get( NewSerializationContext( PackerCompatibilityOptions.None ) ); + var result = serializer.Unpack( buffer ); + assertion( result ); + } + } +#endif // !NETFX_35 && !UNITY + + private void TestCore( T value, Func unpacking, Func comparer ) + { + TestCore( value, unpacking, comparer, null ); + } + + private void TestCore( T value, Func unpacking, Func comparer, Action contextAdjuster ) + { + var safeComparer = comparer ?? EqualityComparer.Default.Equals; + var context = GetSerializationContext(); + if ( contextAdjuster != null ) + { + contextAdjuster( context ); + } + + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T intermediate = unpacking( buffer ); + Assert.That( safeComparer( intermediate, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, intermediate ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + Assert.That( safeComparer( unpacked, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, unpacked ); + } + } + + private void TestCoreWithVerify( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#if FEATURE_TAP + + private async Task TestCoreWithVerifyAsync( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ); + buffer.Position = 0; + T unpacked = await target.UnpackAsync( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_Plain() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, hasEnumerable ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestIssue25_PlainAsync() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, hasEnumerable ); + buffer.Position = 0; + var result = await target.UnpackAsync( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_SelfComposite() + { + SerializationContext serializationContext = + SerializationContext.Default; + try + { + + serializationContext.Serializers.Register( new PersonSerializer() ); + serializationContext.Serializers.Register( new ChildrenSerializer() ); + + object[] array = new object[] { new Person { Name = "Joe" }, 3 }; + + MessagePackSerializer context = + serializationContext.GetSerializer(); + + byte[] packed = context.PackSingleObject( array ); + object[] unpacked = context.UnpackSingleObject( packed ); + + Assert.That( unpacked.Length, Is.EqualTo( 2 ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Name" ].AsString(), Is.EqualTo( "Joe" ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Children" ].IsNil ); + Assert.That( ( MessagePackObject )unpacked[ 1 ], Is.EqualTo( new MessagePackObject( 3 ) ) ); + } + finally + { + SerializationContext.Default = new SerializationContext(); + } + } + +#region -- ReadOnly / Private Members -- + + // ReSharper disable UnusedMember.Local + // member names + private const string PublicProperty = "PublicProperty"; + private const string PublicReadOnlyProperty = "PublicReadOnlyProperty"; + private const string NonPublicProperty = "NonPublicProperty"; + private const string PublicPropertyPlain = "PublicPropertyPlain"; + private const string PublicReadOnlyPropertyPlain = "PublicReadOnlyPropertyPlain"; + private const string NonPublicPropertyPlain = "NonPublicPropertyPlain"; + private const string CollectionReadOnlyProperty = "CollectionReadOnlyProperty"; + private const string NonPublicCollectionProperty = "NonPublicCollectionProperty"; + private const string NonPublicCollectionField = "NonPublicCollectionField"; + private const string NonPublicCollectionReadOnlyProperty = "NonPublicCollectionReadOnlyProperty"; + private const string NonPublicCollectionReadOnlyField = "NonPublicCollectionReadOnlyField"; + private const string NonPublicDictionaryProperty = "NonPublicDictionaryProperty"; + private const string NonPublicDictionaryField = "NonPublicDictionaryField"; + private const string NonPublicDictionaryReadOnlyProperty = "NonPublicDictionaryReadOnlyProperty"; + private const string NonPublicDictionaryReadOnlyField = "NonPublicDictionaryReadOnlyField"; + private const string NonPublicIDictionaryProperty = "NonPublicIDictionaryProperty"; + private const string NonPublicIDictionaryField = "NonPublicIDictionaryField"; + private const string NonPublicIDictionaryReadOnlyProperty = "NonPublicIDictionaryReadOnlyProperty"; + private const string NonPublicIDictionaryReadOnlyField = "NonPublicIDictionaryReadOnlyField"; + private const string PublicField = "PublicField"; + private const string PublicReadOnlyField = "PublicReadOnlyField"; + private const string NonPublicField = "NonPublicField"; + private const string PublicFieldPlain = "PublicFieldPlain"; + private const string PublicReadOnlyFieldPlain = "PublicReadOnlyFieldPlain"; + private const string NonPublicFieldPlain = "NonPublicFieldPlain"; +#if !NETFX_CORE && !SILVERLIGHT + private const string NonSerializedPublicField = "NonSerializedPublicField"; + private const string NonSerializedPublicReadOnlyField = "NonSerializedPublicReadOnlyField"; + private const string NonSerializedNonPublicField = "NonSerializedNonPublicField"; + private const string NonSerializedPublicFieldPlain = "NonSerializedPublicFieldPlain"; + private const string NonSerializedPublicReadOnlyFieldPlain = "NonSerializedPublicReadOnlyFieldPlain"; + private const string NonSerializedNonPublicFieldPlain = "NonSerializedNonPublicFieldPlain"; +#endif // !NETFX_CORE && !SILVERLIGHT + // ReSharper restore UnusedMember.Local + + [Test] + public void TestNonPublicWritableMember_PlainOldCliClass() + { + var target = new PlainClass(); + target.InitializeCollectionMembers(); + TestNonPublicWritableMemberCore( target, PublicProperty, PublicField, CollectionReadOnlyProperty ); + } + + [Test] + public void TestNonPublicWritableMember_MessagePackMember() + { + var target = new AnnotatedClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + [Test] + public void TestNonPublicWritableMember_DataContract() + { + // includes issue33 + var target = new DataMamberClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + private void TestNonPublicWritableMemberCore( T original, params string[] expectedMemberNames ) + { + var serializer = CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, original ); + buffer.Position = 0; + var actual = serializer.Unpack( buffer ); + + foreach ( var memberName in expectedMemberNames ) + { + Func getter = null; +#if !NETFX_CORE + var property = typeof( T ).GetProperty( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var property = typeof( T ).GetRuntimeProperties().SingleOrDefault( p => p.Name == memberName ); +#endif + if ( property != null ) + { +#if !UNITY + getter = obj => property.GetValue( obj, null ); +#else + getter = obj => property.GetGetMethod( true ).InvokePreservingExceptionType( obj ); +#endif // !UNITY + } + else + { +#if !NETFX_CORE + var field = typeof( T ).GetField( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var field = typeof( T ).GetRuntimeFields().SingleOrDefault( f => f.Name == memberName ); +#endif + if ( field == null ) + { + Assert.Fail( memberName + " is not found." ); + } + + getter = obj => field.GetValue( obj ); + } + + // Naive, but OK + if ( memberName.Contains( "IDictionary" ) ) + { + Func> toDictionary = + hashTable => + ( ( System.Collections.IEnumerable )hashTable ) + .OfType() + .ToDictionary( + de => de.Key.ToString(), + de => + ( de.Value is MessagePackObject ) + ? ( int )( MessagePackObject )de.Value + : ( int )de.Value + ); + + Assert.That( toDictionary( getter( actual ) ), Is.EqualTo( toDictionary( getter( original ) ) ), typeof(T) + "." + memberName ); + } + else + { + Assert.That( getter( actual ), Is.EqualTo( getter( original ) ), typeof(T) + "." + memberName ); + } + } + } + } + +#endregion -- ReadOnly / Private Members -- + +#region -- IPackabke/IUnpackable -- + + // Issue 150 + [Test] + public void TestExplicitlyImplementedPackableUnpackable() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new PackableUnpackableImplementedExplictly(); + obj.Data = "ABC"; + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + Assert.That( actual.Data, Is.EqualTo( PackableUnpackableImplementedExplictly.UnpackingPrefix + PackableUnpackableImplementedExplictly.PackingPrefix + obj.Data ) ); + } + } + + // Issue153 + + + [Test] + public void TestEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP + +#endregion -- IPackabke/IUnpackable -- + +#region -- Exclusion -- + + private void TestIgnoreCore( Action setter, Action assertion ) + where T : new() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new T(); + setter( obj ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + assertion( obj, actual ); + } + } + + private void TestIgnoreCore() + where TException : Exception + { + Assert.Throws( () => GetSerializationContext().GetSerializer() ); + } + + [Test] + public void TestIgnore_Normal() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotIgnored = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotIgnored, Is.EqualTo( expected.NotIgnored ) ); + } + ); + } + + [Test] + public void TestIgnore_ExcludedOnly() + { + TestIgnoreCore(); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionMixed() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotMarked = "ABC"; + target.Marked = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotMarked, Is.Null ); + Assert.That( actual.Marked, Is.EqualTo( expected.Marked ) ); + } + ); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionSimulatously() + { + TestIgnoreCore(); + } + + + public class OnlyExcluded + { + [MessagePackIgnore] + public string Ignored { get; set; } + } + + public class Excluded + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotIgnored { get; set; } + } + + public class ExclusionAndInclusionMixed + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotMarked { get; set; } + + [MessagePackMember( 0 )] + public string Marked { get; set; } + } + + public class ExclusionAndInclusionSimulatously + { + [MessagePackMember( 0 )] + public string Marked { get; set; } + + [MessagePackIgnore] + [MessagePackMember( 1 )] + public string DoubleMarked { get; set; } + } + +#endregion -- Exclusion -- + +#if !UNITY + // Mono 2.7.3 AOT fails when these classes are used... + // Issue 119 +#region -- Generic -- + + [Test] + public void TestGenericDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericValueClass + { + GenericField = 1, + GenericProperty = 2 + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericReferenceClass + { + GenericField = "1", + GenericProperty = "2" + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordValueClass( 1, 2 ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordReferenceClass( "1", "2" ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + +#endregion -- Generic -- + +#region -- Nullable -- + // Issue #121 + + [Test] + public void TestNullable_Primitive_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DateTime.UtcNow.Millisecond; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Primitive_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( int? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = TimeSpan.FromSeconds( DateTime.UtcNow.Millisecond ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( TimeSpan? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DayOfWeek.Monday; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( DayOfWeek? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } +#endregion -- Nullable -- + +#endif // !UNITY + + + // Related to issue #62 -- internal types handling is not consistent at first. + + [Test] + public void TestNonPublicType_Plain_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_MessagePackMember_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_DataContract_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + // Issue 170 + [Test] + public void TestStaticMembersDoNotCausePrepareError() + { + MessagePackSerializer.Get().PackSingleObject( new ClassHasStaticField() ); + } + +#pragma warning disable 649 + internal class NonPublic + { + public int Value; + } + + internal class NonPublicWithMessagePackMember + { + [MessagePackMember( 0 )] + public int Value; + } + + [DataContract] + internal class NonPublicWithDataContract + { + [DataMember] + public int Value; + } +#pragma warning restore 649 + + // issue #63 + [Test] + public void TestManyMembers() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + var target = new WithManyMembers(); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + +#pragma warning disable 659 + public class WithManyMembers + { + private readonly int[] _backingField = Enumerable.Range( 0, SByte.MaxValue + 2 ).ToArray(); + + public int Member0 + { + get { return this._backingField[ 0 ]; } + set { this._backingField[ 0 ] = value; } + } + public int Member1 + { + get { return this._backingField[ 1 ]; } + set { this._backingField[ 1 ] = value; } + } + public int Member2 + { + get { return this._backingField[ 2 ]; } + set { this._backingField[ 2 ] = value; } + } + public int Member3 + { + get { return this._backingField[ 3 ]; } + set { this._backingField[ 3 ] = value; } + } + public int Member4 + { + get { return this._backingField[ 4 ]; } + set { this._backingField[ 4 ] = value; } + } + public int Member5 + { + get { return this._backingField[ 5 ]; } + set { this._backingField[ 5 ] = value; } + } + public int Member6 + { + get { return this._backingField[ 6 ]; } + set { this._backingField[ 6 ] = value; } + } + public int Member7 + { + get { return this._backingField[ 7 ]; } + set { this._backingField[ 7 ] = value; } + } + public int Member8 + { + get { return this._backingField[ 8 ]; } + set { this._backingField[ 8 ] = value; } + } + public int Member9 + { + get { return this._backingField[ 9 ]; } + set { this._backingField[ 9 ] = value; } + } + public int Member10 + { + get { return this._backingField[ 10 ]; } + set { this._backingField[ 10 ] = value; } + } + public int Member11 + { + get { return this._backingField[ 11 ]; } + set { this._backingField[ 11 ] = value; } + } + public int Member12 + { + get { return this._backingField[ 12 ]; } + set { this._backingField[ 12 ] = value; } + } + public int Member13 + { + get { return this._backingField[ 13 ]; } + set { this._backingField[ 13 ] = value; } + } + public int Member14 + { + get { return this._backingField[ 14 ]; } + set { this._backingField[ 14 ] = value; } + } + public int Member15 + { + get { return this._backingField[ 15 ]; } + set { this._backingField[ 15 ] = value; } + } + public int Member16 + { + get { return this._backingField[ 16 ]; } + set { this._backingField[ 16 ] = value; } + } + public int Member17 + { + get { return this._backingField[ 17 ]; } + set { this._backingField[ 17 ] = value; } + } + public int Member18 + { + get { return this._backingField[ 18 ]; } + set { this._backingField[ 18 ] = value; } + } + public int Member19 + { + get { return this._backingField[ 19 ]; } + set { this._backingField[ 19 ] = value; } + } + public int Member20 + { + get { return this._backingField[ 20 ]; } + set { this._backingField[ 20 ] = value; } + } + public int Member21 + { + get { return this._backingField[ 21 ]; } + set { this._backingField[ 21 ] = value; } + } + public int Member22 + { + get { return this._backingField[ 22 ]; } + set { this._backingField[ 22 ] = value; } + } + public int Member23 + { + get { return this._backingField[ 23 ]; } + set { this._backingField[ 23 ] = value; } + } + public int Member24 + { + get { return this._backingField[ 24 ]; } + set { this._backingField[ 24 ] = value; } + } + public int Member25 + { + get { return this._backingField[ 25 ]; } + set { this._backingField[ 25 ] = value; } + } + public int Member26 + { + get { return this._backingField[ 26 ]; } + set { this._backingField[ 26 ] = value; } + } + public int Member27 + { + get { return this._backingField[ 27 ]; } + set { this._backingField[ 27 ] = value; } + } + public int Member28 + { + get { return this._backingField[ 28 ]; } + set { this._backingField[ 28 ] = value; } + } + public int Member29 + { + get { return this._backingField[ 29 ]; } + set { this._backingField[ 29 ] = value; } + } + public int Member30 + { + get { return this._backingField[ 30 ]; } + set { this._backingField[ 30 ] = value; } + } + public int Member31 + { + get { return this._backingField[ 31 ]; } + set { this._backingField[ 31 ] = value; } + } + public int Member32 + { + get { return this._backingField[ 32 ]; } + set { this._backingField[ 32 ] = value; } + } + public int Member33 + { + get { return this._backingField[ 33 ]; } + set { this._backingField[ 33 ] = value; } + } + public int Member34 + { + get { return this._backingField[ 34 ]; } + set { this._backingField[ 34 ] = value; } + } + public int Member35 + { + get { return this._backingField[ 35 ]; } + set { this._backingField[ 35 ] = value; } + } + public int Member36 + { + get { return this._backingField[ 36 ]; } + set { this._backingField[ 36 ] = value; } + } + public int Member37 + { + get { return this._backingField[ 37 ]; } + set { this._backingField[ 37 ] = value; } + } + public int Member38 + { + get { return this._backingField[ 38 ]; } + set { this._backingField[ 38 ] = value; } + } + public int Member39 + { + get { return this._backingField[ 39 ]; } + set { this._backingField[ 39 ] = value; } + } + public int Member40 + { + get { return this._backingField[ 40 ]; } + set { this._backingField[ 40 ] = value; } + } + public int Member41 + { + get { return this._backingField[ 41 ]; } + set { this._backingField[ 41 ] = value; } + } + public int Member42 + { + get { return this._backingField[ 42 ]; } + set { this._backingField[ 42 ] = value; } + } + public int Member43 + { + get { return this._backingField[ 43 ]; } + set { this._backingField[ 43 ] = value; } + } + public int Member44 + { + get { return this._backingField[ 44 ]; } + set { this._backingField[ 44 ] = value; } + } + public int Member45 + { + get { return this._backingField[ 45 ]; } + set { this._backingField[ 45 ] = value; } + } + public int Member46 + { + get { return this._backingField[ 46 ]; } + set { this._backingField[ 46 ] = value; } + } + public int Member47 + { + get { return this._backingField[ 47 ]; } + set { this._backingField[ 47 ] = value; } + } + public int Member48 + { + get { return this._backingField[ 48 ]; } + set { this._backingField[ 48 ] = value; } + } + public int Member49 + { + get { return this._backingField[ 49 ]; } + set { this._backingField[ 49 ] = value; } + } + public int Member50 + { + get { return this._backingField[ 50 ]; } + set { this._backingField[ 50 ] = value; } + } + public int Member51 + { + get { return this._backingField[ 51 ]; } + set { this._backingField[ 51 ] = value; } + } + public int Member52 + { + get { return this._backingField[ 52 ]; } + set { this._backingField[ 52 ] = value; } + } + public int Member53 + { + get { return this._backingField[ 53 ]; } + set { this._backingField[ 53 ] = value; } + } + public int Member54 + { + get { return this._backingField[ 54 ]; } + set { this._backingField[ 54 ] = value; } + } + public int Member55 + { + get { return this._backingField[ 55 ]; } + set { this._backingField[ 55 ] = value; } + } + public int Member56 + { + get { return this._backingField[ 56 ]; } + set { this._backingField[ 56 ] = value; } + } + public int Member57 + { + get { return this._backingField[ 57 ]; } + set { this._backingField[ 57 ] = value; } + } + public int Member58 + { + get { return this._backingField[ 58 ]; } + set { this._backingField[ 58 ] = value; } + } + public int Member59 + { + get { return this._backingField[ 59 ]; } + set { this._backingField[ 59 ] = value; } + } + public int Member60 + { + get { return this._backingField[ 60 ]; } + set { this._backingField[ 60 ] = value; } + } + public int Member61 + { + get { return this._backingField[ 61 ]; } + set { this._backingField[ 61 ] = value; } + } + public int Member62 + { + get { return this._backingField[ 62 ]; } + set { this._backingField[ 62 ] = value; } + } + public int Member63 + { + get { return this._backingField[ 63 ]; } + set { this._backingField[ 63 ] = value; } + } + public int Member64 + { + get { return this._backingField[ 64 ]; } + set { this._backingField[ 64 ] = value; } + } + public int Member65 + { + get { return this._backingField[ 65 ]; } + set { this._backingField[ 65 ] = value; } + } + public int Member66 + { + get { return this._backingField[ 66 ]; } + set { this._backingField[ 66 ] = value; } + } + public int Member67 + { + get { return this._backingField[ 67 ]; } + set { this._backingField[ 67 ] = value; } + } + public int Member68 + { + get { return this._backingField[ 68 ]; } + set { this._backingField[ 68 ] = value; } + } + public int Member69 + { + get { return this._backingField[ 69 ]; } + set { this._backingField[ 69 ] = value; } + } + public int Member70 + { + get { return this._backingField[ 70 ]; } + set { this._backingField[ 70 ] = value; } + } + public int Member71 + { + get { return this._backingField[ 71 ]; } + set { this._backingField[ 71 ] = value; } + } + public int Member72 + { + get { return this._backingField[ 72 ]; } + set { this._backingField[ 72 ] = value; } + } + public int Member73 + { + get { return this._backingField[ 73 ]; } + set { this._backingField[ 73 ] = value; } + } + public int Member74 + { + get { return this._backingField[ 74 ]; } + set { this._backingField[ 74 ] = value; } + } + public int Member75 + { + get { return this._backingField[ 75 ]; } + set { this._backingField[ 75 ] = value; } + } + public int Member76 + { + get { return this._backingField[ 76 ]; } + set { this._backingField[ 76 ] = value; } + } + public int Member77 + { + get { return this._backingField[ 77 ]; } + set { this._backingField[ 77 ] = value; } + } + public int Member78 + { + get { return this._backingField[ 78 ]; } + set { this._backingField[ 78 ] = value; } + } + public int Member79 + { + get { return this._backingField[ 79 ]; } + set { this._backingField[ 79 ] = value; } + } + public int Member80 + { + get { return this._backingField[ 80 ]; } + set { this._backingField[ 80 ] = value; } + } + public int Member81 + { + get { return this._backingField[ 81 ]; } + set { this._backingField[ 81 ] = value; } + } + public int Member82 + { + get { return this._backingField[ 82 ]; } + set { this._backingField[ 82 ] = value; } + } + public int Member83 + { + get { return this._backingField[ 83 ]; } + set { this._backingField[ 83 ] = value; } + } + public int Member84 + { + get { return this._backingField[ 84 ]; } + set { this._backingField[ 84 ] = value; } + } + public int Member85 + { + get { return this._backingField[ 85 ]; } + set { this._backingField[ 85 ] = value; } + } + public int Member86 + { + get { return this._backingField[ 86 ]; } + set { this._backingField[ 86 ] = value; } + } + public int Member87 + { + get { return this._backingField[ 87 ]; } + set { this._backingField[ 87 ] = value; } + } + public int Member88 + { + get { return this._backingField[ 88 ]; } + set { this._backingField[ 88 ] = value; } + } + public int Member89 + { + get { return this._backingField[ 89 ]; } + set { this._backingField[ 89 ] = value; } + } + public int Member90 + { + get { return this._backingField[ 90 ]; } + set { this._backingField[ 90 ] = value; } + } + public int Member91 + { + get { return this._backingField[ 91 ]; } + set { this._backingField[ 91 ] = value; } + } + public int Member92 + { + get { return this._backingField[ 92 ]; } + set { this._backingField[ 92 ] = value; } + } + public int Member93 + { + get { return this._backingField[ 93 ]; } + set { this._backingField[ 93 ] = value; } + } + public int Member94 + { + get { return this._backingField[ 94 ]; } + set { this._backingField[ 94 ] = value; } + } + public int Member95 + { + get { return this._backingField[ 95 ]; } + set { this._backingField[ 95 ] = value; } + } + public int Member96 + { + get { return this._backingField[ 96 ]; } + set { this._backingField[ 96 ] = value; } + } + public int Member97 + { + get { return this._backingField[ 97 ]; } + set { this._backingField[ 97 ] = value; } + } + public int Member98 + { + get { return this._backingField[ 98 ]; } + set { this._backingField[ 98 ] = value; } + } + public int Member99 + { + get { return this._backingField[ 99 ]; } + set { this._backingField[ 99 ] = value; } + } + public int Member100 + { + get { return this._backingField[ 100 ]; } + set { this._backingField[ 100 ] = value; } + } + public int Member101 + { + get { return this._backingField[ 101 ]; } + set { this._backingField[ 101 ] = value; } + } + public int Member102 + { + get { return this._backingField[ 102 ]; } + set { this._backingField[ 102 ] = value; } + } + public int Member103 + { + get { return this._backingField[ 103 ]; } + set { this._backingField[ 103 ] = value; } + } + public int Member104 + { + get { return this._backingField[ 104 ]; } + set { this._backingField[ 104 ] = value; } + } + public int Member105 + { + get { return this._backingField[ 105 ]; } + set { this._backingField[ 105 ] = value; } + } + public int Member106 + { + get { return this._backingField[ 106 ]; } + set { this._backingField[ 106 ] = value; } + } + public int Member107 + { + get { return this._backingField[ 107 ]; } + set { this._backingField[ 107 ] = value; } + } + public int Member108 + { + get { return this._backingField[ 108 ]; } + set { this._backingField[ 108 ] = value; } + } + public int Member109 + { + get { return this._backingField[ 109 ]; } + set { this._backingField[ 109 ] = value; } + } + public int Member110 + { + get { return this._backingField[ 110 ]; } + set { this._backingField[ 110 ] = value; } + } + public int Member111 + { + get { return this._backingField[ 111 ]; } + set { this._backingField[ 111 ] = value; } + } + public int Member112 + { + get { return this._backingField[ 112 ]; } + set { this._backingField[ 112 ] = value; } + } + public int Member113 + { + get { return this._backingField[ 113 ]; } + set { this._backingField[ 113 ] = value; } + } + public int Member114 + { + get { return this._backingField[ 114 ]; } + set { this._backingField[ 114 ] = value; } + } + public int Member115 + { + get { return this._backingField[ 115 ]; } + set { this._backingField[ 115 ] = value; } + } + public int Member116 + { + get { return this._backingField[ 116 ]; } + set { this._backingField[ 116 ] = value; } + } + public int Member117 + { + get { return this._backingField[ 117 ]; } + set { this._backingField[ 117 ] = value; } + } + public int Member118 + { + get { return this._backingField[ 118 ]; } + set { this._backingField[ 118 ] = value; } + } + public int Member119 + { + get { return this._backingField[ 119 ]; } + set { this._backingField[ 119 ] = value; } + } + public int Member120 + { + get { return this._backingField[ 120 ]; } + set { this._backingField[ 120 ] = value; } + } + public int Member121 + { + get { return this._backingField[ 121 ]; } + set { this._backingField[ 121 ] = value; } + } + public int Member122 + { + get { return this._backingField[ 122 ]; } + set { this._backingField[ 122 ] = value; } + } + public int Member123 + { + get { return this._backingField[ 123 ]; } + set { this._backingField[ 123 ] = value; } + } + public int Member124 + { + get { return this._backingField[ 124 ]; } + set { this._backingField[ 124 ] = value; } + } + public int Member125 + { + get { return this._backingField[ 125 ]; } + set { this._backingField[ 125 ] = value; } + } + public int Member126 + { + get { return this._backingField[ 126 ]; } + set { this._backingField[ 126 ] = value; } + } + public int Member127 + { + get { return this._backingField[ 127 ]; } + set { this._backingField[ 127 ] = value; } + } + public int Member128 + { + get { return this._backingField[ 128 ]; } + set { this._backingField[ 128 ] = value; } + } + + public override bool Equals( object obj ) + { + var other = obj as WithManyMembers; + if ( other == null ) + { + return false; + } + + return this._backingField == other._backingField || this._backingField.SequenceEqual( other._backingField ); + } + } +#pragma warning restore 659 + +#region issue #169 + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new GenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new NonGenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + // Issue #136 + [Test] + public void TestOmitNullEntryInDictionary() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" ); + TestOmitNullEntryInDictionaryCore( context, true, false ); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, false, false ); + } + +#if FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_Async() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" ); + TestOmitNullEntryInDictionaryCore( context, true, true ); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, false, true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_BackwordCompatibility() + { + SerializerDebugging.UseLegacyNullMapEntryHandling = true; + try + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, true, false ); + } + finally + { + SerializerDebugging.UseLegacyNullMapEntryHandling = false; + } + } + +#if FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_BackwordCompatibility_Async() + { + SerializerDebugging.UseLegacyNullMapEntryHandling = true; + try + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, true, true ); + } + finally + { + SerializerDebugging.UseLegacyNullMapEntryHandling = false; + } + } + +#endif // FEATURE_TAP + + private static void TestOmitNullEntryInDictionaryCore( SerializationContext context, bool shouldContainNulls, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = new SimpleClass { FirstProperty = "foo", SecondProperty = null }; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TASK + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TASK + serializer.Pack( buffer, obj ); +#if FEATURE_TASK + } +#endif // FEATURE_TASK + + buffer.Position = 0; + var map = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsDictionary(); + + Assert.That( map.ContainsKey( "FirstProperty" ) ); + Assert.That( map.ContainsKey( "SecondProperty" ), Is.EqualTo( shouldContainNulls ) ); + Assert.That( map.ContainsKey( "ThirdProperty" ), Is.EqualTo( shouldContainNulls ) ); + Assert.That( map.ContainsKey( "FourthProperty" ) ); + + Assert.That( map[ "FirstProperty" ].AsString(), Is.EqualTo( "foo" ) ); + if ( shouldContainNulls ) + { + Assert.That( map[ "SecondProperty" ].IsNil ); + Assert.That( map[ "ThirdProperty" ].IsNil ); + } + Assert.That( map[ "FourthProperty" ].AsInt32(), Is.EqualTo( 0 ) ); + + buffer.Position = 0; + + SimpleClass deserialized; +#if FEATURE_TASK + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TASK + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TASK + } +#endif // FEATURE_TASK + + Assert.That( deserialized.FirstProperty, Is.EqualTo( obj.FirstProperty) ); + Assert.That( deserialized.SecondProperty, Is.EqualTo( obj.SecondProperty) ); + Assert.That( deserialized.ThirdProperty, Is.EqualTo( obj.ThirdProperty) ); + Assert.That( deserialized.FourthProperty, Is.EqualTo( obj.FourthProperty) ); + } + } + + // Issue #175 + [Test] + public void TestDictionaryKeyTransformer_Default_AsIs() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" ); + TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Default_AsIs_Async() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" ); + TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_LowerCamel() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel; + TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_LowerCamel_Async() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel; + TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Custom() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Custom_Async() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestDictionaryKeyCore( SerializationContext context, string expectedKey1, string expectedKey2, string expectedKey3, string expectedKey4, bool asIs, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = new SimpleClass { FirstProperty = "foo", SecondProperty = "bar", ThirdProperty = 3, FourthProperty = 4 }; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var map = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsDictionary(); + + Assert.That( map.ContainsKey( "FirstProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "SecondProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "ThirdProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "FourthProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( expectedKey1 ) ); + Assert.That( map.ContainsKey( expectedKey2 ) ); + Assert.That( map.ContainsKey( expectedKey3 ) ); + Assert.That( map.ContainsKey( expectedKey4 ) ); + + buffer.Position = 0; + + SimpleClass deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized.FirstProperty, Is.EqualTo( obj.FirstProperty ) ); + Assert.That( deserialized.SecondProperty, Is.EqualTo( obj.SecondProperty ) ); + Assert.That( deserialized.ThirdProperty, Is.EqualTo( obj.ThirdProperty ) ); + Assert.That( deserialized.FourthProperty, Is.EqualTo( obj.FourthProperty ) ); + } + } +#endregion issue #169 + + #region -- Asymmetric -- + [Test] + public void TestAsymmetric_PackOnly_NoSettableNoConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableNoConstructorsForAsymmetricTest().Initialize( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoSettableMultipleConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableMultipleConstructorsForAsymmetricTest( "A", 0 ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoDefaultConstructor_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoDefaultConstructorForAsymmetricTest( 'A' ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableDictionaryForAsymmetricTest( new KeyValuePair( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericDictionaryForAsymmetricTest( new DictionaryEntry( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + + [Test] + public void TestAsymmetric_PackOnly_UnsettableArrayMemberObject_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnsettableArrayMemberObjectForAsymmetricTest(), + SerializerCapabilities.PackTo, + new byte[] { 0x82, 0xA5, ( byte )'F', ( byte )'i', ( byte )'e', ( byte )'l', ( byte )'d', 0x91, 0xA1, ( byte )'A', 0xA8, ( byte )'P', ( byte )'r', ( byte )'o', ( byte )'p', ( byte )'e', ( byte )'r', ( byte )'t', ( byte )'y', 0x91, 0xA1, ( byte )'A' } + ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized ) + { + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, true ); + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, false ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized, bool avoidsGenericSerializer ) + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowAsymmetricSerializer = true; + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + + var serializer = this.CreateTarget( context ); + Assert.That( serializer.Capabilities, Is.EqualTo( expectedCapabilities ) ); + + var obj = factory(); + using ( var buffer = new MemoryStream() ) + { + if ( ( expectedCapabilities & SerializerCapabilities.PackTo ) != 0 ) + { + serializer.Pack( buffer, obj ); + Assert.That( buffer.ToArray(), Is.EqualTo( serialized ), "{0} != {1}", BitConverter.ToString( buffer.ToArray() ), BitConverter.ToString( serialized ) ); + } + else if ( ( expectedCapabilities & SerializerCapabilities.UnpackFrom ) != 0 ) + { + buffer.Write( serialized, 0, serialized.Length ); + buffer.Position = 0; + var unpacked = serializer.Unpack( buffer ); + Assert.That( obj, Is.EqualTo( unpacked ) ); + } + } + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Asymmetric -- + + #region -- Object Packing/Unpacking -- + + [Test] + public void TestToFromMessagePackObject_Complex() + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestToFromMessagePackObjectCore( + target, + mpo => + { + Assert.That( mpo.IsDictionary ); + var asDictionary = mpo.AsDictionary(); + Assert.That( asDictionary.Count, Is.EqualTo( 5 ) ); + + Assert.That( asDictionary[ "Source" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "Source" ].AsString(), Is.EqualTo( target.Source.ToString() ) ); + + Assert.That( asDictionary[ "Data" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "Data" ].AsBinary(), Is.EqualTo( target.Data ) ); + + Assert.That( asDictionary[ "TimeStamp" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "TimeStamp" ].AsInt64(), Is.EqualTo( target.TimeStamp.ToBinary() ) ); + + Assert.That( asDictionary[ "History" ].AsDictionary().Single().Key.AsInt64(), Is.EqualTo( target.History.Single().Key.ToBinary() ) ); + Assert.That( asDictionary[ "History" ].AsDictionary().Single().Value.AsString(), Is.EqualTo( target.History.Single().Value ) ); + + Assert.That( asDictionary[ "Points" ].IsArray ); + Assert.That( asDictionary[ "Points" ].AsList().Single().AsInt32(), Is.EqualTo( target.Points.Single() ) ); + } + ); + } + + [Test] + public void TestToFromMessagePackObject_ComplexGenerated() + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + // This test does not check packed result -- it is verfied with previous test and seems overkill. + this.TestToFromMessagePackObjectCore( target, _ => {} ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion ) + where T : IVerifiable + { + this.TestToFromMessagePackObjectCore( value, mpoAssertion, true ); + this.TestToFromMessagePackObjectCore( value, mpoAssertion, false ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion, bool avoidsGenericSerializer ) + where T : IVerifiable + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + var serializer = this.CreateTarget( context ); + var mpo = serializer.ToMessagePackObject( value ); + mpoAssertion( mpo ); + var result = serializer.FromMessagePackObject( mpo ); + result.Verify( value ); + + var mpoLoose = ( ( MessagePackSerializer )serializer ).ToMessagePackObject( value ); + mpoAssertion( mpoLoose ); + var resultLoose = ( ( MessagePackSerializer )serializer ).FromMessagePackObject( mpoLoose ); + Assert.That( resultLoose, Is.TypeOf() ); + ( ( T )resultLoose ).Verify( value ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Object Packing/Unpacking -- + #region -- Polymorphism -- + #region ---- KnownType ---- + + #region ------ KnownType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.NormalTypes ------ + + #region ------ KnownType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.CollectionTypes ------ + + #region ------ KnownType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ KnownType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- KnownType ---- + #region ---- RuntimeType ---- + + #region ------ RuntimeType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.NormalTypes ------ + + #region ------ RuntimeType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.CollectionTypes ------ + + #region ------ RuntimeType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ RuntimeType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- RuntimeType ---- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + target.NormalVanilla = "ABC"; + target.NormalRuntime = new FileEntry { Name = "File", Size = 1 }; + target.NormalKnown = new FileEntry { Name = "File", Size = 2 }; + target.ObjectRuntime = new FileEntry { Name = "File", Size = 3 }; + target.ObjectRuntimeOmittedType = new MsgPack.UnitTest.TestTypes.OmittedType { Value = "ABC" }; + target.ListVanilla = new List { "ABC" }; + target.ListKnownItem = new List { new FileEntry { Name = "File", Size = 1 } }; + target.ListKnwonContainerRuntimeItem = new List { new FileEntry { Name = "File", Size = 2 } }; + target.ListObjectRuntimeItem = new List { new FileEntry { Name = "File", Size = 3 } }; + target.DictionaryVanilla = new Dictionary { { "Key", "ABC" } }; + target.DictionaryKnownValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 1 } } }; + target.DictionaryKnownContainerRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 2 } } }; + target.DictionaryObjectRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 3 } } }; +#if !NETFX_35 && !UNITY + target.Tuple = Tuple.Create( "ABC", new FileEntry { Name = "File", Size = 1 }, new FileEntry { Name = "File", Size = 3 }, new FileEntry { Name = "File", Size = 3 } ); +#endif // !NETFX_35 && !UNITY + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.EqualTo( target.NormalVanilla ), "NormalVanilla" ); + Assert.That( result.NormalVanilla, Is.InstanceOf( target.NormalVanilla.GetType() ), "NormalVanilla" ); + Assert.That( result.NormalRuntime, Is.EqualTo( target.NormalRuntime ), "NormalRuntime" ); + Assert.That( result.NormalRuntime, Is.InstanceOf( target.NormalRuntime.GetType() ), "NormalRuntime" ); + Assert.That( result.NormalKnown, Is.EqualTo( target.NormalKnown ), "NormalKnown" ); + Assert.That( result.NormalKnown, Is.InstanceOf( target.NormalKnown.GetType() ), "NormalKnown" ); + Assert.That( result.ObjectRuntime, Is.EqualTo( target.ObjectRuntime ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntime, Is.InstanceOf( target.ObjectRuntime.GetType() ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.EqualTo( target.ObjectRuntimeOmittedType ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.InstanceOf( target.ObjectRuntimeOmittedType.GetType() ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ListVanilla, Is.EqualTo( target.ListVanilla ), "ListVanilla" ); + Assert.That( result.ListVanilla, Is.InstanceOf( target.ListVanilla.GetType() ), "ListVanilla" ); + Assert.That( result.ListKnownItem, Is.EqualTo( target.ListKnownItem ), "ListKnownItem" ); + Assert.That( result.ListKnownItem, Is.InstanceOf( target.ListKnownItem.GetType() ), "ListKnownItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.EqualTo( target.ListKnwonContainerRuntimeItem ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.InstanceOf( target.ListKnwonContainerRuntimeItem.GetType() ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.EqualTo( target.ListObjectRuntimeItem ), "ListObjectRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.InstanceOf( target.ListObjectRuntimeItem.GetType() ), "ListObjectRuntimeItem" ); + Assert.That( result.DictionaryVanilla, Is.EqualTo( target.DictionaryVanilla ), "DictionaryVanilla" ); + Assert.That( result.DictionaryVanilla, Is.InstanceOf( target.DictionaryVanilla.GetType() ), "DictionaryVanilla" ); + Assert.That( result.DictionaryKnownValue, Is.EqualTo( target.DictionaryKnownValue ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownValue, Is.InstanceOf( target.DictionaryKnownValue.GetType() ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.EqualTo( target.DictionaryKnownContainerRuntimeValue ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.InstanceOf( target.DictionaryKnownContainerRuntimeValue.GetType() ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.EqualTo( target.DictionaryObjectRuntimeValue ), "DictionaryObjectRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.InstanceOf( target.DictionaryObjectRuntimeValue.GetType() ), "DictionaryObjectRuntimeValue" ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.EqualTo( target.Tuple ), "Tuple" ); + Assert.That( result.Tuple, Is.InstanceOf( target.Tuple.GetType() ), "Tuple" ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.Null ); + Assert.That( result.NormalRuntime, Is.Null ); + Assert.That( result.NormalKnown, Is.Null ); + Assert.That( result.ObjectRuntime, Is.Null ); + Assert.That( result.ObjectRuntimeOmittedType, Is.Null ); + Assert.That( result.ListVanilla, Is.Null ); + Assert.That( result.ListKnownItem, Is.Null ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.Null ); + Assert.That( result.ListObjectRuntimeItem, Is.Null ); + Assert.That( result.DictionaryVanilla, Is.Null ); + Assert.That( result.DictionaryKnownValue, Is.Null ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.Null ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.Null ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.Null ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } +#if !NETFX_35 && !UNITY + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTupleAbstractType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new TupleAbstractType { Value = Tuple.Create( new FileEntry { Name = "1", Size = 1 } as AbstractFileSystemEntry, new FileEntry { Name = "2", Size = 2 } as IFileSystemEntry, new FileEntry { Name = "3", Size = 3 } as AbstractFileSystemEntry, new FileEntry { Name = "4", Size = 4 } as IFileSystemEntry ) }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + // Issue 137 + [Test] + [Category( "PolymorphicSerialization" )] + public void TestGlobalNamespace() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#if FEATURE_TAP + [Test] + [Category( "PolymorphicSerialization" )] + public async Task TestGlobalNamespaceAsync() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + await serializer.PackAsync( buffer, target ); + buffer.Position = 0; + var result = await serializer.UnpackAsync( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#endif // FEATURE_TAP + +#region -- Polymorphic Attributes in Type and Member -- + + private static void SetUpDefaultCollectionsForPolymorphism( SerializationContext context ) + { + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicCollection ), typeof( KnownTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicCollection ), typeof( RuntimeTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicDictionary ), typeof( KnownTypePolymorphicDictionary ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicDictionary ), typeof( RuntimeTypePolymorphicDictionary ) ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphismAttributesInType() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + } + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + +#endregion -- Polymorphic Attributes in Type and Member -- + +#region -- TypeVerifier cases -- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoMethods_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoMethods { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseVoidReturnMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierVoidReturnMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseExtraParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierExtraParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierDoesNotLoadTypeItself() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + using ( var packer = Packer.Create( buffer ) ) + { + Polymorphic.TypeInfoEncoder.Encode( packer, typeof( DangerousClass ) ); + packer.PackArrayHeader( 1 ); + packer.PackString( "Foo" ); // Value + buffer.Position = 0; + var ex = Assert.Catch( () => serializer.Unpack( buffer ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "Type verifier rejects type " ) ); +#else + Assert.That( ex.Message.StartsWith( "Type verifier rejects type " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + +#endregion -- TypeVerifier cases -- + + + #endregion -- Polymorphism -- + [Test] + public void TestNullField() + { + this.TestCoreWithAutoVerify( default( object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( default( object ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestTrueField() + { + this.TestCoreWithAutoVerify( true, GetSerializationContext() ); + } + + [Test] + public void TestTrueFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( true, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestFalseField() + { + this.TestCoreWithAutoVerify( false, GetSerializationContext() ); + } + + [Test] + public void TestFalseFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( false, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyByteField() + { + this.TestCoreWithAutoVerify( 1, GetSerializationContext() ); + } + + [Test] + public void TestTinyByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 1, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteField() + { + this.TestCoreWithAutoVerify( 0x80, GetSerializationContext() ); + } + + [Test] + public void TestByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x80, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxByteField() + { + this.TestCoreWithAutoVerify( 0xff, GetSerializationContext() ); + } + + [Test] + public void TestMaxByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16Field() + { + this.TestCoreWithAutoVerify( 0x100, GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16Field() + { + this.TestCoreWithAutoVerify( 0xffff, GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xffff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32Field() + { + this.TestCoreWithAutoVerify( 0x10000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x10000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64Field() + { + this.TestCoreWithAutoVerify( 0x100000000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100000000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeField() + { + this.TestCoreWithAutoVerify( DateTime.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTime.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( DateTimeOffset.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTimeOffset.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriField() + { + this.TestCoreWithAutoVerify( new Uri( "http://example.com/" ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Uri( "http://example.com/" ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldNull() + { + this.TestCoreWithAutoVerify( default( Uri ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Uri[] ), GetSerializationContext() ); + } + + [Test] + public void TestVersionField() + { + this.TestCoreWithAutoVerify( new Version( 1, 2, 3, 4 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3, 4 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEField() + { + this.TestCoreWithAutoVerify( ToFileTime( DateTime.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( ToFileTime( DateTime.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanField() + { + this.TestCoreWithAutoVerify( TimeSpan.FromMilliseconds( 123456789 ), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( TimeSpan.FromMilliseconds( 123456789 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestGuidField() + { + this.TestCoreWithAutoVerify( Guid.NewGuid(), GetSerializationContext() ); + } + + [Test] + public void TestGuidFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Guid.NewGuid(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharField() + { + this.TestCoreWithAutoVerify( '　', GetSerializationContext() ); + } + + [Test] + public void TestCharFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( '　', 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDecimalField() + { + this.TestCoreWithAutoVerify( 123456789.0987654321m, GetSerializationContext() ); + } + + [Test] + public void TestDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 123456789.0987654321m, 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestBigIntegerField() + { + this.TestCoreWithAutoVerify( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestBigIntegerFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestComplexField() + { + this.TestCoreWithAutoVerify( new Complex( 1.3, 2.4 ), GetSerializationContext() ); + } + + [Test] + public void TestComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Complex( 1.3, 2.4 ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestDictionaryEntryField() + { + this.TestCoreWithAutoVerify( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryEntryFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestKeyValuePairStringComplexField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestStringField() + { + this.TestCoreWithAutoVerify( "StringValue", GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "StringValue", 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldNull() + { + this.TestCoreWithAutoVerify( default( String ), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( String[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayField() + { + this.TestCoreWithAutoVerify( new Byte[]{ 1, 2, 3, 4 }, GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Byte[]{ 1, 2, 3, 4 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Byte[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Byte[][] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayField() + { + this.TestCoreWithAutoVerify( "ABCD".ToCharArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "ABCD".ToCharArray(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Char[] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Char[][] ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32Field() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectField() + { + this.TestCoreWithAutoVerify( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple ), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestImage_Field() + { + this.TestCoreWithAutoVerify( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image ), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image[] ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectField() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayField() + { + this.TestCoreWithAutoVerify( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[][] ), GetSerializationContext() ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestArrayListField() + { + this.TestCoreWithAutoVerify( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldNull() + { + this.TestCoreWithAutoVerify( default( ArrayList ), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ArrayList[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestHashtableField() + { + this.TestCoreWithAutoVerify( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldNull() + { + this.TestCoreWithAutoVerify( default( Hashtable ), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Hashtable[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[][] ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList ), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestCoreWithAutoVerify( T value, SerializationContext context ) + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + AutoMessagePackSerializerTest.Verify( value, unpacked ); + } + } + + private void TestCoreWithVerifiable( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( value ); + } + } + + private void TestCoreWithVerifiable( T[] value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T[] unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.Length, Is.EqualTo( value.Length ) ); + for( int i = 0; i < unpacked.Length; i ++ ) + { + try + { + unpacked[ i ].Verify( value[ i ] ); + } +#if MSTEST + catch( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException ae ) + { + throw new Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#else + catch( AssertionException ae ) + { + throw new AssertionException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#endif + } + } + } + + private static FILETIME ToFileTime( DateTime dateTime ) + { + var fileTime = dateTime.ToFileTimeUtc(); + return new FILETIME(){ dwHighDateTime = unchecked( ( int )( fileTime >> 32 ) ), dwLowDateTime = unchecked( ( int )( fileTime & 0xffffffff ) ) }; + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt new file mode 100644 index 000000000..700929de0 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedAutoMessagePackSerializerTest.tt @@ -0,0 +1,17 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.ttinclude" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.Types.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Linq" #> +<# +Geneate( "Map", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "CSharp" ); +GenerateTypes(); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.cs new file mode 100644 index 000000000..ed032f005 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.cs @@ -0,0 +1,721 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +#if !NETFX_CORE +using System.Collections; +#endif +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !AOT && !SILVERLIGHT +#if !NETFX_CORE +using Microsoft.FSharp.Collections; +#endif // !NETFX_CORE +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class MapCSharpCodeTreeBasedImmutableCollectionsTest + { + private MessagePackSerializer CreateTarget() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context.GetSerializer( PolymorphismSchema.Default ); + } + + private bool CanDump + { + get { return true; } + } + +#if !NETFX_CORE + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif + + [Test] + public void QueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Queue(); + value.Enqueue( 1 ); + value.Enqueue( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void StackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Stack(); + value.Push( 1 ); + value.Push( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + +#if !NETFX_CORE + [Test] + public void NonGenericQueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Queue(); + value.Enqueue( ( MessagePackObject )1 ); + value.Enqueue( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void NonGenericStackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Stack(); + value.Push( ( MessagePackObject )1 ); + value.Push( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } +#endif // !NETFX_CORE + + + [Test] + public void ImmutableArrayTest_0_Success() + { + var collection = ImmutableArray.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_1_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_2_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_0_Success() + { + var collection = ImmutableList.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_1_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_2_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_0_Success() + { + var collection = ImmutableStack.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_1_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_2_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + collection = collection.Push( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_0_Success() + { + var collection = ImmutableQueue.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_1_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_2_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + collection = collection.Enqueue( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_0_Success() + { + var collection = ImmutableHashSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_1_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_2_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_0_Success() + { + var collection = ImmutableSortedSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_1_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_2_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_0_Success() + { + var collection = ImmutableDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_1_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_2_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_0_Success() + { + var collection = ImmutableSortedDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_1_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_2_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#if !NETFX_CORE + + + [Test] + public void FSharpListTest_0_Success() + { + var collection = FSharpList.Empty; + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_1_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_2_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + collection = new FSharpList( 1, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_0_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_1_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_2_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_0_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_1_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_2_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#endif // !NETFX_CORE + + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.tt new file mode 100644 index 000000000..8adffde8c --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedCustomCollectionSerializersTest.tt @@ -0,0 +1,15 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest.BclExtensions\Serialization\CustomCollectionSerializersTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "Map", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "CSharp" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.cs new file mode 100644 index 000000000..d9666ce29 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.cs @@ -0,0 +1,1340 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2014-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP + +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT + +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 30000 )] + public class MapCSharpCodeTreeBasedEnumSerializerTest + { + private SerializationContext GetSerializationContext() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CSharpCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) + { + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( value.ToString() ) ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackDictionary( stream ); + Assert.That( +#if !UNITY + result[ property ].Equals( propertyInfo.GetValue( value, null ).ToString() ), + result[ property ] + " == " + propertyInfo.GetValue( value, null ) +#else + result[ property ].Equals( propertyInfo.GetGetMethod().Invoke( value, null ).ToString() ), + result[ property ] + " == " + propertyInfo.GetGetMethod().Invoke( value, null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByName( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByNameAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#endif // FEATURE_TAP + + private static void TestEnumForByUnderlyingValueCore( Stream stream, T value, T deserialized, string property ) + { + + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + var result = Unpacking.UnpackObject( stream ); + Assert.That( + result.ToString().Equals( ( ( IFormattable )value ).ToString( "D", null ) ), + result + " == " + ( ( IFormattable )value ).ToString( "D", null ) + ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackDictionary( stream ); + Assert.That( +#if !UNITY + result[ property ].ToString().Equals( ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) ), + result[ property ] + " == " + ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) +#else + result[ property ].ToString().Equals( ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) ), + result[ property ] + " == " + ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByUnderlyingValue( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByUnderlyingValueAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumDefault.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumDefault.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumByName.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumByName.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByUnderlyingValueAsync( context, EnumByUnderlyingValue.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + // Issue #184 + [Test] + public void TestEnumKeyTransformer_Default_AsIs() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Default_AsIs_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper_Async() + { + var context = GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestEnumKeyCore( SerializationContext context, string expected, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = MidpointRounding.ToEven; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var stringValue = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsString(); + + Assert.That( stringValue, Is.EqualTo( expected ) ); + + buffer.Position = 0; + + MidpointRounding deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized, Is.EqualTo( obj ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.tt new file mode 100644 index 000000000..eebd6d077 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapCSharpCodeTreeBasedEnumSerializationTest.tt @@ -0,0 +1,10 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\EnumSerializationTest.ttinclude" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<# +GenerateCore( "Map", "CodeTreeBased", true, false, "CSharp" ); +#> \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs new file mode 100644 index 000000000..87ddc8284 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.cs @@ -0,0 +1,22081 @@ + + + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke and contributors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Contributors: +// Samuel Cragg +// +#endregion -- License Terms -- + +#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT +#define UNITY +#endif + +#pragma warning disable 3003 +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !NETFX_35 && !WINDOWS_PHONE +using System.Numerics; +#endif // !NETFX_35 && !WINDOWS_PHONE +using System.Reflection; +using System.Runtime.InteropServices.ComTypes; +using System.Runtime.Serialization; +using System.Text; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using CategoryAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestCategoryAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +using Does = NUnit.Framework.Does; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 60000 )] + public class MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest + { + private static SerializationContext GetSerializationContext() + { +#if !UNITY + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; +#else + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + +#endif // !UNITY + } + + private static SerializationContext NewSerializationContext( PackerCompatibilityOptions compatibilityOptions ) + { + var context = new SerializationContext( compatibilityOptions ) { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return context.GetSerializer( context ); + } + +#if UNITY + [TestFixtureSetUp] + public static void SetUpFixture() + { + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareCollectionType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareDictionaryType(); + MessagePackSerializer.PrepareType(); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + new ArraySegmentEqualityComparer().Equals( default( ArraySegment ), default( ArraySegment ) ); + } +#endif // UNITY + + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } + +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + private void DoKnownCollectionTest( SerializationContext context ) + where T : new() + { + using ( var buffer = new MemoryStream() ) + { + CreateTarget( context ).Pack( buffer, new T() ); + } + } + + [Test] + public void TestUnpackTo() + { + var target = this.CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, new[] { 1, 2 } ); + buffer.Position = 0; + int[] result = new int[ 2 ]; + using ( var unpacker = Unpacker.Create( buffer, false ) ) + { + unpacker.Read(); + target.UnpackTo( unpacker, result ); + Assert.That( result, Is.EqualTo( new[] { 1, 2 } ) ); + } + } + } + + [Test] + public void TestInt32() + { + TestCore( 1, stream => Unpacking.UnpackInt32( stream ), null ); + } + + [Test] + public void TestInt64() + { + TestCore( Int32.MaxValue + 1L, stream => Unpacking.UnpackInt64( stream ), null ); + } + + [Test] + public void TestString() + { + TestCore( "abc", stream => Unpacking.UnpackString( stream ), null ); + } + + [Test] + public void TestDateTime() + { + TestCore( + DateTime.Now, + stream => DateTime.FromBinary( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeOffset() + { + TestCore( + DateTimeOffset.Now, + stream => + { + var array = Unpacking.UnpackArray( stream ); + return new DateTimeOffset( DateTime.FromBinary( array[ 0 ].AsInt64() ), TimeSpan.FromMinutes( array[ 1 ].AsInt16() ) ); + }, + ( x, y ) => x.Equals( y ), + context => + { + Assert.That( context.DefaultDateTimeConversionMethod, Is.EqualTo( DateTimeConversionMethod.Native ) ); + } + ); + } + + [Test] + public void TestDateTimeClassic() + { + TestCore( + DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetClassic() + { + TestCore( + DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.DateTime.ToUniversalTime(), y.DateTime.ToUniversalTime() ), + context => + { + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeNullableChangeOnDemand() + { + TestCore( + ( DateTime? )DateTime.UtcNow, + stream => MessagePackConvert.ToDateTime( Unpacking.UnpackInt64( stream ) ), + CompareDateTime, + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + [Test] + public void TestDateTimeOffsetNullableChangeOnDemand() + { + TestCore( + ( DateTimeOffset? )DateTimeOffset.UtcNow, + stream => MessagePackConvert.ToDateTimeOffset( Unpacking.UnpackInt64( stream ) ), + ( x, y ) => CompareDateTime( x.Value.DateTime.ToUniversalTime(), y.Value.DateTime.ToUniversalTime() ), + context => + { + context.GetSerializer(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + } + ); + } + + private static bool CompareDateTime( DateTime x, DateTime y ) + { + return x.Date == y.Date && x.Hour == y.Hour && x.Minute == y.Minute && x.Second == y.Second && x.Millisecond == y.Millisecond; + } + + private static bool CompareDateTime( DateTime? x, DateTime? y ) + { + return CompareDateTime( x.Value, y.Value ); + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_NativeContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.Native; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeField, Is.EqualTo( input.VanillaDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( result.DefaultDateTimeField, Is.EqualTo( input.DefaultDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetField.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( result.DefaultDateTimeOffsetField.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // Kind is preserved. + Assert.That( result.VanillaDateTimeProperty, Is.EqualTo( input.VanillaDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( result.DefaultDateTimeProperty, Is.EqualTo( input.DefaultDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // Offset is preserved. + Assert.That( result.VanillaDateTimeOffsetProperty.DateTime, Is.EqualTo( input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( result.DefaultDateTimeOffsetProperty.DateTime, Is.EqualTo( input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Local() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.Now ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC is forced. + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + [Test] + public void TestDateTimeMemberAttributes_UnixEpocContext_Utc() + { + var context = GetSerializationContext(); + context.DefaultDateTimeConversionMethod = DateTimeConversionMethod.UnixEpoc; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + var input = new AnnotatedDateTimes( DateTimeOffset.UtcNow ); + target.Pack( buffer, input ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeField, input.VanillaDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeField, input.VanillaDateTimeField ); + Assert.That( CompareDateTime( result.DefaultDateTimeField, input.DefaultDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeField, input.DefaultDateTimeField ); + Assert.That( result.NativeDateTimeField, Is.EqualTo( input.NativeDateTimeField ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeField, input.NativeDateTimeField ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeField, input.UnixEpocDateTimeField.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeField, input.UnixEpocDateTimeField ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetField.DateTime, input.VanillaDateTimeOffsetField.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetField.DateTime, input.DefaultDateTimeOffsetField.DateTime ); + Assert.That( result.NativeDateTimeOffsetField.DateTime, Is.EqualTo( input.NativeDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetField.DateTime, input.NativeDateTimeOffsetField.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetField.DateTime, input.UnixEpocDateTimeOffsetField.DateTime ); + + // UTC is forced. + Assert.That( CompareDateTime( result.VanillaDateTimeProperty, input.VanillaDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeProperty, input.VanillaDateTimeProperty ); + Assert.That( CompareDateTime( result.DefaultDateTimeProperty, input.DefaultDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeProperty, input.DefaultDateTimeProperty ); + Assert.That( result.NativeDateTimeProperty, Is.EqualTo( input.NativeDateTimeProperty ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeProperty, input.NativeDateTimeProperty ); + Assert.That( CompareDateTime( result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty.ToUniversalTime() ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeProperty, input.UnixEpocDateTimeProperty ); + + + // UTC == UTC + Assert.That( CompareDateTime( result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.VanillaDateTimeOffsetProperty.DateTime, input.VanillaDateTimeOffsetProperty.DateTime ); + Assert.That( CompareDateTime( result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.DefaultDateTimeOffsetProperty.DateTime, input.DefaultDateTimeOffsetProperty.DateTime ); + Assert.That( result.NativeDateTimeOffsetProperty.DateTime, Is.EqualTo( input.NativeDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.NativeDateTimeOffsetProperty.DateTime, input.NativeDateTimeOffsetProperty.DateTime ); + // UTC == UTC + Assert.That( CompareDateTime( result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ), "{0:O}({0:%K}) == {1:O}({1:%K})", result.UnixEpocDateTimeOffsetProperty.DateTime, input.UnixEpocDateTimeOffsetProperty.DateTime ); + } + } + + + [Test] + public void TestUri() + { + TestCore( new Uri( "http://www.example.com" ), stream => new Uri( Unpacking.UnpackString( stream ) ), null ); + } + + [Test] + public void TestComplexObject_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObject_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestCoreWithVerify( target, context ); + } + +#if FEATURE_TAP + [Test] + public async Task TestComplexObjectAsync_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public async Task TestComplexObjectAsync_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + await this.TestComplexObjectAsyncCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private async Task TestComplexObjectAsyncCore( SerializationContext context ) + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + await TestCoreWithVerifyAsync( target, context ); + } +#endif // FEATURE_TAP + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithoutAnyAttribute_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithoutAnyAttribute( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithoutAnyAttribute( SerializationContext context ) + { + var target = new ComplexTypeWithoutAnyAttribute() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithMissingMessagePackMemberAttributeMember() + { + this.TestTypeWithMissingMessagePackMemberAttributeMemberCore( GetSerializationContext() ); + } + + private void TestTypeWithMissingMessagePackMemberAttributeMemberCore( SerializationContext context ) + { + var target = new TypeWithMissingMessagePackMemberAttributeMember(); + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestTypeWithInvalidMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestTypeWithDuplicatedMessagePackMemberAttributeMember() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithDataContract_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithDataContractCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithDataContractCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContract() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeWithDataContractWithOrder_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexTypeWithDataContractWithOrderCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexTypeWithDataContractWithOrderCore( SerializationContext context ) + { + var target = new ComplexTypeWithDataContractWithOrder() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#else + target.NonSerialized = new Stopwatch(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexObjectTypeWithNonSerialized_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestComplexObjectTypeWithNonSerializedCore( GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestComplexObjectTypeWithNonSerializedCore( SerializationContext context ) + { + var target = new ComplexTypeWithNonSerialized() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); +#if !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + target.NonSerialized = new DefaultTraceListener(); +#endif // !NETFX_CORE && !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 + TestCoreWithVerify( target, context ); + } + + [Test] + public void TestDataMemberAttributeOrderWithOneBase() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseAsync() + { + var context = GetSerializationContext(); + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBase_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var value = new ComplexTypeWithOneBaseOrder(); + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ).ConfigureAwait( false ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( value.One ) ); + Assert.That( unpacked.Two, Is.EqualTo( value.Two ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserializeAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x93, 0xff, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatible() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#if FEATURE_TAP + + [Test] + public async Task TestDataMemberAttributeOrderWithOneBaseDeserialize_ProtoBufCompatibleAsync() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + buffer.Write( new byte[] { 0x92, 10, 20 } ); + buffer.Position = 0; + var unpacked = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + Assert.That( unpacked.One, Is.EqualTo( 10 ) ); + Assert.That( unpacked.Two, Is.EqualTo( 20 ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestDataMemberAttributeOrderWithZeroBase_ProtoBufCompatible_Fail() + { + var context = GetSerializationContext(); + context.SerializationMethod = SerializationMethod.Array; + context.CompatibilityOptions.OneBoundDataMemberOrder = true; + Assert.Throws( + () => this.CreateTarget( context ) + ); + } + + [Test] + public void TestDataMemberAttributeNamedProperties() + { + var context = GetSerializationContext(); + if ( context.SerializationMethod == SerializationMethod.Array ) + { + // Nothing to test. + return; + } + + var value = new DataMemberAttributeNamedPropertyTestTarget() { Member = "A Member" }; + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + var asDictionary = Unpacking.UnpackDictionary( buffer ); + + Assert.That( asDictionary[ "Alias" ] == value.Member ); + + buffer.Position = 0; + + var unpacked = target.Unpack( buffer ); + Assert.That( unpacked.Member, Is.EqualTo( value.Member ) ); + } + } + + [Test] + public void TestEnum() + { + TestCore( DayOfWeek.Sunday, stream => ( DayOfWeek )Enum.Parse( typeof( DayOfWeek ), Unpacking.UnpackString( stream ) ), ( x, y ) => x == y ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestNameValueCollection() + { + var target = new NameValueCollection(); + target.Add( String.Empty, "Empty-1" ); + target.Add( String.Empty, "Empty-2" ); + target.Add( "1", "1-1" ); + target.Add( "1", "1-2" ); + target.Add( "1", "1-3" ); + target.Add( "null", null ); // This value will not be packed. + target.Add( "Empty", String.Empty ); + target.Add( "2", "2" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, target ); + stream.Position = 0; + NameValueCollection result = serializer.Unpack( stream ); + Assert.That( result.GetValues( String.Empty ), Is.EquivalentTo( new[] { "Empty-1", "Empty-2" } ) ); + Assert.That( result.GetValues( "1" ), Is.EquivalentTo( new[] { "1-1", "1-2", "1-3" } ) ); + Assert.That( result.GetValues( "null" ), Is.Null ); + Assert.That( result.GetValues( "Empty" ), Is.EquivalentTo( new string[] { String.Empty } ) ); + Assert.That( result.GetValues( "2" ), Is.EquivalentTo( new string[] { "2" } ) ); + // null only value is not packed. + Assert.That( result.Count, Is.EqualTo( target.Count - 1 ) ); + } + } + + [Test] + public void TestNameValueCollection_NullKey() + { + var target = new NameValueCollection(); + target.Add( null, "null" ); + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + Assert.Throws( () => serializer.Pack( stream, target ) ); + } + } +#endif + + [Test] + public void TestByteArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1, 2, 3, 4 } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackBinary( stream ).ToArray(), Is.EqualTo( new byte[] { 1, 2, 3, 4 } ) ); + } + } + + [Test] + public void TestCharArrayContent() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new char[] { 'a', 'b', 'c', 'd' } ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( "abcd" ) ); + } + } + +#if !NETFX_35 + [Test] + public void TestTuple1() + { + TestTupleCore( new Tuple( 1 ) ); + } + + [Test] + public void TestTuple7() + { + TestTupleCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public void TestTuple8() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public void TestTuple14() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public void TestTuple15() + { + TestTupleCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private void TestTupleCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, expected ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( expected ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestTuple1Async() + { + await TestTupleAsyncCore( new Tuple( 1 ) ); + } + + [Test] + public async Task TestTuple7Async() + { + await TestTupleAsyncCore( new Tuple( 1, "2", 3, "4", 5, "6", 7 ) ); + } + + [Test] + public async Task TestTuple8Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple>( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( "8" ) + ) + ); + } + + [Test] + public async Task TestTuple14Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple( + "8", 9, "10", 11, "12", 13, "14" + ) + ) + ); + } + + [Test] + public async Task TestTuple15Async() + { + await TestTupleAsyncCore( + new Tuple< + int, string, int, string, int, string, int, + Tuple< + string, int, string, int, string, int, string, + Tuple + > + >( + 1, "2", 3, "4", 5, "6", 7, + new Tuple>( + "8", 9, "10", 11, "12", 13, "14", + new Tuple( 15 ) + ) + ) + ); + } + + private async Task TestTupleAsyncCore( T expected ) + where T : IStructuralEquatable + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, expected ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( expected ) ); + } + } +#endif // FEATURE_TAP +#endif // !NETFX_35 + + [Test] + public void TestEmptyBytes() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 2 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyBytes_Classic() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = this.CreateTarget( context ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ), BitConverter.ToString( stream.ToArray() ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new byte[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyString() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, String.Empty ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( String.Empty ) ); + } + } + + [Test] + public void TestEmptyIntArray() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new int[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new int[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyKeyValuePairArray() + { + var serializer = this.CreateTarget[]>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new KeyValuePair[ 0 ] ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new KeyValuePair[ 0 ] ) ); + } + } + + [Test] + public void TestEmptyMap() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new Dictionary() ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( new Dictionary() ) ); + } + } + + [Test] + public void TestNullable() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + serializer.Pack( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( serializer.Unpack( stream ), Is.EqualTo( null ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestNullableAsync() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, 1 ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( 1 ) ); + + stream.Position = 0; + await serializer.PackAsync( stream, null ); + Assert.That( stream.Length, Is.EqualTo( 1 ) ); + stream.Position = 0; + Assert.That( await serializer.UnpackAsync( stream ), Is.EqualTo( null ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestValueType_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestValueTypeAsync_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = + new TestValueType() + { + StringField = "ABC", + Int32ArrayField = new int[] { 1, 2, 3 }, + DictionaryField = +#if !UNITY + new Dictionary() +#else + new Dictionary( AotHelper.GetEqualityComparer() ) +#endif // !UNITY + { { 1, 1 } } + }; + await serializer.PackAsync( stream, value ); + stream.Position = 0; + var result = await serializer.UnpackAsync( stream ); + Assert.That( result.StringField, Is.EqualTo( value.StringField ) ); + Assert.That( result.Int32ArrayField, Is.EqualTo( value.Int32ArrayField ) ); + Assert.That( result.DictionaryField, Is.EqualTo( value.DictionaryField ) ); + } + } +#endif // FEATURE_TAP + + // Issue81 + [Test] + public void TestMultiDimensionalArray() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } + +#if FEATURE_TAP + // Issue81 + [Test] + public async Task TestMultiDimensionalArrayAsync() + { + var array = new int [ 2, 2 ]; + array[ 0, 0 ] = 0; + array[ 0, 1 ] = 1; + array[ 1, 0 ] = 10; + array[ 1, 1 ] = 11; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, array ); + stream.Position = 0; + + var result = await serializer.UnpackAsync( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 1, 1 ], Is.EqualTo( 11 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestMultiDimensionalArrayComprex() + { + var array = new int [ 2, 3, 4 ]; + array[ 0, 0, 0 ] = 0; + array[ 0, 0, 1 ] = 1; + array[ 0, 0, 2 ] = 2; + array[ 0, 0, 3 ] = 3; + array[ 0, 1, 0 ] = 10; + array[ 0, 1, 1 ] = 11; + array[ 0, 1, 2 ] = 12; + array[ 0, 1, 3 ] = 13; + array[ 0, 2, 0 ] = 20; + array[ 0, 2, 1 ] = 21; + array[ 0, 2, 2 ] = 22; + array[ 0, 2, 3 ] = 23; + array[ 1, 0, 0 ] = 100; + array[ 1, 0, 1 ] = 101; + array[ 1, 0, 2 ] = 102; + array[ 1, 0, 3 ] = 103; + array[ 1, 1, 0 ] = 110; + array[ 1, 1, 1 ] = 111; + array[ 1, 1, 2 ] = 112; + array[ 1, 1, 3 ] = 113; + array[ 1, 2, 0 ] = 120; + array[ 1, 2, 1 ] = 121; + array[ 1, 2, 2 ] = 122; + array[ 1, 2, 3 ] = 123; + + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf() ); + Assert.That( result.Rank, Is.EqualTo( 3 ) ); + Assert.That( result.Length, Is.EqualTo( 24 ) ); + Assert.That( result.GetLength( 0 ), Is.EqualTo( 2 ) ); + Assert.That( result.GetLength( 1 ), Is.EqualTo( 3 ) ); + Assert.That( result.GetLength( 2 ), Is.EqualTo( 4 ) ); + Assert.That( result[ 0, 0, 0 ], Is.EqualTo( 0 ) ); + Assert.That( result[ 0, 0, 1 ], Is.EqualTo( 1 ) ); + Assert.That( result[ 0, 0, 2 ], Is.EqualTo( 2 ) ); + Assert.That( result[ 0, 0, 3 ], Is.EqualTo( 3 ) ); + Assert.That( result[ 0, 1, 0 ], Is.EqualTo( 10 ) ); + Assert.That( result[ 0, 1, 1 ], Is.EqualTo( 11 ) ); + Assert.That( result[ 0, 1, 2 ], Is.EqualTo( 12 ) ); + Assert.That( result[ 0, 1, 3 ], Is.EqualTo( 13 ) ); + Assert.That( result[ 0, 2, 0 ], Is.EqualTo( 20 ) ); + Assert.That( result[ 0, 2, 1 ], Is.EqualTo( 21 ) ); + Assert.That( result[ 0, 2, 2 ], Is.EqualTo( 22 ) ); + Assert.That( result[ 0, 2, 3 ], Is.EqualTo( 23 ) ); + Assert.That( result[ 1, 0, 0 ], Is.EqualTo( 100 ) ); + Assert.That( result[ 1, 0, 1 ], Is.EqualTo( 101 ) ); + Assert.That( result[ 1, 0, 2 ], Is.EqualTo( 102 ) ); + Assert.That( result[ 1, 0, 3 ], Is.EqualTo( 103 ) ); + Assert.That( result[ 1, 1, 0 ], Is.EqualTo( 110 ) ); + Assert.That( result[ 1, 1, 1 ], Is.EqualTo( 111 ) ); + Assert.That( result[ 1, 1, 2 ], Is.EqualTo( 112 ) ); + Assert.That( result[ 1, 1, 3 ], Is.EqualTo( 113 ) ); + Assert.That( result[ 1, 2, 0 ], Is.EqualTo( 120 ) ); + Assert.That( result[ 1, 2, 1 ], Is.EqualTo( 121 ) ); + Assert.That( result[ 1, 2, 2 ], Is.EqualTo( 122 ) ); + Assert.That( result[ 1, 2, 3 ], Is.EqualTo( 123 ) ); + } + } + + [Test] +#if UNITY_WORKAROUND + [Ignore( "Unity's Array.SetValue is buggy for non-SZArray" )] +#endif // UNITY_WORKAROUND + public void TestNonZeroBoundArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2 }, new [] { 1 } ); + array.SetValue( 1, 1 ); + array.SetValue( 2, 2 ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); +#if !SILVERLIGHT + Assert.That( result, Is.TypeOf( array.GetType() ) ); +#else + // Silverlight does not support lower bound settings, so sz array will return. + Assert.That( result, Is.TypeOf() ); +#endif // !SILVERLIGHT + Assert.That( result.Rank, Is.EqualTo( 1 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 2 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 3 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetValue( 2 ), Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestNonZeroBoundMultidimensionalArray() + { + var array = Array.CreateInstance( typeof( int ), new [] { 2, 2 }, new [] { 1, 1 } ); + array.SetValue( 11, new [] { 1, 1 } ); + array.SetValue( 12, new [] { 1, 2 } ); + array.SetValue( 21, new [] { 2, 1 } ); + array.SetValue( 22, new [] { 2, 2 } ); + + var serializer = GetSerializationContext().GetSerializer( array.GetType() ); + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, array ); + stream.Position = 0; + + var result = ( Array )serializer.Unpack( stream ); + Assert.That( result, Is.TypeOf( array.GetType() ) ); + Assert.That( result.Rank, Is.EqualTo( 2 ) ); +#if !SILVERLIGHT + Assert.That( result.Length, Is.EqualTo( 4 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 1 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 1 ) ); +#else + // Silverlight does not support lower bound settings, so lowerBound + length will be set. + Assert.That( result.Length, Is.EqualTo( 9 ) ); + Assert.That( result.GetLowerBound( 0 ), Is.EqualTo( 0 ) ); + Assert.That( result.GetLowerBound( 1 ), Is.EqualTo( 0 ) ); +#endif // !SILVERLIGHT + Assert.That( result.GetValue( 1, 1 ), Is.EqualTo( 11 ) ); + Assert.That( result.GetValue( 1, 2 ), Is.EqualTo( 12 ) ); + Assert.That( result.GetValue( 2, 1 ), Is.EqualTo( 21 ) ); + Assert.That( result.GetValue( 2, 2 ), Is.EqualTo( 22 ) ); + } + } + + + [Test] + public void TestHasInitOnlyFieldWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasReadWriteFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithDefaultConstructor_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasGetOnlyPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithDefaultConstructor(); + value.InitializeMember( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithRecordConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithBothConstructor( "123" ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( "123" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and was nothing to be set. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasPublicSetterPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasReadWriteAppendableCollectionFieldWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithDefaultConstructor(); + value.InitializeMember( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithDefaultConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithRecordConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Set null via deserialization constructor. + Assert.That( result.Member, Is.Null ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithRecordConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithBothConstructor( new List{ "123" } ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // check the member value deserialized properly. + Assert.That( result.Member, Is.EqualTo( new List{ "123" } ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + var value = new HasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor( -1 /* dummy */ ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + Assert.That( result.WasProperConstructorUsed() ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeserializeWithMissingMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 } ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + // Default constructor was called and nothing to be set. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstructor_DeseriaizeWithExtraMember_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + + using ( var stream = new MemoryStream() ) + { + using ( var packer = Packer.Create( stream, false ) ) + { + packer.PackMapHeader( 2 ); + packer.PackString( "Member" ); + packer.PackArrayHeader( 1 ); + packer.PackString( "123" ); + packer.PackString( "Extra" ); + packer.PackNull(); + } + + stream.Position = 0; + var result = serializer.Unpack( stream ); + // dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type. + Assert.That( result.Member, Is.EqualTo( new List() ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherNameConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherNameConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( 0 ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAnotherTypeConstrtor_DifferIsSetDefault() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithAnotherTypeConstructor( 1, 2 ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ReadOnlySame, Is.EqualTo( 1 ) ); + Assert.That( result.ReadOnlyDiffer, Is.EqualTo( "0" ) ); + } + } + + [Test] + public void TestConstrutorDeserializationWithAttribute_Preferred() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new WithConstructorAttribute( 1, false ); + Assert.That( value.IsAttributePreferred, Is.False ); + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1 ) ); + Assert.That( result.IsAttributePreferred, Is.True ); + } + } + + [Test] + public void TestConstrutorDeserializationWithMultipleAttributes_Fail() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + + [Test] + public void TestOptionalConstructorByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( byte )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorSByte_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( sbyte )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( short )-2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt16_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ushort )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2 ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt32_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( uint )2 ) ); + } + } + + [Test] + public void TestOptionalConstructorInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( -2L ) ); + } + } + + [Test] + public void TestOptionalConstructorUInt64_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( ( ulong )2L ) ); + } + } + + [Test] + public void TestOptionalConstructorSingle_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2f ) ); + } + } + + [Test] + public void TestOptionalConstructorDouble_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2 ) ); + } + } + + [Test] + public void TestOptionalConstructorDecimal_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 1.2m ) ); + } + } + + [Test] + public void TestOptionalConstructorBoolean_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( true ) ); + } + } + + [Test] + public void TestOptionalConstructorChar_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( 'A' ) ); + } + } + + [Test] + public void TestOptionalConstructorString_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + stream.Write( new byte[]{ 0x80 }, 0, 1 ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Value, Is.EqualTo( "ABC" ) ); + } + } + + [Test] + public void TestCollection_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new Collection() { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIListValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new ListValueType( 3 ) { 1, 2, 3 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EqualTo( new int[] { 1, 2, 3 } ) ); + } + } + + [Test] + public void TestIDictionaryValueType_Success() + { + var serializer = this.CreateTarget>( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new DictionaryValueType( 3 ) { { 1, 1 }, { 2, 2 }, { 3, 3 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.ToArray(), Is.EquivalentTo( Enumerable.Range( 1, 3 ).Select( i => new KeyValuePair( i, i ) ).ToArray() ) ); + } + } + + [Test] + public void TestPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.Unpack( stream ), "Round-trip should not be succeeded." ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + + [Test] + public void TestUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackable_PackToMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncPackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + Assert.Throws( () => serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(), "Round-trip should not be succeeded." ); + } + } + + [Test] + public void TestAsyncUnpackable_UnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new JustAsyncUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( JustAsyncUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new PackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( PackableUnpackable.Dummy ) ); + +#if FEATURE_TAP + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); +#endif // FEATURE_TAP + } + } + +#if FEATURE_TAP + + [Test] + public void TestAsyncPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new AsyncPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x81, 0xAA, 0x49, 0x6E, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6C, 0x64, 0x1 } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field, Is.EqualTo( value.Int32Field ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( AsyncPackableUnpackable.Dummy ) ); + } + } + + [Test] + public void TestFullPackableUnpackable_PackToMessageAndUnpackFromMessageUsed() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new FullPackableUnpackable(); + value.Int32Field = 1; + serializer.Pack( stream, value ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + + stream.SetLength( 0 ); + serializer.PackAsync( stream, value, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { 0x91, 0xA1, ( byte )'1' } ) ); + stream.Position = 0; + result = serializer.UnpackAsync( stream, CancellationToken.None ).GetAwaiter().GetResult(); + Assert.That( result.Int32Field.ToString(), Is.EqualTo( FullPackableUnpackable.Dummy ) ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestBinary_ClassicContext() + { + var context = NewSerializationContext( PackerCompatibilityOptions.Classic ); + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.MinimumFixedRaw + 1, 1 } ) ); + } + } + + [Test] + public void TestBinary_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, new byte[] { 1 } ); + Assert.That( stream.ToArray(), Is.EqualTo( new byte[] { MessagePackCode.Bin8, 1, 1 } ) ); + } + } + [Test] + public void TestExt_ClassicContext() + { + var context = NewSerializationContext( SerializationContext.CreateClassicContext().CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_DefaultContext() + { + var context = NewSerializationContext( SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestExt_ContextWithPackerCompatilibyOptionsNone() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.Serializers.Register( new CustomDateTimeSerealizer() ); + context.CompatibilityOptions.PackerCompatibilityOptions = PackerCompatibilityOptions.None; + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var date = DateTime.UtcNow; + serializer.Pack( stream, date ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.ToString( "yyyyMMddHHmmssfff" ), Is.EqualTo( date.ToString( "yyyyMMddHHmmssfff" ) ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_Default_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_WithoutRegistration_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Unregister( typeof( IList<> ) ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistration_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList<> ), typeof( Collection<> ) ); + var serializer = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + } + + [Test] + public void TestAbstractTypes_KnownCollections_ExplicitRegistrationForSpecific_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( Collection ) ); + var serializer1 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractInt32Collection() { Collection = new[] { 1, 2 } }; + serializer1.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer1.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( 2 ) ); + } + + // check other types are not affected + var serializer2 = CreateTarget( context ); + + using ( var stream = new MemoryStream() ) + { + var value = new WithAbstractStringCollection() { Collection = new[] { "1", "2" } }; + serializer2.Pack( stream, value ); + stream.Position = 0; + var unpacked = serializer2.Unpack( stream ); + Assert.That( unpacked.Collection, Is.Not.Null.And.InstanceOf>() ); + Assert.That( unpacked.Collection[ 0 ], Is.EqualTo( "1" ) ); + Assert.That( unpacked.Collection[ 1 ], Is.EqualTo( "2" ) ); + } + } + + [Test] + public void TestAbstractTypes_NotACollection_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + Assert.Throws( () => DoKnownCollectionTest( context ) ); + } + +#if !NETFX_35 && !UNITY + [Test] + public void TestReadOnlyCollectionInterfaceDefault() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + null + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + null + ); + } + + [Test] + public void TestReadOnlyCollectionInterfaceExplicit() + { + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyCollection ), typeof( AppendableReadOnlyCollection ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x91, 0x1 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.First(), Is.EqualTo( 1 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyList ), typeof( AppendableReadOnlyList ) ) + ); + TestCollectionInterfaceCore>( + new byte[] { 0x81, 0x1, 0x2 }, + result => + { + Assert.That( result, Is.InstanceOf>() ); + Assert.That( result.Count, Is.EqualTo( 1 ) ); + Assert.That( result.ContainsKey( 1 ) ); + Assert.That( result[ 1 ], Is.EqualTo( 2 ) ); + }, + context => context.DefaultCollectionTypes.Register( typeof( IReadOnlyDictionary ), typeof( AppendableReadOnlyDictionary ) ) + ); + } + + private static void TestCollectionInterfaceCore( byte[] data, Action assertion, Action registration ) + { + using ( var buffer = new MemoryStream(data) ) + { + var serializer = MessagePackSerializer.Get( NewSerializationContext( PackerCompatibilityOptions.None ) ); + var result = serializer.Unpack( buffer ); + assertion( result ); + } + } +#endif // !NETFX_35 && !UNITY + + private void TestCore( T value, Func unpacking, Func comparer ) + { + TestCore( value, unpacking, comparer, null ); + } + + private void TestCore( T value, Func unpacking, Func comparer, Action contextAdjuster ) + { + var safeComparer = comparer ?? EqualityComparer.Default.Equals; + var context = GetSerializationContext(); + if ( contextAdjuster != null ) + { + contextAdjuster( context ); + } + + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T intermediate = unpacking( buffer ); + Assert.That( safeComparer( intermediate, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, intermediate ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + Assert.That( safeComparer( unpacked, value ), "Expected:{1}{0}Actual :{2}", Environment.NewLine, value, unpacked ); + } + } + + private void TestCoreWithVerify( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#if FEATURE_TAP + + private async Task TestCoreWithVerifyAsync( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, value ); + buffer.Position = 0; + T unpacked = await target.UnpackAsync( buffer ); + buffer.Position = 0; + unpacked.Verify( buffer ); + } + } + +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_Plain() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, hasEnumerable ); + buffer.Position = 0; + var result = target.Unpack( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } + +#if FEATURE_TAP + [Test] + public async Task TestIssue25_PlainAsync() + { + var hasEnumerable = new HasEnumerable { Numbers = new[] { 1, 2 } }; + var target = CreateTarget( GetSerializationContext() ); + + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, hasEnumerable ); + buffer.Position = 0; + var result = await target.UnpackAsync( buffer ); + var resultNumbers = result.Numbers.ToArray(); + Assert.That( resultNumbers.Length, Is.EqualTo( 2 ) ); + Assert.That( resultNumbers[ 0 ], Is.EqualTo( 1 ) ); + Assert.That( resultNumbers[ 1 ], Is.EqualTo( 2 ) ); + } + } +#endif // FEATURE_TAP + + [Test] + public void TestIssue25_SelfComposite() + { + SerializationContext serializationContext = + SerializationContext.Default; + try + { + + serializationContext.Serializers.Register( new PersonSerializer() ); + serializationContext.Serializers.Register( new ChildrenSerializer() ); + + object[] array = new object[] { new Person { Name = "Joe" }, 3 }; + + MessagePackSerializer context = + serializationContext.GetSerializer(); + + byte[] packed = context.PackSingleObject( array ); + object[] unpacked = context.UnpackSingleObject( packed ); + + Assert.That( unpacked.Length, Is.EqualTo( 2 ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Name" ].AsString(), Is.EqualTo( "Joe" ) ); + Assert.That( ( ( MessagePackObject )unpacked[ 0 ] ).AsDictionary()[ "Children" ].IsNil ); + Assert.That( ( MessagePackObject )unpacked[ 1 ], Is.EqualTo( new MessagePackObject( 3 ) ) ); + } + finally + { + SerializationContext.Default = new SerializationContext(); + } + } + +#region -- ReadOnly / Private Members -- + + // ReSharper disable UnusedMember.Local + // member names + private const string PublicProperty = "PublicProperty"; + private const string PublicReadOnlyProperty = "PublicReadOnlyProperty"; + private const string NonPublicProperty = "NonPublicProperty"; + private const string PublicPropertyPlain = "PublicPropertyPlain"; + private const string PublicReadOnlyPropertyPlain = "PublicReadOnlyPropertyPlain"; + private const string NonPublicPropertyPlain = "NonPublicPropertyPlain"; + private const string CollectionReadOnlyProperty = "CollectionReadOnlyProperty"; + private const string NonPublicCollectionProperty = "NonPublicCollectionProperty"; + private const string NonPublicCollectionField = "NonPublicCollectionField"; + private const string NonPublicCollectionReadOnlyProperty = "NonPublicCollectionReadOnlyProperty"; + private const string NonPublicCollectionReadOnlyField = "NonPublicCollectionReadOnlyField"; + private const string NonPublicDictionaryProperty = "NonPublicDictionaryProperty"; + private const string NonPublicDictionaryField = "NonPublicDictionaryField"; + private const string NonPublicDictionaryReadOnlyProperty = "NonPublicDictionaryReadOnlyProperty"; + private const string NonPublicDictionaryReadOnlyField = "NonPublicDictionaryReadOnlyField"; + private const string NonPublicIDictionaryProperty = "NonPublicIDictionaryProperty"; + private const string NonPublicIDictionaryField = "NonPublicIDictionaryField"; + private const string NonPublicIDictionaryReadOnlyProperty = "NonPublicIDictionaryReadOnlyProperty"; + private const string NonPublicIDictionaryReadOnlyField = "NonPublicIDictionaryReadOnlyField"; + private const string PublicField = "PublicField"; + private const string PublicReadOnlyField = "PublicReadOnlyField"; + private const string NonPublicField = "NonPublicField"; + private const string PublicFieldPlain = "PublicFieldPlain"; + private const string PublicReadOnlyFieldPlain = "PublicReadOnlyFieldPlain"; + private const string NonPublicFieldPlain = "NonPublicFieldPlain"; +#if !NETFX_CORE && !SILVERLIGHT + private const string NonSerializedPublicField = "NonSerializedPublicField"; + private const string NonSerializedPublicReadOnlyField = "NonSerializedPublicReadOnlyField"; + private const string NonSerializedNonPublicField = "NonSerializedNonPublicField"; + private const string NonSerializedPublicFieldPlain = "NonSerializedPublicFieldPlain"; + private const string NonSerializedPublicReadOnlyFieldPlain = "NonSerializedPublicReadOnlyFieldPlain"; + private const string NonSerializedNonPublicFieldPlain = "NonSerializedNonPublicFieldPlain"; +#endif // !NETFX_CORE && !SILVERLIGHT + // ReSharper restore UnusedMember.Local + + [Test] + public void TestNonPublicWritableMember_PlainOldCliClass() + { + var target = new PlainClass(); + target.InitializeCollectionMembers(); + TestNonPublicWritableMemberCore( target, PublicProperty, PublicField, CollectionReadOnlyProperty ); + } + + [Test] + public void TestNonPublicWritableMember_MessagePackMember() + { + var target = new AnnotatedClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + [Test] + public void TestNonPublicWritableMember_DataContract() + { + // includes issue33 + var target = new DataMamberClass(); + target.InitializeCollectionMembers(); +#if !NETFX_CORE && !SILVERLIGHT + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, NonSerializedPublicField, NonSerializedNonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#else + TestNonPublicWritableMemberCore( + target, PublicProperty, NonPublicProperty, PublicField, NonPublicField, CollectionReadOnlyProperty, + NonPublicCollectionProperty, NonPublicCollectionField, NonPublicCollectionReadOnlyProperty, NonPublicCollectionReadOnlyField, + NonPublicDictionaryProperty, NonPublicDictionaryField, NonPublicDictionaryReadOnlyProperty, NonPublicDictionaryReadOnlyField, + NonPublicIDictionaryProperty, NonPublicIDictionaryField, NonPublicIDictionaryReadOnlyProperty, NonPublicIDictionaryReadOnlyField + ); +#endif // !NETFX_CORE && !SILVERLIGHT + } + + private void TestNonPublicWritableMemberCore( T original, params string[] expectedMemberNames ) + { + var serializer = CreateTarget( GetSerializationContext() ); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, original ); + buffer.Position = 0; + var actual = serializer.Unpack( buffer ); + + foreach ( var memberName in expectedMemberNames ) + { + Func getter = null; +#if !NETFX_CORE + var property = typeof( T ).GetProperty( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var property = typeof( T ).GetRuntimeProperties().SingleOrDefault( p => p.Name == memberName ); +#endif + if ( property != null ) + { +#if !UNITY + getter = obj => property.GetValue( obj, null ); +#else + getter = obj => property.GetGetMethod( true ).InvokePreservingExceptionType( obj ); +#endif // !UNITY + } + else + { +#if !NETFX_CORE + var field = typeof( T ).GetField( memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic ); +#else + var field = typeof( T ).GetRuntimeFields().SingleOrDefault( f => f.Name == memberName ); +#endif + if ( field == null ) + { + Assert.Fail( memberName + " is not found." ); + } + + getter = obj => field.GetValue( obj ); + } + + // Naive, but OK + if ( memberName.Contains( "IDictionary" ) ) + { + Func> toDictionary = + hashTable => + ( ( System.Collections.IEnumerable )hashTable ) + .OfType() + .ToDictionary( + de => de.Key.ToString(), + de => + ( de.Value is MessagePackObject ) + ? ( int )( MessagePackObject )de.Value + : ( int )de.Value + ); + + Assert.That( toDictionary( getter( actual ) ), Is.EqualTo( toDictionary( getter( original ) ) ), typeof(T) + "." + memberName ); + } + else + { + Assert.That( getter( actual ), Is.EqualTo( getter( original ) ), typeof(T) + "." + memberName ); + } + } + } + } + +#endregion -- ReadOnly / Private Members -- + +#region -- IPackabke/IUnpackable -- + + // Issue 150 + [Test] + public void TestExplicitlyImplementedPackableUnpackable() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new PackableUnpackableImplementedExplictly(); + obj.Data = "ABC"; + + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + Assert.That( actual.Data, Is.EqualTo( PackableUnpackableImplementedExplictly.UnpackingPrefix + PackableUnpackableImplementedExplictly.PackingPrefix + obj.Data ) ); + } + } + + // Issue153 + + + [Test] + public void TestEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericEnumerable_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericCollection_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericList_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Packable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_Unpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_NotAware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + + + [Test] + public void TestNonGenericDictionary_PackableUnpackable_Aware() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = target.Unpack( buffer ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer(); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericEnumerable_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericEnumerable(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericEnumerable ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericCollection_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericCollection(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericCollection ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x90 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( UnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // As-is + Assert.That( data.AsList().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericList_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericList(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedCollection( typeof( PackableUnpackableNonGenericList ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + // Always 1 because of IPackable + Assert.That( data.AsList().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Packable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + // Regular UnpackFrom cannot recognize stream generated by our IPackable, so emit standard value here. + buffer.SetLength( 0 ); + buffer.Write( new byte[] { 0x80 } ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Always empty because of our stream rewriting. + Assert.That( actual.GetValues(), Is.EqualTo( new int[ 0 ] ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_Unpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new UnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( UnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // As-is + Assert.That( data.AsDictionary().Count, Is.EqualTo( 3 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_NotAwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + context.CompatibilityOptions.IgnorePackabilityForCollection = true; + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP +#if FEATURE_TAP + + [Test] + public async Task TestNonGenericDictionary_PackableUnpackable_AwareAsync() + { + var context = GetSerializationContext(); + // Check compatibility + Assert.That( context.CompatibilityOptions.IgnorePackabilityForCollection, Is.False ); + var obj = new PackableUnpackableNonGenericDictionary(); + obj.Initialize( 1, 2, 3 ); + var target = context.GetSerializer( PolymorphismSchema.ForContextSpecifiedDictionary( typeof( PackableUnpackableNonGenericDictionary ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ), PolymorphismSchema.ForPolymorphicObject( typeof( object ) ) ) ); + using ( var buffer = new MemoryStream() ) + { + await target.PackAsync( buffer, obj ).ConfigureAwait( false ); + buffer.Position = 0; + var data = Unpacking.UnpackObject( buffer ); + Assert.That( data.IsDictionary ); + // Always 1 because of IPackable + Assert.That( data.AsDictionary().Count, Is.EqualTo( 1 ) ); + buffer.Position = 0; + + var actual = await target.UnpackAsync( buffer ).ConfigureAwait( false ); + // Capacitized constructor should be called with 0. + Assert.That( actual.Capacity, Is.EqualTo( 0 ) ); + + // Always two zeros because of IUnpackable + Assert.That( actual.GetValues(), Is.EqualTo( new [] { 0, 0 } ) ); + } + + } + +#endif // FEATURE_TAP + +#endregion -- IPackabke/IUnpackable -- + +#region -- Exclusion -- + + private void TestIgnoreCore( Action setter, Action assertion ) + where T : new() + { + var target = GetSerializationContext().GetSerializer(); + var obj = new T(); + setter( obj ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, obj ); + buffer.Position = 0; + var actual = target.Unpack( buffer ); + assertion( obj, actual ); + } + } + + private void TestIgnoreCore() + where TException : Exception + { + Assert.Throws( () => GetSerializationContext().GetSerializer() ); + } + + [Test] + public void TestIgnore_Normal() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotIgnored = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotIgnored, Is.EqualTo( expected.NotIgnored ) ); + } + ); + } + + [Test] + public void TestIgnore_ExcludedOnly() + { + TestIgnoreCore(); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionMixed() + { + TestIgnoreCore( + target => { + target.IgnoredField = "ABC"; + target.IgnoredProperty = "ABC"; + target.NotMarked = "ABC"; + target.Marked = "ABC"; + }, + ( expected, actual ) => + { + Assert.That( actual.IgnoredField, Is.Null ); + Assert.That( actual.IgnoredProperty, Is.Null ); + Assert.That( actual.NotMarked, Is.Null ); + Assert.That( actual.Marked, Is.EqualTo( expected.Marked ) ); + } + ); + } + + [Test] + public void TestIgnore_ExclusionAndInclusionSimulatously() + { + TestIgnoreCore(); + } + + + public class OnlyExcluded + { + [MessagePackIgnore] + public string Ignored { get; set; } + } + + public class Excluded + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotIgnored { get; set; } + } + + public class ExclusionAndInclusionMixed + { + [MessagePackIgnore] + public string IgnoredField; + + [MessagePackIgnore] + public string IgnoredProperty { get; set; } + + public string NotMarked { get; set; } + + [MessagePackMember( 0 )] + public string Marked { get; set; } + } + + public class ExclusionAndInclusionSimulatously + { + [MessagePackMember( 0 )] + public string Marked { get; set; } + + [MessagePackIgnore] + [MessagePackMember( 1 )] + public string DoubleMarked { get; set; } + } + +#endregion -- Exclusion -- + +#if !UNITY + // Mono 2.7.3 AOT fails when these classes are used... + // Issue 119 +#region -- Generic -- + + [Test] + public void TestGenericDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericValueClass + { + GenericField = 1, + GenericProperty = 2 + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericReferenceClass + { + GenericField = "1", + GenericProperty = "2" + }; + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Value_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordValueClass( 1, 2 ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + + [Test] + public void TestGenericRecordDerived_Reference_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = + new GenericRecordReferenceClass( "1", "2" ); + var serializer = context.GetSerializer(); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.Not.Null ); + Assert.That( result.GenericField, Is.EqualTo( target.GenericField ) ); + Assert.That( result.GenericProperty, Is.EqualTo( target.GenericProperty ) ); + } + } + +#endregion -- Generic -- + +#region -- Nullable -- + // Issue #121 + + [Test] + public void TestNullable_Primitive_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DateTime.UtcNow.Millisecond; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Primitive_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( int? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = TimeSpan.FromSeconds( DateTime.UtcNow.Millisecond ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Complex_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( TimeSpan? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_NonNull_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = DayOfWeek.Monday; + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + + [Test] + public void TestNullable_Enum_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = default( DayOfWeek? ); + var serializer = MessagePackSerializer.CreateInternal( context, null ); + + using( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } +#endregion -- Nullable -- + +#endif // !UNITY + + + // Related to issue #62 -- internal types handling is not consistent at first. + + [Test] + public void TestNonPublicType_Plain_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_MessagePackMember_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + [Test] + public void TestNonPublicType_DataContract_Failed() + { + Assert.Throws( () => this.CreateTarget( GetSerializationContext() ) ); + } + + // Issue 170 + [Test] + public void TestStaticMembersDoNotCausePrepareError() + { + MessagePackSerializer.Get().PackSingleObject( new ClassHasStaticField() ); + } + +#pragma warning disable 649 + internal class NonPublic + { + public int Value; + } + + internal class NonPublicWithMessagePackMember + { + [MessagePackMember( 0 )] + public int Value; + } + + [DataContract] + internal class NonPublicWithDataContract + { + [DataMember] + public int Value; + } +#pragma warning restore 649 + + // issue #63 + [Test] + public void TestManyMembers() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + var target = new WithManyMembers(); + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( target ) ); + } + } + +#pragma warning disable 659 + public class WithManyMembers + { + private readonly int[] _backingField = Enumerable.Range( 0, SByte.MaxValue + 2 ).ToArray(); + + public int Member0 + { + get { return this._backingField[ 0 ]; } + set { this._backingField[ 0 ] = value; } + } + public int Member1 + { + get { return this._backingField[ 1 ]; } + set { this._backingField[ 1 ] = value; } + } + public int Member2 + { + get { return this._backingField[ 2 ]; } + set { this._backingField[ 2 ] = value; } + } + public int Member3 + { + get { return this._backingField[ 3 ]; } + set { this._backingField[ 3 ] = value; } + } + public int Member4 + { + get { return this._backingField[ 4 ]; } + set { this._backingField[ 4 ] = value; } + } + public int Member5 + { + get { return this._backingField[ 5 ]; } + set { this._backingField[ 5 ] = value; } + } + public int Member6 + { + get { return this._backingField[ 6 ]; } + set { this._backingField[ 6 ] = value; } + } + public int Member7 + { + get { return this._backingField[ 7 ]; } + set { this._backingField[ 7 ] = value; } + } + public int Member8 + { + get { return this._backingField[ 8 ]; } + set { this._backingField[ 8 ] = value; } + } + public int Member9 + { + get { return this._backingField[ 9 ]; } + set { this._backingField[ 9 ] = value; } + } + public int Member10 + { + get { return this._backingField[ 10 ]; } + set { this._backingField[ 10 ] = value; } + } + public int Member11 + { + get { return this._backingField[ 11 ]; } + set { this._backingField[ 11 ] = value; } + } + public int Member12 + { + get { return this._backingField[ 12 ]; } + set { this._backingField[ 12 ] = value; } + } + public int Member13 + { + get { return this._backingField[ 13 ]; } + set { this._backingField[ 13 ] = value; } + } + public int Member14 + { + get { return this._backingField[ 14 ]; } + set { this._backingField[ 14 ] = value; } + } + public int Member15 + { + get { return this._backingField[ 15 ]; } + set { this._backingField[ 15 ] = value; } + } + public int Member16 + { + get { return this._backingField[ 16 ]; } + set { this._backingField[ 16 ] = value; } + } + public int Member17 + { + get { return this._backingField[ 17 ]; } + set { this._backingField[ 17 ] = value; } + } + public int Member18 + { + get { return this._backingField[ 18 ]; } + set { this._backingField[ 18 ] = value; } + } + public int Member19 + { + get { return this._backingField[ 19 ]; } + set { this._backingField[ 19 ] = value; } + } + public int Member20 + { + get { return this._backingField[ 20 ]; } + set { this._backingField[ 20 ] = value; } + } + public int Member21 + { + get { return this._backingField[ 21 ]; } + set { this._backingField[ 21 ] = value; } + } + public int Member22 + { + get { return this._backingField[ 22 ]; } + set { this._backingField[ 22 ] = value; } + } + public int Member23 + { + get { return this._backingField[ 23 ]; } + set { this._backingField[ 23 ] = value; } + } + public int Member24 + { + get { return this._backingField[ 24 ]; } + set { this._backingField[ 24 ] = value; } + } + public int Member25 + { + get { return this._backingField[ 25 ]; } + set { this._backingField[ 25 ] = value; } + } + public int Member26 + { + get { return this._backingField[ 26 ]; } + set { this._backingField[ 26 ] = value; } + } + public int Member27 + { + get { return this._backingField[ 27 ]; } + set { this._backingField[ 27 ] = value; } + } + public int Member28 + { + get { return this._backingField[ 28 ]; } + set { this._backingField[ 28 ] = value; } + } + public int Member29 + { + get { return this._backingField[ 29 ]; } + set { this._backingField[ 29 ] = value; } + } + public int Member30 + { + get { return this._backingField[ 30 ]; } + set { this._backingField[ 30 ] = value; } + } + public int Member31 + { + get { return this._backingField[ 31 ]; } + set { this._backingField[ 31 ] = value; } + } + public int Member32 + { + get { return this._backingField[ 32 ]; } + set { this._backingField[ 32 ] = value; } + } + public int Member33 + { + get { return this._backingField[ 33 ]; } + set { this._backingField[ 33 ] = value; } + } + public int Member34 + { + get { return this._backingField[ 34 ]; } + set { this._backingField[ 34 ] = value; } + } + public int Member35 + { + get { return this._backingField[ 35 ]; } + set { this._backingField[ 35 ] = value; } + } + public int Member36 + { + get { return this._backingField[ 36 ]; } + set { this._backingField[ 36 ] = value; } + } + public int Member37 + { + get { return this._backingField[ 37 ]; } + set { this._backingField[ 37 ] = value; } + } + public int Member38 + { + get { return this._backingField[ 38 ]; } + set { this._backingField[ 38 ] = value; } + } + public int Member39 + { + get { return this._backingField[ 39 ]; } + set { this._backingField[ 39 ] = value; } + } + public int Member40 + { + get { return this._backingField[ 40 ]; } + set { this._backingField[ 40 ] = value; } + } + public int Member41 + { + get { return this._backingField[ 41 ]; } + set { this._backingField[ 41 ] = value; } + } + public int Member42 + { + get { return this._backingField[ 42 ]; } + set { this._backingField[ 42 ] = value; } + } + public int Member43 + { + get { return this._backingField[ 43 ]; } + set { this._backingField[ 43 ] = value; } + } + public int Member44 + { + get { return this._backingField[ 44 ]; } + set { this._backingField[ 44 ] = value; } + } + public int Member45 + { + get { return this._backingField[ 45 ]; } + set { this._backingField[ 45 ] = value; } + } + public int Member46 + { + get { return this._backingField[ 46 ]; } + set { this._backingField[ 46 ] = value; } + } + public int Member47 + { + get { return this._backingField[ 47 ]; } + set { this._backingField[ 47 ] = value; } + } + public int Member48 + { + get { return this._backingField[ 48 ]; } + set { this._backingField[ 48 ] = value; } + } + public int Member49 + { + get { return this._backingField[ 49 ]; } + set { this._backingField[ 49 ] = value; } + } + public int Member50 + { + get { return this._backingField[ 50 ]; } + set { this._backingField[ 50 ] = value; } + } + public int Member51 + { + get { return this._backingField[ 51 ]; } + set { this._backingField[ 51 ] = value; } + } + public int Member52 + { + get { return this._backingField[ 52 ]; } + set { this._backingField[ 52 ] = value; } + } + public int Member53 + { + get { return this._backingField[ 53 ]; } + set { this._backingField[ 53 ] = value; } + } + public int Member54 + { + get { return this._backingField[ 54 ]; } + set { this._backingField[ 54 ] = value; } + } + public int Member55 + { + get { return this._backingField[ 55 ]; } + set { this._backingField[ 55 ] = value; } + } + public int Member56 + { + get { return this._backingField[ 56 ]; } + set { this._backingField[ 56 ] = value; } + } + public int Member57 + { + get { return this._backingField[ 57 ]; } + set { this._backingField[ 57 ] = value; } + } + public int Member58 + { + get { return this._backingField[ 58 ]; } + set { this._backingField[ 58 ] = value; } + } + public int Member59 + { + get { return this._backingField[ 59 ]; } + set { this._backingField[ 59 ] = value; } + } + public int Member60 + { + get { return this._backingField[ 60 ]; } + set { this._backingField[ 60 ] = value; } + } + public int Member61 + { + get { return this._backingField[ 61 ]; } + set { this._backingField[ 61 ] = value; } + } + public int Member62 + { + get { return this._backingField[ 62 ]; } + set { this._backingField[ 62 ] = value; } + } + public int Member63 + { + get { return this._backingField[ 63 ]; } + set { this._backingField[ 63 ] = value; } + } + public int Member64 + { + get { return this._backingField[ 64 ]; } + set { this._backingField[ 64 ] = value; } + } + public int Member65 + { + get { return this._backingField[ 65 ]; } + set { this._backingField[ 65 ] = value; } + } + public int Member66 + { + get { return this._backingField[ 66 ]; } + set { this._backingField[ 66 ] = value; } + } + public int Member67 + { + get { return this._backingField[ 67 ]; } + set { this._backingField[ 67 ] = value; } + } + public int Member68 + { + get { return this._backingField[ 68 ]; } + set { this._backingField[ 68 ] = value; } + } + public int Member69 + { + get { return this._backingField[ 69 ]; } + set { this._backingField[ 69 ] = value; } + } + public int Member70 + { + get { return this._backingField[ 70 ]; } + set { this._backingField[ 70 ] = value; } + } + public int Member71 + { + get { return this._backingField[ 71 ]; } + set { this._backingField[ 71 ] = value; } + } + public int Member72 + { + get { return this._backingField[ 72 ]; } + set { this._backingField[ 72 ] = value; } + } + public int Member73 + { + get { return this._backingField[ 73 ]; } + set { this._backingField[ 73 ] = value; } + } + public int Member74 + { + get { return this._backingField[ 74 ]; } + set { this._backingField[ 74 ] = value; } + } + public int Member75 + { + get { return this._backingField[ 75 ]; } + set { this._backingField[ 75 ] = value; } + } + public int Member76 + { + get { return this._backingField[ 76 ]; } + set { this._backingField[ 76 ] = value; } + } + public int Member77 + { + get { return this._backingField[ 77 ]; } + set { this._backingField[ 77 ] = value; } + } + public int Member78 + { + get { return this._backingField[ 78 ]; } + set { this._backingField[ 78 ] = value; } + } + public int Member79 + { + get { return this._backingField[ 79 ]; } + set { this._backingField[ 79 ] = value; } + } + public int Member80 + { + get { return this._backingField[ 80 ]; } + set { this._backingField[ 80 ] = value; } + } + public int Member81 + { + get { return this._backingField[ 81 ]; } + set { this._backingField[ 81 ] = value; } + } + public int Member82 + { + get { return this._backingField[ 82 ]; } + set { this._backingField[ 82 ] = value; } + } + public int Member83 + { + get { return this._backingField[ 83 ]; } + set { this._backingField[ 83 ] = value; } + } + public int Member84 + { + get { return this._backingField[ 84 ]; } + set { this._backingField[ 84 ] = value; } + } + public int Member85 + { + get { return this._backingField[ 85 ]; } + set { this._backingField[ 85 ] = value; } + } + public int Member86 + { + get { return this._backingField[ 86 ]; } + set { this._backingField[ 86 ] = value; } + } + public int Member87 + { + get { return this._backingField[ 87 ]; } + set { this._backingField[ 87 ] = value; } + } + public int Member88 + { + get { return this._backingField[ 88 ]; } + set { this._backingField[ 88 ] = value; } + } + public int Member89 + { + get { return this._backingField[ 89 ]; } + set { this._backingField[ 89 ] = value; } + } + public int Member90 + { + get { return this._backingField[ 90 ]; } + set { this._backingField[ 90 ] = value; } + } + public int Member91 + { + get { return this._backingField[ 91 ]; } + set { this._backingField[ 91 ] = value; } + } + public int Member92 + { + get { return this._backingField[ 92 ]; } + set { this._backingField[ 92 ] = value; } + } + public int Member93 + { + get { return this._backingField[ 93 ]; } + set { this._backingField[ 93 ] = value; } + } + public int Member94 + { + get { return this._backingField[ 94 ]; } + set { this._backingField[ 94 ] = value; } + } + public int Member95 + { + get { return this._backingField[ 95 ]; } + set { this._backingField[ 95 ] = value; } + } + public int Member96 + { + get { return this._backingField[ 96 ]; } + set { this._backingField[ 96 ] = value; } + } + public int Member97 + { + get { return this._backingField[ 97 ]; } + set { this._backingField[ 97 ] = value; } + } + public int Member98 + { + get { return this._backingField[ 98 ]; } + set { this._backingField[ 98 ] = value; } + } + public int Member99 + { + get { return this._backingField[ 99 ]; } + set { this._backingField[ 99 ] = value; } + } + public int Member100 + { + get { return this._backingField[ 100 ]; } + set { this._backingField[ 100 ] = value; } + } + public int Member101 + { + get { return this._backingField[ 101 ]; } + set { this._backingField[ 101 ] = value; } + } + public int Member102 + { + get { return this._backingField[ 102 ]; } + set { this._backingField[ 102 ] = value; } + } + public int Member103 + { + get { return this._backingField[ 103 ]; } + set { this._backingField[ 103 ] = value; } + } + public int Member104 + { + get { return this._backingField[ 104 ]; } + set { this._backingField[ 104 ] = value; } + } + public int Member105 + { + get { return this._backingField[ 105 ]; } + set { this._backingField[ 105 ] = value; } + } + public int Member106 + { + get { return this._backingField[ 106 ]; } + set { this._backingField[ 106 ] = value; } + } + public int Member107 + { + get { return this._backingField[ 107 ]; } + set { this._backingField[ 107 ] = value; } + } + public int Member108 + { + get { return this._backingField[ 108 ]; } + set { this._backingField[ 108 ] = value; } + } + public int Member109 + { + get { return this._backingField[ 109 ]; } + set { this._backingField[ 109 ] = value; } + } + public int Member110 + { + get { return this._backingField[ 110 ]; } + set { this._backingField[ 110 ] = value; } + } + public int Member111 + { + get { return this._backingField[ 111 ]; } + set { this._backingField[ 111 ] = value; } + } + public int Member112 + { + get { return this._backingField[ 112 ]; } + set { this._backingField[ 112 ] = value; } + } + public int Member113 + { + get { return this._backingField[ 113 ]; } + set { this._backingField[ 113 ] = value; } + } + public int Member114 + { + get { return this._backingField[ 114 ]; } + set { this._backingField[ 114 ] = value; } + } + public int Member115 + { + get { return this._backingField[ 115 ]; } + set { this._backingField[ 115 ] = value; } + } + public int Member116 + { + get { return this._backingField[ 116 ]; } + set { this._backingField[ 116 ] = value; } + } + public int Member117 + { + get { return this._backingField[ 117 ]; } + set { this._backingField[ 117 ] = value; } + } + public int Member118 + { + get { return this._backingField[ 118 ]; } + set { this._backingField[ 118 ] = value; } + } + public int Member119 + { + get { return this._backingField[ 119 ]; } + set { this._backingField[ 119 ] = value; } + } + public int Member120 + { + get { return this._backingField[ 120 ]; } + set { this._backingField[ 120 ] = value; } + } + public int Member121 + { + get { return this._backingField[ 121 ]; } + set { this._backingField[ 121 ] = value; } + } + public int Member122 + { + get { return this._backingField[ 122 ]; } + set { this._backingField[ 122 ] = value; } + } + public int Member123 + { + get { return this._backingField[ 123 ]; } + set { this._backingField[ 123 ] = value; } + } + public int Member124 + { + get { return this._backingField[ 124 ]; } + set { this._backingField[ 124 ] = value; } + } + public int Member125 + { + get { return this._backingField[ 125 ]; } + set { this._backingField[ 125 ] = value; } + } + public int Member126 + { + get { return this._backingField[ 126 ]; } + set { this._backingField[ 126 ] = value; } + } + public int Member127 + { + get { return this._backingField[ 127 ]; } + set { this._backingField[ 127 ] = value; } + } + public int Member128 + { + get { return this._backingField[ 128 ]; } + set { this._backingField[ 128 ] = value; } + } + + public override bool Equals( object obj ) + { + var other = obj as WithManyMembers; + if ( other == null ) + { + return false; + } + + return this._backingField == other._backingField || this._backingField.SequenceEqual( other._backingField ); + } + } +#pragma warning restore 659 + +#region issue #169 + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new GenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_Success() + { + var serializer = this.CreateTarget( GetSerializationContext() ); + using ( var stream = new MemoryStream() ) + { + var value = new NonGenericNonCollectionType { Property = 123 }; + serializer.Pack( stream, value ); + stream.Position = 0; + var result = serializer.Unpack( stream ); + Assert.That( result.Property, Is.EqualTo( 123 ) ); + } + } + + [Test] + public void TestImplementsGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + [Test] + public void TestImplementsNonGenericIEnumerableWithNoAdd_ProhibitEnumerableNonCollection_Fail() + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + Assert.Throws( () => this.CreateTarget( context ) ); + } + + // Issue #136 + [Test] + public void TestOmitNullEntryInDictionary() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" ); + TestOmitNullEntryInDictionaryCore( context, true, false ); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, false, false ); + } + +#if FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_Async() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.OmitNullEntry, Is.False, "default value" ); + TestOmitNullEntryInDictionaryCore( context, true, true ); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, false, true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_BackwordCompatibility() + { + SerializerDebugging.UseLegacyNullMapEntryHandling = true; + try + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, true, false ); + } + finally + { + SerializerDebugging.UseLegacyNullMapEntryHandling = false; + } + } + +#if FEATURE_TAP + + [Test] + public void TestOmitNullEntryInDictionary_BackwordCompatibility_Async() + { + SerializerDebugging.UseLegacyNullMapEntryHandling = true; + try + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.OmitNullEntry = true; + TestOmitNullEntryInDictionaryCore( context, true, true ); + } + finally + { + SerializerDebugging.UseLegacyNullMapEntryHandling = false; + } + } + +#endif // FEATURE_TAP + + private static void TestOmitNullEntryInDictionaryCore( SerializationContext context, bool shouldContainNulls, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = new SimpleClass { FirstProperty = "foo", SecondProperty = null }; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TASK + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TASK + serializer.Pack( buffer, obj ); +#if FEATURE_TASK + } +#endif // FEATURE_TASK + + buffer.Position = 0; + var map = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsDictionary(); + + Assert.That( map.ContainsKey( "FirstProperty" ) ); + Assert.That( map.ContainsKey( "SecondProperty" ), Is.EqualTo( shouldContainNulls ) ); + Assert.That( map.ContainsKey( "ThirdProperty" ), Is.EqualTo( shouldContainNulls ) ); + Assert.That( map.ContainsKey( "FourthProperty" ) ); + + Assert.That( map[ "FirstProperty" ].AsString(), Is.EqualTo( "foo" ) ); + if ( shouldContainNulls ) + { + Assert.That( map[ "SecondProperty" ].IsNil ); + Assert.That( map[ "ThirdProperty" ].IsNil ); + } + Assert.That( map[ "FourthProperty" ].AsInt32(), Is.EqualTo( 0 ) ); + + buffer.Position = 0; + + SimpleClass deserialized; +#if FEATURE_TASK + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TASK + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TASK + } +#endif // FEATURE_TASK + + Assert.That( deserialized.FirstProperty, Is.EqualTo( obj.FirstProperty) ); + Assert.That( deserialized.SecondProperty, Is.EqualTo( obj.SecondProperty) ); + Assert.That( deserialized.ThirdProperty, Is.EqualTo( obj.ThirdProperty) ); + Assert.That( deserialized.FourthProperty, Is.EqualTo( obj.FourthProperty) ); + } + } + + // Issue #175 + [Test] + public void TestDictionaryKeyTransformer_Default_AsIs() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" ); + TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Default_AsIs_Async() + { + var context = GetSerializationContext(); + Assert.That( context.DictionarySerlaizationOptions.KeyTransformer, Is.Null, "default value" ); + TestDictionaryKeyCore( context, "FirstProperty", "SecondProperty", "ThirdProperty", "FourthProperty", asIs: true, isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_LowerCamel() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel; + TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_LowerCamel_Async() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = DictionaryKeyTransformers.LowerCamel; + TestDictionaryKeyCore( context, "firstProperty", "secondProperty", "thirdProperty", "fourthProperty", asIs: false, isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Custom() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestDictionaryKeyTransformer_Custom_Async() + { + var context = GetSerializationContext(); + context.DictionarySerlaizationOptions.KeyTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestDictionaryKeyCore( context, "first-property", "second-property", "third-property", "fourth-property", asIs: false, isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestDictionaryKeyCore( SerializationContext context, string expectedKey1, string expectedKey2, string expectedKey3, string expectedKey4, bool asIs, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = new SimpleClass { FirstProperty = "foo", SecondProperty = "bar", ThirdProperty = 3, FourthProperty = 4 }; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var map = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsDictionary(); + + Assert.That( map.ContainsKey( "FirstProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "SecondProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "ThirdProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( "FourthProperty" ), Is.EqualTo( asIs ) ); + Assert.That( map.ContainsKey( expectedKey1 ) ); + Assert.That( map.ContainsKey( expectedKey2 ) ); + Assert.That( map.ContainsKey( expectedKey3 ) ); + Assert.That( map.ContainsKey( expectedKey4 ) ); + + buffer.Position = 0; + + SimpleClass deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized.FirstProperty, Is.EqualTo( obj.FirstProperty ) ); + Assert.That( deserialized.SecondProperty, Is.EqualTo( obj.SecondProperty ) ); + Assert.That( deserialized.ThirdProperty, Is.EqualTo( obj.ThirdProperty ) ); + Assert.That( deserialized.FourthProperty, Is.EqualTo( obj.FourthProperty ) ); + } + } +#endregion issue #169 + + #region -- Asymmetric -- + [Test] + public void TestAsymmetric_PackOnly_NoSettableNoConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableNoConstructorsForAsymmetricTest().Initialize( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoSettableMultipleConstructors_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoSettableMultipleConstructorsForAsymmetricTest( "A", 0 ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_NoDefaultConstructor_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new NoDefaultConstructorForAsymmetricTest( 'A' ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA5, ( byte )'V', ( byte )'a', ( byte )'l', ( byte )'u', ( byte )'e', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableDictionaryForAsymmetricTest( new KeyValuePair( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericList_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericListForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnconstructableNonGenericDictionary_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnconstructableNonGenericDictionaryForAsymmetricTest( new DictionaryEntry( "A", "A" ) ), + SerializerCapabilities.PackTo, + new byte[] { 0x81, 0xA1, ( byte )'A', 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericEnumerable_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericEnumerableForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + [Test] + public void TestAsymmetric_PackOnly_UnappendableNonGenericCollection_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnappendableNonGenericCollectionForAsymmetricTest( "A" ), + SerializerCapabilities.PackTo, + new byte[] { 0x91, 0xA1, ( byte )'A' } + ); + } + + + [Test] + public void TestAsymmetric_PackOnly_UnsettableArrayMemberObject_Packable() + { + this.TestAsymmetricPackOnlyCore( + () => new UnsettableArrayMemberObjectForAsymmetricTest(), + SerializerCapabilities.PackTo, + new byte[] { 0x82, 0xA5, ( byte )'F', ( byte )'i', ( byte )'e', ( byte )'l', ( byte )'d', 0x91, 0xA1, ( byte )'A', 0xA8, ( byte )'P', ( byte )'r', ( byte )'o', ( byte )'p', ( byte )'e', ( byte )'r', ( byte )'t', ( byte )'y', 0x91, 0xA1, ( byte )'A' } + ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized ) + { + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, true ); + this.TestAsymmetricPackOnlyCore( factory, expectedCapabilities, serialized, false ); + } + + private void TestAsymmetricPackOnlyCore( Func factory, SerializerCapabilities expectedCapabilities, byte[] serialized, bool avoidsGenericSerializer ) + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + context.CompatibilityOptions.AllowAsymmetricSerializer = true; + context.CompatibilityOptions.AllowNonCollectionEnumerableTypes = false; + + var serializer = this.CreateTarget( context ); + Assert.That( serializer.Capabilities, Is.EqualTo( expectedCapabilities ) ); + + var obj = factory(); + using ( var buffer = new MemoryStream() ) + { + if ( ( expectedCapabilities & SerializerCapabilities.PackTo ) != 0 ) + { + serializer.Pack( buffer, obj ); + Assert.That( buffer.ToArray(), Is.EqualTo( serialized ), "{0} != {1}", BitConverter.ToString( buffer.ToArray() ), BitConverter.ToString( serialized ) ); + } + else if ( ( expectedCapabilities & SerializerCapabilities.UnpackFrom ) != 0 ) + { + buffer.Write( serialized, 0, serialized.Length ); + buffer.Position = 0; + var unpacked = serializer.Unpack( buffer ); + Assert.That( obj, Is.EqualTo( unpacked ) ); + } + } + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Asymmetric -- + + #region -- Object Packing/Unpacking -- + + [Test] + public void TestToFromMessagePackObject_Complex() + { + var target = new ComplexType() { Source = new Uri( "http://www.exambple.com" ), TimeStamp = DateTime.Now, Data = new byte[] { 0x1, 0x2, 0x3, 0x4 } }; + target.History.Add( DateTime.Now.Subtract( TimeSpan.FromDays( 1 ) ), "Create New" ); + target.Points.Add( 123 ); + TestToFromMessagePackObjectCore( + target, + mpo => + { + Assert.That( mpo.IsDictionary ); + var asDictionary = mpo.AsDictionary(); + Assert.That( asDictionary.Count, Is.EqualTo( 5 ) ); + + Assert.That( asDictionary[ "Source" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "Source" ].AsString(), Is.EqualTo( target.Source.ToString() ) ); + + Assert.That( asDictionary[ "Data" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "Data" ].AsBinary(), Is.EqualTo( target.Data ) ); + + Assert.That( asDictionary[ "TimeStamp" ].IsTypeOf().Value ); + Assert.That( asDictionary[ "TimeStamp" ].AsInt64(), Is.EqualTo( target.TimeStamp.ToBinary() ) ); + + Assert.That( asDictionary[ "History" ].AsDictionary().Single().Key.AsInt64(), Is.EqualTo( target.History.Single().Key.ToBinary() ) ); + Assert.That( asDictionary[ "History" ].AsDictionary().Single().Value.AsString(), Is.EqualTo( target.History.Single().Value ) ); + + Assert.That( asDictionary[ "Points" ].IsArray ); + Assert.That( asDictionary[ "Points" ].AsList().Single().AsInt32(), Is.EqualTo( target.Points.Single() ) ); + } + ); + } + + [Test] + public void TestToFromMessagePackObject_ComplexGenerated() + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + // This test does not check packed result -- it is verfied with previous test and seems overkill. + this.TestToFromMessagePackObjectCore( target, _ => {} ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion ) + where T : IVerifiable + { + this.TestToFromMessagePackObjectCore( value, mpoAssertion, true ); + this.TestToFromMessagePackObjectCore( value, mpoAssertion, false ); + } + + private void TestToFromMessagePackObjectCore( T value, Action mpoAssertion, bool avoidsGenericSerializer ) + where T : IVerifiable + { + var previousAvoidsGenericSerializer = SerializerDebugging.AvoidsGenericSerializer; + SerializerDebugging.AvoidsGenericSerializer = avoidsGenericSerializer; + try + { + var context = GetSerializationContext(); + var serializer = this.CreateTarget( context ); + var mpo = serializer.ToMessagePackObject( value ); + mpoAssertion( mpo ); + var result = serializer.FromMessagePackObject( mpo ); + result.Verify( value ); + + var mpoLoose = ( ( MessagePackSerializer )serializer ).ToMessagePackObject( value ); + mpoAssertion( mpoLoose ); + var resultLoose = ( ( MessagePackSerializer )serializer ).FromMessagePackObject( mpoLoose ); + Assert.That( resultLoose, Is.TypeOf() ); + ( ( T )resultLoose ).Verify( value ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = previousAvoidsGenericSerializer; + } + } + + #endregion -- Object Packing/Unpacking -- + #region -- Polymorphism -- + #region ---- KnownType ---- + + #region ------ KnownType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.NormalTypes ------ + + #region ------ KnownType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.CollectionTypes ------ + + #region ------ KnownType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ KnownType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ KnownType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeKnownType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ KnownType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- KnownType ---- + #region ---- RuntimeType ---- + + #region ------ RuntimeType.NormalTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ReferenceReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceGetOnlyPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceGetOnlyPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferencePrivateSetterPropertyAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferencePrivateSetterPropertyAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ReferenceReadOnlyFieldAndConstructor( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.EqualTo( target.Reference ) ); + Assert.That( result.Reference, Is.InstanceOf( target.Reference.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ReferenceReadOnlyFieldAndConstructorAsObject( new Version( 1, 2, 3, 4 ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Reference, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_ValueReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_ValueReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueGetOnlyPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueGetOnlyPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValuePrivateSetterPropertyAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValuePrivateSetterPropertyAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_ValueReadOnlyFieldAndConstructor( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_ValueReadOnlyFieldAndConstructorAsObject( new DateTime( 1982, 1, 29, 15, 46, 12, DateTimeKind.Utc ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PrimitiveReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveGetOnlyPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveGetOnlyPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitivePrivateSetterPropertyAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitivePrivateSetterPropertyAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PrimitiveReadOnlyFieldAndConstructor( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.EqualTo( target.Primitive ) ); + Assert.That( result.Primitive, Is.InstanceOf( target.Primitive.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PrimitiveReadOnlyFieldAndConstructorAsObject( 123 ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Primitive, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_StringReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_StringReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringGetOnlyPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringGetOnlyPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringPrivateSetterPropertyAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringPrivateSetterPropertyAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_StringReadOnlyFieldAndConstructor( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.EqualTo( target.String ) ); + Assert.That( result.String, Is.InstanceOf( target.String.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject_AsMpo() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_StringReadOnlyFieldAndConstructorAsObject( "ABC" ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.String, Is.InstanceOf( typeof( MessagePackObject ) ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWritePropertyAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_PolymorphicReadWriteFieldAsObject.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicGetOnlyPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicGetOnlyPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicPrivateSetterPropertyAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicPrivateSetterPropertyAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Normal_PolymorphicReadOnlyFieldAndConstructor( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_PolymorphicReadOnlyFieldAndConstructorAsObject( new FileEntry { Name = "file", Size = 1 } ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Polymorphic, Is.EqualTo( target.Polymorphic ) ); + Assert.That( result.Polymorphic, Is.InstanceOf( target.Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.NormalTypes ------ + + #region ------ RuntimeType.CollectionTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListStaticItem, Is.EqualTo( target.ListStaticItem ) ); + Assert.That( result.ListStaticItem, Is.InstanceOf( target.ListStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItem, Is.EqualTo( target.ListPolymorphicItem ) ); + Assert.That( result.ListPolymorphicItem, Is.InstanceOf( target.ListPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItem, Is.EqualTo( target.ListObjectItem ) ); + Assert.That( result.ListObjectItem, Is.InstanceOf( target.ListObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListPolymorphicItself, Is.EqualTo( target.ListPolymorphicItself ) ); + Assert.That( result.ListPolymorphicItself, Is.InstanceOf( target.ListPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.ListObjectItself, Is.EqualTo( target.ListObjectItself ) ); + Assert.That( result.ListObjectItself, Is.InstanceOf( target.ListObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_List_ListObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.CollectionTypes ------ + + #region ------ RuntimeType.DictionaryTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.EqualTo( target.DictStaticKeyAndStaticItem ) ); + Assert.That( result.DictStaticKeyAndStaticItem, Is.InstanceOf( target.DictStaticKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.EqualTo( target.DictPolymorphicKeyAndStaticItem ) ); + Assert.That( result.DictPolymorphicKeyAndStaticItem, Is.InstanceOf( target.DictPolymorphicKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndStaticItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.EqualTo( target.DictObjectKeyAndStaticItem ) ); + Assert.That( result.DictObjectKeyAndStaticItem, Is.InstanceOf( target.DictObjectKeyAndStaticItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndPolymorphicItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.EqualTo( target.DictStaticKeyAndPolymorphicItem ) ); + Assert.That( result.DictStaticKeyAndPolymorphicItem, Is.InstanceOf( target.DictStaticKeyAndPolymorphicItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictStaticKeyAndObjectItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.EqualTo( target.DictStaticKeyAndObjectItem ) ); + Assert.That( result.DictStaticKeyAndObjectItem, Is.InstanceOf( target.DictStaticKeyAndObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.EqualTo( target.DictPolymorphicKeyAndItem ) ); + Assert.That( result.DictPolymorphicKeyAndItem, Is.InstanceOf( target.DictPolymorphicKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectKeyAndItemReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectKeyAndItem, Is.EqualTo( target.DictObjectKeyAndItem ) ); + Assert.That( result.DictObjectKeyAndItem, Is.InstanceOf( target.DictObjectKeyAndItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfGetOnlyCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictPolymorphicItselfReadOnlyCollectionField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictPolymorphicItself, Is.EqualTo( target.DictPolymorphicItself ) ); + Assert.That( result.DictPolymorphicItself, Is.InstanceOf( target.DictPolymorphicItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfGetOnlyCollectionProperty.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfPrivateSetterCollectionProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.DictObjectItself, Is.EqualTo( target.DictObjectItself ) ); + Assert.That( result.DictObjectItself, Is.InstanceOf( target.DictObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Dict_DictObjectItselfReadOnlyCollectionField.Initialize(); + Assert.Throws( () => context.GetSerializer() ); + } + +#endif // !UNITY + + #endregion ------ RuntimeType.DictionaryTypes ------ + +#if !NETFX_35 && !UNITY + #region ------ RuntimeType.TupleTypes ------ + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticGetOnlyPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1StaticReadOnlyFieldAndConstructor( Tuple.Create( "1" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Static, Is.EqualTo( target.Tuple1Static ) ); + Assert.That( result.Tuple1Static, Is.InstanceOf( target.Tuple1Static.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1PolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1Polymorphic, Is.EqualTo( target.Tuple1Polymorphic ) ); + Assert.That( result.Tuple1Polymorphic, Is.InstanceOf( target.Tuple1Polymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItemReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as object ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItem, Is.EqualTo( target.Tuple1ObjectItem ) ); + Assert.That( result.Tuple1ObjectItem, Is.InstanceOf( target.Tuple1ObjectItem.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple1ObjectItselfReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple1ObjectItself, Is.EqualTo( target.Tuple1ObjectItself ) ); + Assert.That( result.Tuple1ObjectItself, Is.InstanceOf( target.Tuple1ObjectItself.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllStatic, Is.EqualTo( target.Tuple7AllStatic ) ); + Assert.That( result.Tuple7AllStatic, Is.InstanceOf( target.Tuple7AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7FirstPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, "2", "3", "4", "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.EqualTo( target.Tuple7FirstPolymorphic ) ); + Assert.That( result.Tuple7FirstPolymorphic, Is.InstanceOf( target.Tuple7FirstPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.EqualTo( target.Tuple7LastPolymorphic ) ); + Assert.That( result.Tuple7LastPolymorphic, Is.InstanceOf( target.Tuple7LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7MidPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", new FileEntry { Name = "4", Size = 4 } as FileSystemEntry, "5", "6", "7") ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.EqualTo( target.Tuple7MidPolymorphic ) ); + Assert.That( result.Tuple7MidPolymorphic, Is.InstanceOf( target.Tuple7MidPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple7AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.EqualTo( target.Tuple7AllPolymorphic ) ); + Assert.That( result.Tuple7AllPolymorphic, Is.InstanceOf( target.Tuple7AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllStaticReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", "8" ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllStatic, Is.EqualTo( target.Tuple8AllStatic ) ); + Assert.That( result.Tuple8AllStatic, Is.InstanceOf( target.Tuple8AllStatic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8LastPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( "1", "2", "3", "4", "5", "6", "7", new FileEntry { Name = "8", Size = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.EqualTo( target.Tuple8LastPolymorphic ) ); + Assert.That( result.Tuple8LastPolymorphic, Is.InstanceOf( target.Tuple8LastPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteProperty.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadWriteField.Initialize(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicGetOnlyPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicPrivateSetterPropertyAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + +#if !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeRuntimeType_Tuple_Tuple8AllPolymorphicReadOnlyFieldAndConstructor( Tuple.Create( new FileEntry { Name = "1", Size = 1 } as FileSystemEntry, new DirectoryEntry { Name = "2", ChildCount = 2 } as FileSystemEntry, new FileEntry { Name = "3", Size = 3 } as FileSystemEntry, new DirectoryEntry { Name = "4", ChildCount = 4 } as FileSystemEntry, new FileEntry { Name = "5", Size = 5 } as FileSystemEntry, new DirectoryEntry { Name = "6", ChildCount = 6 } as FileSystemEntry, new FileEntry { Name = "7", Size = 7 } as FileSystemEntry, new DirectoryEntry { Name = "8", ChildCount = 8 } as FileSystemEntry ) ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.EqualTo( target.Tuple8AllPolymorphic ) ); + Assert.That( result.Tuple8AllPolymorphic, Is.InstanceOf( target.Tuple8AllPolymorphic.GetType() ) ); + } + } + +#endif // !UNITY + + #endregion ------ RuntimeType.TupleTypes ------ +#endif // #if !NETFX_35 && !UNITY + + #endregion ---- RuntimeType ---- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + target.NormalVanilla = "ABC"; + target.NormalRuntime = new FileEntry { Name = "File", Size = 1 }; + target.NormalKnown = new FileEntry { Name = "File", Size = 2 }; + target.ObjectRuntime = new FileEntry { Name = "File", Size = 3 }; + target.ObjectRuntimeOmittedType = new MsgPack.UnitTest.TestTypes.OmittedType { Value = "ABC" }; + target.ListVanilla = new List { "ABC" }; + target.ListKnownItem = new List { new FileEntry { Name = "File", Size = 1 } }; + target.ListKnwonContainerRuntimeItem = new List { new FileEntry { Name = "File", Size = 2 } }; + target.ListObjectRuntimeItem = new List { new FileEntry { Name = "File", Size = 3 } }; + target.DictionaryVanilla = new Dictionary { { "Key", "ABC" } }; + target.DictionaryKnownValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 1 } } }; + target.DictionaryKnownContainerRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 2 } } }; + target.DictionaryObjectRuntimeValue = new Dictionary { { "Key", new FileEntry { Name = "File", Size = 3 } } }; +#if !NETFX_35 && !UNITY + target.Tuple = Tuple.Create( "ABC", new FileEntry { Name = "File", Size = 1 }, new FileEntry { Name = "File", Size = 3 }, new FileEntry { Name = "File", Size = 3 } ); +#endif // !NETFX_35 && !UNITY + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.EqualTo( target.NormalVanilla ), "NormalVanilla" ); + Assert.That( result.NormalVanilla, Is.InstanceOf( target.NormalVanilla.GetType() ), "NormalVanilla" ); + Assert.That( result.NormalRuntime, Is.EqualTo( target.NormalRuntime ), "NormalRuntime" ); + Assert.That( result.NormalRuntime, Is.InstanceOf( target.NormalRuntime.GetType() ), "NormalRuntime" ); + Assert.That( result.NormalKnown, Is.EqualTo( target.NormalKnown ), "NormalKnown" ); + Assert.That( result.NormalKnown, Is.InstanceOf( target.NormalKnown.GetType() ), "NormalKnown" ); + Assert.That( result.ObjectRuntime, Is.EqualTo( target.ObjectRuntime ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntime, Is.InstanceOf( target.ObjectRuntime.GetType() ), "ObjectRuntime" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.EqualTo( target.ObjectRuntimeOmittedType ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ObjectRuntimeOmittedType, Is.InstanceOf( target.ObjectRuntimeOmittedType.GetType() ), "ObjectRuntimeOmittedType" ); + Assert.That( result.ListVanilla, Is.EqualTo( target.ListVanilla ), "ListVanilla" ); + Assert.That( result.ListVanilla, Is.InstanceOf( target.ListVanilla.GetType() ), "ListVanilla" ); + Assert.That( result.ListKnownItem, Is.EqualTo( target.ListKnownItem ), "ListKnownItem" ); + Assert.That( result.ListKnownItem, Is.InstanceOf( target.ListKnownItem.GetType() ), "ListKnownItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.EqualTo( target.ListKnwonContainerRuntimeItem ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.InstanceOf( target.ListKnwonContainerRuntimeItem.GetType() ), "ListKnwonContainerRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.EqualTo( target.ListObjectRuntimeItem ), "ListObjectRuntimeItem" ); + Assert.That( result.ListObjectRuntimeItem, Is.InstanceOf( target.ListObjectRuntimeItem.GetType() ), "ListObjectRuntimeItem" ); + Assert.That( result.DictionaryVanilla, Is.EqualTo( target.DictionaryVanilla ), "DictionaryVanilla" ); + Assert.That( result.DictionaryVanilla, Is.InstanceOf( target.DictionaryVanilla.GetType() ), "DictionaryVanilla" ); + Assert.That( result.DictionaryKnownValue, Is.EqualTo( target.DictionaryKnownValue ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownValue, Is.InstanceOf( target.DictionaryKnownValue.GetType() ), "DictionaryKnownValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.EqualTo( target.DictionaryKnownContainerRuntimeValue ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.InstanceOf( target.DictionaryKnownContainerRuntimeValue.GetType() ), "DictionaryKnownContainerRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.EqualTo( target.DictionaryObjectRuntimeValue ), "DictionaryObjectRuntimeValue" ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.InstanceOf( target.DictionaryObjectRuntimeValue.GetType() ), "DictionaryObjectRuntimeValue" ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.EqualTo( target.Tuple ), "Tuple" ); + Assert.That( result.Tuple, Is.InstanceOf( target.Tuple.GetType() ), "Tuple" ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphicMemberTypeMixed_Null_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new PolymorphicMemberTypeMixed(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.NormalVanilla, Is.Null ); + Assert.That( result.NormalRuntime, Is.Null ); + Assert.That( result.NormalKnown, Is.Null ); + Assert.That( result.ObjectRuntime, Is.Null ); + Assert.That( result.ObjectRuntimeOmittedType, Is.Null ); + Assert.That( result.ListVanilla, Is.Null ); + Assert.That( result.ListKnownItem, Is.Null ); + Assert.That( result.ListKnwonContainerRuntimeItem, Is.Null ); + Assert.That( result.ListObjectRuntimeItem, Is.Null ); + Assert.That( result.DictionaryVanilla, Is.Null ); + Assert.That( result.DictionaryKnownValue, Is.Null ); + Assert.That( result.DictionaryKnownContainerRuntimeValue, Is.Null ); + Assert.That( result.DictionaryObjectRuntimeValue, Is.Null ); +#if !NETFX_35 && !UNITY + Assert.That( result.Tuple, Is.Null ); +#endif // !NETFX_35 && !UNITY + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new AbstractClassDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberNoAttribute { Value = new FileEntry { Name = "file", Size = 1 } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberKnownType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceMemberRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceMemberRuntimeType { Value = new FileEntry { Name = "file", Size = 1 } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemNoAttribute { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemKnownType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceListItemRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceListItemRuntimeType { Value = new List{ new FileEntry { Name = "file", Size = 1 } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyNoAttribute_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyNoAttribute { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyKnownType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceDictKeyRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new InterfaceDictKeyRuntimeType { Value = new Dictionary { { new FileEntry { Name = "file", Size = 1 }, "ABC" } } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAbstractClassCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( KeyedCollection ), typeof( EchoKeyedCollection ) ); + var target = new AbstractClassCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionNoAttribute_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionNoAttribute { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionKnownType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionKnownType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestInterfaceCollectionRuntimeType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.DefaultCollectionTypes.Register( typeof( IList ), typeof( EchoKeyedCollection ) ); + var target = new InterfaceCollectionRuntimeType { Value = new EchoKeyedCollection { "ABC" } }; + + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value.Count, Is.EqualTo( target.Value.Count ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + Assert.That( result.Value, Is.EquivalentTo( target.Value ) ); + } + } +#if !NETFX_35 && !UNITY + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTupleAbstractType_Success() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new TupleAbstractType { Value = Tuple.Create( new FileEntry { Name = "1", Size = 1 } as AbstractFileSystemEntry, new FileEntry { Name = "2", Size = 2 } as IFileSystemEntry, new FileEntry { Name = "3", Size = 3 } as AbstractFileSystemEntry, new FileEntry { Name = "4", Size = 4 } as IFileSystemEntry ) }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.Value, Is.EqualTo( target.Value ) ); + Assert.That( result.Value, Is.InstanceOf( target.Value.GetType() ) ); + } + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_DuplicatedKnownTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new DuplicatedKnownTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeMember_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeMember(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeCollectionItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeCollectionItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeDictionaryKey_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeDictionaryKey(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#if !NETFX_35 && !UNITY + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestAttribute_KnownAndRuntimeTupleItem_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new KnownAndRuntimeTupleItem(); + Assert.Throws( ()=> context.GetSerializer() ); + } +#endif // !NETFX_35 && !UNITY + // Issue 137 + [Test] + [Category( "PolymorphicSerialization" )] + public void TestGlobalNamespace() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#if FEATURE_TAP + [Test] + [Category( "PolymorphicSerialization" )] + public async Task TestGlobalNamespaceAsync() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new HasGlobalNamespaceType { GlobalType = new TypeInGlobalNamespace { Value = "ABC" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + await serializer.PackAsync( buffer, target ); + buffer.Position = 0; + var result = await serializer.UnpackAsync( buffer ); + + Assert.That( result, Is.Not.Null ); + Assert.That( result, Is.Not.SameAs( target ) ); + Assert.That( result.GlobalType, Is.Not.Null ); + Assert.That( result.GlobalType, Is.Not.SameAs( target.GlobalType ) ); + Assert.That( result.GlobalType.Value, Is.EqualTo( target.GlobalType.Value ) ); + } + } + +#endif // FEATURE_TAP + +#region -- Polymorphic Attributes in Type and Member -- + + private static void SetUpDefaultCollectionsForPolymorphism( SerializationContext context ) + { + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicCollection ), typeof( KnownTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicCollection ), typeof( RuntimeTypePolymorphicCollection ) ); + context.DefaultCollectionTypes.Register( typeof( IKnownTypePolymorphicDictionary ), typeof( KnownTypePolymorphicDictionary ) ); + context.DefaultCollectionTypes.Register( typeof( IRuntimeTypePolymorphicDictionary ), typeof( RuntimeTypePolymorphicDictionary ) ); + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestPolymorphismAttributesInType() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + context.GetSerializer(); + } + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicVanillaProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicKnownProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeField = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicRuntimeProperty = new KnownTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicVanillaProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicKnownProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeField = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeType_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicRuntimeProperty = new RuntimeTypePolymorphic(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionVanillaProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionKnownProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeField = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicCollectionRuntimeProperty = new KnownTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionVanillaProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionKnownProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeField = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeCollection_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicCollectionRuntimeProperty = new RuntimeTypePolymorphicCollection(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicCollectionRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsNothing_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryVanillaProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Field_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsKnown_Property_Known() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryKnownProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryKnownProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsTypeOf().GetValueOrDefault(), Is.True, typeHeader.ToString() ); // known type header + // Verify override in member value. + Assert.That( typeHeader.AsString(), Is.EqualTo( "A" ), typeHeader.ToString() ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeField = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestKnownTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.KnownTypePolymorphicDictionaryRuntimeProperty = new KnownTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "KnownTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsNothing_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryVanillaProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryVanillaProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Field_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsKnown_Property_Known_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryKnownProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + var ex = Assert.Catch( () => serializer.Pack( buffer ,target ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.Contain( "is not defined as known type" ) ); +#else + Assert.That( ex.Message.Contains( "is not defined as known type" ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Field_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeField = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeField" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestRuntimeTypeDictionary_AttributeIsRuntime_Property_Runtime() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + context.SerializationMethod = SerializationMethod.Map; + SetUpDefaultCollectionsForPolymorphism( context ); + + var target = new PolymorphicHolder(); + target.RuntimeTypePolymorphicDictionaryRuntimeProperty = new RuntimeTypePolymorphicDictionary(); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var serializedObject = Unpacking.UnpackObject( buffer ); + Assert.That( serializedObject.IsDictionary, Is.True, serializedObject.ToString() ); + var serializedMember = serializedObject.AsDictionary()[ "RuntimeTypePolymorphicDictionaryRuntimeProperty" ]; + Assert.That( serializedMember.IsArray, Is.True, serializedObject.ToString() ); + Assert.That( serializedMember.AsList().Count, Is.EqualTo( 2 ), serializedMember.ToString() ); + var typeHeader = serializedMember.AsList()[ 0 ]; + Assert.That( typeHeader.IsArray, typeHeader.ToString() ); + Assert.That( typeHeader.AsList().Count, Is.EqualTo( 6 ), typeHeader.ToString() ); // runtime type header + } + } + + +#endregion -- Polymorphic Attributes in Type and Member -- + +#region -- TypeVerifier cases -- + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_PublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicStaticMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateStaticAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateStaticAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_PublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPublicInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPublicInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierSelection_NonPublicVerifierType_NonPublicInstanceMethod_OK() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + SetUpDefaultCollectionsForPolymorphism( context ); + var target = new PolymorphicHolder { ForNonPublicTypeVerifierPrivateInstanceAllowAll = new PolymorphicValueA { Value = "Foo" } }; + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, target ); + buffer.Position = 0; + var deserialized = serializer.Unpack( buffer ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll, Is.Not.Null ); + Assert.That( deserialized.ForNonPublicTypeVerifierPrivateInstanceAllowAll.Value, Is.EqualTo( "Foo" ) ); + } + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoMethods_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoMethods { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseVoidReturnMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierVoidReturnMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseNoParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierNoParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestSpecifiedTypeVerifierIsNotFound_BecauseExtraParametersMethod_Fail() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var target = new RuntimeTypePolymorphicWithInvalidVerifierExtraParametersMethod { Value = "Foo" }; + + var ex = Assert.Catch( () => context.GetSerializer() ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "VerifierMethodName cannot be null " ).Or.StartWith( "A public static or instance method " ) ); +#else + Assert.That( ex.Message.StartsWith( "VerifierMethodName cannot be null " ) || ex.Message.StartsWith( "A public static or instance method " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + + [Test] + [Category( "PolymorphicSerialization" )] + public void TestTypeVerifierDoesNotLoadTypeItself() + { + var context = NewSerializationContext( PackerCompatibilityOptions.None ); + var serializer = context.GetSerializer(); + + using ( var buffer = new MemoryStream() ) + using ( var packer = Packer.Create( buffer ) ) + { + Polymorphic.TypeInfoEncoder.Encode( packer, typeof( DangerousClass ) ); + packer.PackArrayHeader( 1 ); + packer.PackString( "Foo" ); // Value + buffer.Position = 0; + var ex = Assert.Catch( () => serializer.Unpack( buffer ) ); +#if !UNITY && !XAMARIN + Assert.That( ex.Message, Does.StartWith( "Type verifier rejects type " ) ); +#else + Assert.That( ex.Message.StartsWith( "Type verifier rejects type " ), ex.Message ); +#endif // !UNITY && !XAMARIN + } + } + +#endregion -- TypeVerifier cases -- + + + #endregion -- Polymorphism -- + [Test] + public void TestNullField() + { + this.TestCoreWithAutoVerify( default( object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( default( object ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestNullFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestTrueField() + { + this.TestCoreWithAutoVerify( true, GetSerializationContext() ); + } + + [Test] + public void TestTrueFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( true, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestFalseField() + { + this.TestCoreWithAutoVerify( false, GetSerializationContext() ); + } + + [Test] + public void TestFalseFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( false, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyByteField() + { + this.TestCoreWithAutoVerify( 1, GetSerializationContext() ); + } + + [Test] + public void TestTinyByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 1, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteField() + { + this.TestCoreWithAutoVerify( 0x80, GetSerializationContext() ); + } + + [Test] + public void TestByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x80, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxByteField() + { + this.TestCoreWithAutoVerify( 0xff, GetSerializationContext() ); + } + + [Test] + public void TestMaxByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16Field() + { + this.TestCoreWithAutoVerify( 0x100, GetSerializationContext() ); + } + + [Test] + public void TestTinyUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16Field() + { + this.TestCoreWithAutoVerify( 0xffff, GetSerializationContext() ); + } + + [Test] + public void TestMaxUInt16FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0xffff, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32Field() + { + this.TestCoreWithAutoVerify( 0x10000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x10000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt32Field() + { + this.TestCoreWithAutoVerify( Int32.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int32.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64Field() + { + this.TestCoreWithAutoVerify( 0x100000000, GetSerializationContext() ); + } + + [Test] + public void TestTinyInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 0x100000000, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestMaxInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMinInt64Field() + { + this.TestCoreWithAutoVerify( Int64.MinValue, GetSerializationContext() ); + } + + [Test] + public void TestMinInt64FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Int64.MinValue, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeField() + { + this.TestCoreWithAutoVerify( DateTime.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTime.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( DateTimeOffset.UtcNow, GetSerializationContext() ); + } + + [Test] + public void TestDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( DateTimeOffset.UtcNow, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriField() + { + this.TestCoreWithAutoVerify( new Uri( "http://example.com/" ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Uri( "http://example.com/" ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldNull() + { + this.TestCoreWithAutoVerify( default( Uri ), GetSerializationContext() ); + } + + [Test] + public void TestUriFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Uri[] ), GetSerializationContext() ); + } + + [Test] + public void TestVersionField() + { + this.TestCoreWithAutoVerify( new Version( 1, 2, 3, 4 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3, 4 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEField() + { + this.TestCoreWithAutoVerify( ToFileTime( DateTime.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestFILETIMEFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( ToFileTime( DateTime.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanField() + { + this.TestCoreWithAutoVerify( TimeSpan.FromMilliseconds( 123456789 ), GetSerializationContext() ); + } + + [Test] + public void TestTimeSpanFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( TimeSpan.FromMilliseconds( 123456789 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestGuidField() + { + this.TestCoreWithAutoVerify( Guid.NewGuid(), GetSerializationContext() ); + } + + [Test] + public void TestGuidFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( Guid.NewGuid(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharField() + { + this.TestCoreWithAutoVerify( '　', GetSerializationContext() ); + } + + [Test] + public void TestCharFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( '　', 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDecimalField() + { + this.TestCoreWithAutoVerify( 123456789.0987654321m, GetSerializationContext() ); + } + + [Test] + public void TestDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( 123456789.0987654321m, 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestBigIntegerField() + { + this.TestCoreWithAutoVerify( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, GetSerializationContext() ); + } + + [Test] + public void TestBigIntegerFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new BigInteger( UInt64.MaxValue ) + UInt64.MaxValue, 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestComplexField() + { + this.TestCoreWithAutoVerify( new Complex( 1.3, 2.4 ), GetSerializationContext() ); + } + + [Test] + public void TestComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Complex( 1.3, 2.4 ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestDictionaryEntryField() + { + this.TestCoreWithAutoVerify( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryEntryFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new DictionaryEntry( new MessagePackObject( "Key" ), new MessagePackObject( "Value" ) ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringDateTimeOffsetFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", DateTimeOffset.UtcNow ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestKeyValuePairStringComplexField() + { + this.TestCoreWithAutoVerify( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), GetSerializationContext() ); + } + + [Test] + public void TestKeyValuePairStringComplexFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new KeyValuePair( "Key", new Complex( 1.3, 2.4 ) ), 2 ).ToArray(), GetSerializationContext() ); + } + +#endif // !NETFX_35 && !WINDOWS_PHONE + [Test] + public void TestStringField() + { + this.TestCoreWithAutoVerify( "StringValue", GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "StringValue", 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldNull() + { + this.TestCoreWithAutoVerify( default( String ), GetSerializationContext() ); + } + + [Test] + public void TestStringFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( String[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayField() + { + this.TestCoreWithAutoVerify( new Byte[]{ 1, 2, 3, 4 }, GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Byte[]{ 1, 2, 3, 4 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Byte[] ), GetSerializationContext() ); + } + + [Test] + public void TestByteArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Byte[][] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayField() + { + this.TestCoreWithAutoVerify( "ABCD".ToCharArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( "ABCD".ToCharArray(), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Char[] ), GetSerializationContext() ); + } + + [Test] + public void TestCharArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Char[][] ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentByteFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Byte[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32Field() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentInt32FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Int32[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalField() + { + this.TestCoreWithAutoVerify( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), GetSerializationContext() ); + } + + [Test] + public void TestArraySegmentDecimalFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArraySegment( new Decimal[]{ 1, 2, 3, 4 } ), 2 ).ToArray(), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectField() + { + this.TestCoreWithAutoVerify( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Tuple( 1, "ABC", new MessagePackObject( "abc" ), new MessagePackObject( "123" ) ) , 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple ), GetSerializationContext() ); + } + + [Test] + public void TestTuple_Int32_String_MessagePackObject_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Tuple[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestImage_Field() + { + this.TestCoreWithAutoVerify( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Image(){ uri = "http://example.com/logo.png", title = "logo", width = 160, height = 120, size = 13612 }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image ), GetSerializationContext() ); + } + + [Test] + public void TestImage_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Image[] ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetDateTimeField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListDateTimeField() + { + this.TestCoreWithAutoVerify( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { "Yesterday", DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ) }, { "Today", DateTime.UtcNow } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryStringDateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ DateTime.UtcNow.Subtract( TimeSpan.FromDays( 1 ) ), DateTime.UtcNow }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_DateTimeFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectField() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Object ), GetSerializationContext() ); + } + + [Test] + public void TestObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayField() + { + this.TestCoreWithAutoVerify( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Object []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldNull() + { + this.TestCoreWithAutoVerify( default( Object[] ), GetSerializationContext() ); + } + + [Test] + public void TestObjectArrayFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Object[][] ), GetSerializationContext() ); + } + +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestArrayListField() + { + this.TestCoreWithAutoVerify( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ArrayList(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldNull() + { + this.TestCoreWithAutoVerify( default( ArrayList ), GetSerializationContext() ); + } + + [Test] + public void TestArrayListFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ArrayList[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT +#if !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestHashtableField() + { + this.TestCoreWithAutoVerify( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Hashtable(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldNull() + { + this.TestCoreWithAutoVerify( default( Hashtable ), GetSerializationContext() ); + } + + [Test] + public void TestHashtableFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Hashtable[] ), GetSerializationContext() ); + } + +#endif // !NETFX_CORE && !SILVERLIGHT + [Test] + public void TestListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( List ), GetSerializationContext() ); + } + + [Test] + public void TestListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollectionObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollectionObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISetObjectField() + { + this.TestCoreWithAutoVerify( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISetObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIListObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IList ), GetSerializationContext() ); + } + + [Test] + public void TestIListObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary(){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionaryObjectObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_ObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject( 1 ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject( 1 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObject_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_Field() + { + this.TestCoreWithAutoVerify( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new MessagePackObject []{ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[] ), GetSerializationContext() ); + } + + [Test] + public void TestMessagePackObjectArray_FieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.MessagePackObject[][] ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List ), GetSerializationContext() ); + } + + [Test] + public void TestList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.List[] ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary ), GetSerializationContext() ); + } + + [Test] + public void TestDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.Dictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Collection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection ), GetSerializationContext() ); + } + + [Test] + public void TestCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.Collection[] ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new StringKeyedCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection ), GetSerializationContext() ); + } + + [Test] + public void TestStringKeyedCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.StringKeyedCollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestObservableCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new ObservableCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection ), GetSerializationContext() ); + } + + [Test] + public void TestObservableCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.ObjectModel.ObservableCollection[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestHashSet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet ), GetSerializationContext() ); + } + + [Test] + public void TestHashSet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.HashSet[] ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new SimpleCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection ), GetSerializationContext() ); + } + + [Test] + public void TestICollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ICollection[] ), GetSerializationContext() ); + } + +#if !NETFX_35 + [Test] + public void TestISet_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new HashSet( DictionaryTestHelper.GetEqualityComparer() ){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet ), GetSerializationContext() ); + } + + [Test] + public void TestISet_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.ISet[] ), GetSerializationContext() ); + } + +#endif // !NETFX_35 + [Test] + public void TestIList_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new List(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList ), GetSerializationContext() ); + } + + [Test] + public void TestIList_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IList[] ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Dictionary( DictionaryTestHelper.GetEqualityComparer() ){ { new MessagePackObject( "1" ), new MessagePackObject( 1 ) }, { new MessagePackObject( "2" ), new MessagePackObject( 2 ) } }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary ), GetSerializationContext() ); + } + + [Test] + public void TestIDictionary_MessagePackObject_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( System.Collections.Generic.IDictionary[] ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectField() + { + this.TestCoreWithAutoVerify( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new AddOnlyCollection(){ new MessagePackObject( 1 ), new MessagePackObject( 2 ) }, 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection ), GetSerializationContext() ); + } + + [Test] + public void TestAddOnlyCollection_MessagePackObjectFieldArrayNull() + { + this.TestCoreWithAutoVerify( default( MsgPack.Serialization.AddOnlyCollection[] ), GetSerializationContext() ); + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosure_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGeneratedEnclosure(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedEnclosureArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGeneratedEnclosure().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGenerated_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + var target = new ComplexTypeGenerated(); + target.Initialize(); + this.TestCoreWithVerifiable( target, GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = false; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + [Test] + public void TestComplexTypeGeneratedArray_WithoutShortcut() + { + SerializerDebugging.AvoidsGenericSerializer = true; + try + { + this.TestCoreWithVerifiable( Enumerable.Repeat( 0, 2 ).Select( _ => new ComplexTypeGenerated().Initialize() ).ToArray(), GetSerializationContext() ); + } + finally + { + SerializerDebugging.AvoidsGenericSerializer = false; + } + } + + private void TestCoreWithAutoVerify( T value, SerializationContext context ) + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + AutoMessagePackSerializerTest.Verify( value, unpacked ); + } + } + + private void TestCoreWithVerifiable( T value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T unpacked = target.Unpack( buffer ); + buffer.Position = 0; + unpacked.Verify( value ); + } + } + + private void TestCoreWithVerifiable( T[] value, SerializationContext context ) + where T : IVerifiable + { + var target = this.CreateTarget( context ); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, value ); + buffer.Position = 0; + T[] unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.Length, Is.EqualTo( value.Length ) ); + for( int i = 0; i < unpacked.Length; i ++ ) + { + try + { + unpacked[ i ].Verify( value[ i ] ); + } +#if MSTEST + catch( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException ae ) + { + throw new Microsoft.VisualStudio.TestPlatform.UnitTestFramework.AssertFailedException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#else + catch( AssertionException ae ) + { + throw new AssertionException( String.Format( "[{0}]:{1}", i, ae.Message ), ae ); + } +#endif + } + } + } + + private static FILETIME ToFileTime( DateTime dateTime ) + { + var fileTime = dateTime.ToFileTimeUtc(); + return new FILETIME(){ dwHighDateTime = unchecked( ( int )( fileTime >> 32 ) ), dwLowDateTime = unchecked( ( int )( fileTime & 0xffffffff ) ) }; + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt new file mode 100644 index 000000000..44b38b6a3 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedAutoMessagePackSerializerTest.tt @@ -0,0 +1,17 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.ttinclude" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\AutoMessagePackSerializerTest.Types.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Linq" #> +<# +Geneate( "Map", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "VisualBasic" ); +GenerateTypes(); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs new file mode 100644 index 000000000..c0a1d612a --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.cs @@ -0,0 +1,721 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +#if !NETFX_CORE +using System.Collections; +#endif +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.IO; +using System.Linq; +#if !AOT && !SILVERLIGHT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !AOT && !SILVERLIGHT +#if !NETFX_CORE +using Microsoft.FSharp.Collections; +#endif // !NETFX_CORE +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class MapVisualBasicCodeTreeBasedImmutableCollectionsTest + { + private MessagePackSerializer CreateTarget() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context.GetSerializer( PolymorphismSchema.Default ); + } + + private bool CanDump + { + get { return true; } + } + +#if !NETFX_CORE + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( ImmutableList ).Assembly.Location ); + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif + + [Test] + public void QueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Queue(); + value.Enqueue( 1 ); + value.Enqueue( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void StackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer>(); + var value = new Stack(); + value.Push( 1 ); + value.Push( 2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + +#if !NETFX_CORE + [Test] + public void NonGenericQueueSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Queue(); + value.Enqueue( ( MessagePackObject )1 ); + value.Enqueue( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } + + [Test] + public void NonGenericStackSerializationTest() + { + var serializer = SerializationContext.Default.GetSerializer(); + var value = new Stack(); + value.Push( ( MessagePackObject )1 ); + value.Push( ( MessagePackObject )2 ); + + using ( var buffer = new MemoryStream() ) + { + serializer.Pack( buffer, value ); + buffer.Position = 0; + var result = serializer.Unpack( buffer ); + Assert.That( result, Is.EqualTo( value ) ); + } + } +#endif // !NETFX_CORE + + + [Test] + public void ImmutableArrayTest_0_Success() + { + var collection = ImmutableArray.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_1_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableArrayTest_2_Success() + { + var collection = ImmutableArray.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_0_Success() + { + var collection = ImmutableList.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_1_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableListTest_2_Success() + { + var collection = ImmutableList.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_0_Success() + { + var collection = ImmutableStack.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_1_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableStackTest_2_Success() + { + var collection = ImmutableStack.Create(); + collection = collection.Push( 0 ); + collection = collection.Push( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_0_Success() + { + var collection = ImmutableQueue.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_1_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableQueueTest_2_Success() + { + var collection = ImmutableQueue.Create(); + collection = collection.Enqueue( 0 ); + collection = collection.Enqueue( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_0_Success() + { + var collection = ImmutableHashSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_1_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableHashSetTest_2_Success() + { + var collection = ImmutableHashSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_0_Success() + { + var collection = ImmutableSortedSet.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_1_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedSetTest_2_Success() + { + var collection = ImmutableSortedSet.Create(); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_0_Success() + { + var collection = ImmutableDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_1_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableDictionaryTest_2_Success() + { + var collection = ImmutableDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_0_Success() + { + var collection = ImmutableSortedDictionary.Create(); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_1_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void ImmutableSortedDictionaryTest_2_Success() + { + var collection = ImmutableSortedDictionary.Create(); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#if !NETFX_CORE + + + [Test] + public void FSharpListTest_0_Success() + { + var collection = FSharpList.Empty; + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_1_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpListTest_2_Success() + { + var collection = FSharpList.Empty; + collection = new FSharpList( 0, collection ); + collection = new FSharpList( 1, collection ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_0_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_1_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpSetTest_2_Success() + { + var collection = new FSharpSet( Enumerable.Empty() ); + collection = collection.Add( 0 ); + collection = collection.Add( 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_0_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_1_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + + [Test] + public void FSharpMapTest_2_Success() + { + var collection = new FSharpMap( Enumerable.Empty>() ); + collection = collection.Add( 0, 0 ); + collection = collection.Add( 1, 1 ); + var target = this.CreateTarget>(); + using ( var buffer = new MemoryStream() ) + { + target.Pack( buffer, collection ); + buffer.Position = 0; + var unpacked = target.Unpack( buffer ); + buffer.Position = 0; + Assert.That( unpacked.ToArray(), Is.EqualTo( collection.ToArray() ) ); + } + } + +#endif // !NETFX_CORE + + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt new file mode 100644 index 000000000..c7de288e4 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedCustomCollectionSerializersTest.tt @@ -0,0 +1,15 @@ +<#@ template hostSpecific="false"#> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest.BclExtensions\Serialization\CustomCollectionSerializersTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Numerics" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Globalization" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "Map", "CodeTreeBased", "CodeTreeSerializerBuilder", true, "VisualBasic" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.cs new file mode 100644 index 000000000..1cb9c0e88 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.cs @@ -0,0 +1,1340 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2014-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text.RegularExpressions; +#if FEATURE_TAP +using System.Threading; +using System.Threading.Tasks; +#endif // FEATURE_TAP + +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT + +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + [Timeout( 30000 )] + public class MapVisualBasicCodeTreeBasedEnumSerializerTest + { + private SerializationContext GetSerializationContext() + { + var context = new SerializationContext { SerializationMethod = SerializationMethod.Map }; + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + private bool CanDump + { + get { return true; } + } + +#if !SILVERLIGHT && !AOT + [SetUp] + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); + if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) + { + try + { + SerializerDebugging.Dump(); + } + catch ( NotSupportedException ex ) + { + Console.Error.WriteLine( ex ); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) + { + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + Assert.That( Unpacking.UnpackString( stream ), Is.EqualTo( value.ToString() ) ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackDictionary( stream ); + Assert.That( +#if !UNITY + result[ property ].Equals( propertyInfo.GetValue( value, null ).ToString() ), + result[ property ] + " == " + propertyInfo.GetValue( value, null ) +#else + result[ property ].Equals( propertyInfo.GetGetMethod().Invoke( value, null ).ToString() ), + result[ property ] + " == " + propertyInfo.GetGetMethod().Invoke( value, null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByName( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByNameAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByNameCore( stream, value, deserialized, property ); + } + } + +#endif // FEATURE_TAP + + private static void TestEnumForByUnderlyingValueCore( Stream stream, T value, T deserialized, string property ) + { + + if ( property == null ) + { + Assert.That( deserialized, Is.EqualTo( value ) ); + stream.Position = 0; + var result = Unpacking.UnpackObject( stream ); + Assert.That( + result.ToString().Equals( ( ( IFormattable )value ).ToString( "D", null ) ), + result + " == " + ( ( IFormattable )value ).ToString( "D", null ) + ); + } + else + { + var propertyInfo = typeof( T ).GetProperty( property ); +#if !UNITY + Assert.That( propertyInfo.GetValue( deserialized, null ), Is.EqualTo( propertyInfo.GetValue( value, null ) ) ); +#else + Assert.That( propertyInfo.GetGetMethod().Invoke( deserialized, null ), Is.EqualTo( propertyInfo.GetGetMethod().Invoke( value, null ) ) ); +#endif // !UNITY + stream.Position = 0; + var result = Unpacking.UnpackDictionary( stream ); + Assert.That( +#if !UNITY + result[ property ].ToString().Equals( ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) ), + result[ property ] + " == " + ( ( IFormattable )propertyInfo.GetValue( value, null ) ).ToString( "D", null ) +#else + result[ property ].ToString().Equals( ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) ), + result[ property ] + " == " + ( ( IFormattable )propertyInfo.GetGetMethod().Invoke( value, null ) ).ToString( "D", null ) +#endif // !UNITY + ); + } + } + + private static void TestEnumForByUnderlyingValue( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + serializer.Pack( stream, value ); + stream.Position = 0; + var deserialized = serializer.Unpack( stream ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + +#if FEATURE_TAP + + private static async Task TestEnumForByUnderlyingValueAsync( SerializationContext context, T value, string property ) + { + var serializer = context.GetSerializer(); + + using ( var stream = new MemoryStream() ) + { + await serializer.PackAsync( stream, value, CancellationToken.None ).ConfigureAwait( false ); + stream.Position = 0; + var deserialized = await serializer.UnpackAsync( stream, CancellationToken.None ).ConfigureAwait( false ); + TestEnumForByUnderlyingValueCore( stream, value, deserialized, property ); + } + } + + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumDefault.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumDefault.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, EnumByName.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByNameAsync( context, EnumByName.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + +#if FEATURE_TAP + + [Test] + public async Task TestAsyncSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + await TestEnumForByUnderlyingValueAsync( context, EnumByUnderlyingValue.Foo, null ); + } + +#endif // FEATURE_TAP + + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsDefault_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByName_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumDefault.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "DefaultByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsNone_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "DefaultByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, EnumByName.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByNameByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByName_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByNameByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsNone() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByUnderlyingValue.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsDefault() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueDefaultProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByName( context, new EnumMemberObject(), "ByUnderlyingValueByNameProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestSerializationMethod_ContextIsByUnderlyingValue_TypeIsByUnderlyingValue_MemberIsByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, new EnumMemberObject(), "ByUnderlyingValueByUnderlyingValueProperty" ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumByteFlags.Foo | EnumByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByte.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumSByte_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumSByteFlags.Foo | EnumSByteFlags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt16Flags.Foo | EnumInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt16_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt16Flags.Foo | EnumUInt16Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt32Flags.Foo | EnumInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt32_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt32Flags.Foo | EnumUInt32Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumInt64Flags.Foo | EnumInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithoutFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64.Foo, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByName() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + try + { + TestEnumForByName( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + [Test] + public void TestEnumUInt64_WithFlags_ByUnderlyingValue() + { + var context = this.GetSerializationContext(); + context.EnumSerializationMethod = EnumSerializationMethod.ByUnderlyingValue; + try + { + TestEnumForByUnderlyingValue( context, EnumUInt64Flags.Foo | EnumUInt64Flags.Bar, null ); + } + finally + { + context.EnumSerializationMethod = EnumSerializationMethod.ByName; + } + } + + // Issue #184 + [Test] + public void TestEnumKeyTransformer_Default_AsIs() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Default_AsIs_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + Assert.That( context.EnumSerializationOptions.NameTransformer, Is.Null, "default value" ); + TestEnumKeyCore( context, "ToEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_LowerCamel_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.LowerCamel; + TestEnumKeyCore( context, "toEven", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_AllUpper_Async() + { + var context = GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = EnumNameTransformers.UpperSnake; + TestEnumKeyCore( context, "TO_EVEN", isAsync: true ); + } + +#endif // FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: false ); + } + +#if FEATURE_TAP + + [Test] + public void TestEnumKeyTransformer_Custom_Async() + { + var context = this.GetSerializationContext(); + context.EnumSerializationOptions.SerializationMethod = EnumSerializationMethod.ByName; + context.EnumSerializationOptions.NameTransformer = + key => Regex.Replace( key, "[A-Z]", match => match.Index == 0 ? match.Value.ToLower() : "-" + match.Value.ToLower() ); + TestEnumKeyCore( context, "to-even", isAsync: true ); + } + +#endif // FEATURE_TAP + + private static void TestEnumKeyCore( SerializationContext context, string expected, bool isAsync ) + { + var serializer = context.GetSerializer(); + var obj = MidpointRounding.ToEven; + using ( var buffer = new MemoryStream() ) + { +#if FEATURE_TAP + if ( isAsync ) + { + serializer.PackAsync( buffer, obj, CancellationToken.None ).Wait(); + } + else + { +#endif // FEATURE_TAP + serializer.Pack( buffer, obj ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + buffer.Position = 0; + var stringValue = MessagePackSerializer.UnpackMessagePackObject( buffer ).AsString(); + + Assert.That( stringValue, Is.EqualTo( expected ) ); + + buffer.Position = 0; + + MidpointRounding deserialized; +#if FEATURE_TAP + if ( isAsync ) + { + deserialized = serializer.UnpackAsync( buffer, CancellationToken.None ).Result; + } + else + { +#endif // FEATURE_TAP + deserialized = serializer.Unpack( buffer ); +#if FEATURE_TAP + } +#endif // FEATURE_TAP + + Assert.That( deserialized, Is.EqualTo( obj ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.tt new file mode 100644 index 000000000..4fbbd0354 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/MapVisualBasicCodeTreeBasedEnumSerializationTest.tt @@ -0,0 +1,10 @@ +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\EnumSerializationTest.ttinclude" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ output extension=".cs" #> +<# +GenerateCore( "Map", "CodeTreeBased", true, false, "VisualBasic" ); +#> \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.cs new file mode 100644 index 000000000..ba658901f --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.cs @@ -0,0 +1,588 @@ + +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2015 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.Serialization; +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.EmittingSerializers; +#endif // !SILVERLIGHT && !AOT +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ + [TestFixture] + public class VisualBasicCodeTreeBasedNilImplicationTest + { + private SerializationContext CreateSerializationContext() + { + var context = new SerializationContext(); + context.SerializerOptions.EmitterFlavor = EmitterFlavor.CodeTreeBased; + return context; + } + + private MessagePackSerializer CreateTarget( SerializationContext context ) + { + return MessagePackSerializer.CreateInternal( context, PolymorphismSchema.Default ); + } +#if !SILVERLIGHT && !AOT && !UNITY + +#if MSTEST + [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] + public void Initialize( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestContext c ) + { + this.SetUp(); + } +#else + [SetUp] +#endif + public void SetUp() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.DeletePastTemporaries(); + //SerializerDebugging.TraceEnabled = true; + //SerializerDebugging.DumpEnabled = true; + if ( SerializerDebugging.TraceEnabled ) + { + Tracer.Emit.Listeners.Clear(); + Tracer.Emit.Switch.Level = SourceLevels.All; + Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new VisualBasicCodeTreeSerializerBuilder( t, c ) ); + SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); + if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) + { + SerializerDebugging.AddRuntimeAssembly( typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly.Location ); + } + } + + [TearDown] + public void TearDown() + { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled ) + { + try + { + SerializerDebugging.Dump(); + } + finally + { + SerializationMethodGeneratorManager.Refresh(); + } + } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + + SerializerDebugging.Reset(); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); + } +#endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 + + // ------ Creation ------ + + [Test] + public void TestCreation_ValueType_OnlyNullIsInvalid() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + Assert.Throws( + () => CreateTarget( this.CreateSerializationContext() ) + ); + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_ReferenceType_AllOk() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_NullableValueType_AllOk() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + [Test] + public void TestCreation_ReadOnlyCollectionProperty_OnlyNullIsInvalid() + { + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + Assert.Throws( + () => CreateTarget( this.CreateSerializationContext() ) + ); + Assert.NotNull( CreateTarget( this.CreateSerializationContext() ) ); + } + + // ------ Packing ------ + + private void TestPackFail( + SerializationMethod method, + Func inputFactory + ) + where T : new() + where TException : Exception + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + Assert.Throws( () => seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ) ); + } + } + + // Packing null ValueType is not possible. + + [Test] + public void TestPack_ReadOnlyCollectionProperty_Prohibit_Fail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReadOnlyCollectionPropertyProhibit { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReadOnlyCollectionProperty_Prohibit_Fail_Map() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReadOnlyCollectionPropertyProhibit { Prohibit = null } + ); + } + + [Test] + public void TestPack_NullableValueType_ProhibitWillFail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { Prohibit = null } + ); + } + + [Test] + public void TestPack_NullableValueType_ProhibitWillFail_Map() + { + TestPackFail( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReferenceType_ProhibitWillFail_Array() + { + TestPackFail( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { Prohibit = null } + ); + } + + [Test] + public void TestPack_ReferenceType_ProhibitWillFail_Map() + { + TestPackFail( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { Prohibit = null } + ); + } + + // ------ Unpacking ------ + + + private void TestUnpackSuccess( + SerializationMethod method, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, () => new T(), null, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func inputFactory, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, inputFactory, null, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func packedStreamFactory, + Action assertion + ) + where T : new() + { + this.TestUnpackSuccess( method, () => new T(), packedStreamFactory, assertion ); + } + + private void TestUnpackSuccess( + SerializationMethod method, + Func inputFactory, + Func packedStreamFactory, + Action assertion + ) + where T : new() + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + if ( packedStreamFactory != null ) + { + var bytes = packedStreamFactory(); + buffer.Write( bytes, 0, bytes.Length ); + } + else + { + seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ); + } + + buffer.Position = 0; + assertion( seraizlier.Unpack( buffer ), new T() ); + } + } + + private void TestUnpackFail( + SerializationMethod method, + Func packedStreamFactory + ) + where T : new() + where TException : Exception + { + this.TestUnpackingFail( method, null, packedStreamFactory ); + } + + private void TestUnpackingFail( + SerializationMethod method, + Func inputFactory, + Func packedStreamFactory + ) + where T : new() + where TException : Exception + { + var context = this.CreateSerializationContext(); + context.SerializationMethod = method; + var seraizlier = CreateTarget( context ); + + using ( var buffer = new MemoryStream() ) + { + if ( packedStreamFactory != null ) + { + var bytes = packedStreamFactory(); + buffer.Write( bytes, 0, bytes.Length ); + } + else + { + seraizlier.Pack( buffer, inputFactory == null ? new T() : inputFactory() ); + } + + buffer.Position = 0; + Assert.Throws( () => seraizlier.Unpack( buffer ) ); + } + } + + [Test] + public void TestUnpack_ValueType_MemberDefault_Preserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ValueType_MemberDefault_Preserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ValueType_Prohibit_Fail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ValueType_Prohibit_Fail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => new byte[] { 0x81, ( byte )( 0xA0 + "Prohibit".Length ) }.Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray() + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_MemberDefault_Preserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_MemberDefault_Preserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new byte[] { 0x81, ( byte )( 0xA0 + ( "MemberDefault".Length ) ) }.Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray(), + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_Prohibit_Fail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x91, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ReadOnlyCollectionProperty_Prohibit_Fail_Map() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x81, ( byte )( 0xA0 + ( "Prohibit".Length ) ) }.Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ).ToArray() + ); + } + + [Test] + public void TestUnpack_NullableValueType_MemberDefaultWillBePreserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_MemberDefaultWillBePreserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_NullWillBeNull_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForNullableValueType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_NullWillBeNull_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForNullableValueType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_NullableValueType_ProhibitWillFail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x93, 0xC0, 0xC0, 0xC0 } + ); + } + + [Test] + public void TestUnpack_NullableValueType_ProhibitWillFail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => + new byte[] { 0x83 } + .Concat( new[] { ( byte )( 0xA0 + ( "MemberDefault".Length ) ) } ) + .Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Null".Length ) ) } ) + .Concat( "Null".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Prohibit".Length ) ) } ) + .Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .ToArray() + ); + } + + [Test] + public void TestUnpack_ReferenceType_MemberDefaultWillBePreserved_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_MemberDefaultWillBePreserved_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { MemberDefault = null }, + ( actual, @default ) => Assert.That( actual.MemberDefault, Is.EqualTo( @default.MemberDefault ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_NullWillBeNull_Array() + { + TestUnpackSuccess( + SerializationMethod.Array, + () => new NilImplicationTestTargetForReferenceType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_NullWillBeNull_Map() + { + TestUnpackSuccess( + SerializationMethod.Map, + () => new NilImplicationTestTargetForReferenceType { Null = null }, + ( actual, @default ) => Assert.That( actual.Null, Is.Null.And.Not.EqualTo( @default.Null ) ) + ); + } + + [Test] + public void TestUnpack_ReferenceType_ProhibitWillFail_Array() + { + TestUnpackFail( + SerializationMethod.Array, + () => new byte[] { 0x93, 0xC0, 0xC0, 0xC0 } + ); + } + + [Test] + public void TestUnpack_ReferenceType_ProhibitWillFail_Map() + { + TestUnpackFail( + SerializationMethod.Map, + () => + new byte[] { 0x83 } + .Concat( new[] { ( byte )( 0xA0 + ( "MemberDefault".Length ) ) } ) + .Concat( "MemberDefault".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Null".Length ) ) } ) + .Concat( "Null".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .Concat( new[] { ( byte )( 0xA0 + ( "Prohibit".Length ) ) } ) + .Concat( "Prohibit".ToCharArray().Select( c => ( byte )c ) ).Concat( new byte[] { 0xC0 } ) + .ToArray() + ); + } + + [Test] + public void TestElelementMissingInTheFirstPlace_Map_MissingMembersAreSkipped() + { + using ( var buffer = new MemoryStream() ) + { + var valueOfValue1 = "123"; + using ( var packer = Packer.Create( buffer, false ) ) + { + packer.PackMapHeader( 1 ); + packer.PackString( "Value1" ); + packer.PackString( valueOfValue1 ); + } + + buffer.Position = 0; + + var context = this.CreateSerializationContext(); + context.SerializationMethod = SerializationMethod.Map; + var target = CreateTarget( context ); + var result = target.Unpack( buffer ); + + Assert.That( result.Value1, Is.EqualTo( valueOfValue1 ) ); + Assert.That( result.Value2, Is.EqualTo( new ComplexTypeWithTwoMember().Value2 ) ); + } + } + + [Test] + public void TestElelementTooManyInTheFirstPlace_Map_ExtrasAreIgnored() + { + using ( var buffer = new MemoryStream() ) + { + const string valueOfValue1 = "123"; + const string valueOfValue2 = "234"; + const string valueOfValue3 = "345"; + using ( var packer = Packer.Create( buffer, false ) ) + { + packer.PackMapHeader( 3 ); + packer.PackString( "Value1" ); + packer.PackString( valueOfValue1 ); + packer.PackString( "Value2" ); + packer.PackString( valueOfValue2 ); + packer.PackString( "Value3" ); + packer.PackString( valueOfValue3 ); + } + + buffer.Position = 0; + + var context = this.CreateSerializationContext(); + context.SerializationMethod = SerializationMethod.Map; + var target = CreateTarget( context ); + var result = target.Unpack( buffer ); + + Assert.That( result.Value1, Is.EqualTo( valueOfValue1 ) ); + Assert.That( result.Value2, Is.EqualTo( valueOfValue2 ) ); + } + } + } +} diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.tt b/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.tt new file mode 100644 index 000000000..140f1e573 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/VisualBasicCodeTreeBasedNilImplicationTest.tt @@ -0,0 +1,14 @@ +<#@ template hostSpecific="false" #> +<#@ output extension=".cs" #> +<#@ include file="..\..\MsgPack.UnitTest\Serialization\NilImplicationTest.ttinclude" #> +<#@ Assembly Name="System.Core" #> +<#@ Assembly Name="System.Windows.Forms" #> +<#@ import namespace="System" #> +<#@ import namespace="System.IO" #> +<#@ import namespace="System.Diagnostics" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Collections" #> +<#@ import namespace="System.Collections.Generic" #> +<# +Geneate( "CodeTreeBased", "VisualBasic" ); +#> diff --git a/test/MsgPack.UnitTest.CodeTree/Serialization/_SetUpFixture.cs b/test/MsgPack.UnitTest.CodeTree/Serialization/_SetUpFixture.cs new file mode 100644 index 000000000..0db2fd50d --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/Serialization/_SetUpFixture.cs @@ -0,0 +1,50 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.Diagnostics.Contracts; +using System.Linq; +using System.Text; +#if !MSTEST +using NUnit.Framework; +#else +using TestFixtureAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute; +using TestAttribute = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute; +using TimeoutAttribute = NUnit.Framework.TimeoutAttribute; +using Assert = NUnit.Framework.Assert; +using Is = NUnit.Framework.Is; +#endif + +namespace MsgPack.Serialization +{ +#if !MSTEST + [CLSCompliant( false )] + public sealed class _SetUpFixture + { + [SetUp] + public void SetupCurrentNamespaceTests() + { + Contract.ContractFailed += ( sender, e ) => e.SetUnwind(); + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + } + } +#endif +} \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/app.config b/test/MsgPack.UnitTest.CodeTree/app.config new file mode 100644 index 000000000..015909c49 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/app.config @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/test/MsgPack.UnitTest.CodeTree/packages.config b/test/MsgPack.UnitTest.CodeTree/packages.config new file mode 100644 index 000000000..3271c7831 --- /dev/null +++ b/test/MsgPack.UnitTest.CodeTree/packages.config @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/test/MsgPack.UnitTest.Mono/MsgPack.UnitTest.Mono.csproj b/test/MsgPack.UnitTest.Mono/MsgPack.UnitTest.Mono.csproj index 57a9866d2..b4672fba9 100644 --- a/test/MsgPack.UnitTest.Mono/MsgPack.UnitTest.Mono.csproj +++ b/test/MsgPack.UnitTest.Mono/MsgPack.UnitTest.Mono.csproj @@ -1733,6 +1733,9 @@ Serialization\StringKeyedCollection.cs + + Serialization\TempFileDependentAssemblyManager.cs + Serialization\TestValueType.cs @@ -1757,6 +1760,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Net35/MsgPack.UnitTest.Net35.csproj b/test/MsgPack.UnitTest.Net35/MsgPack.UnitTest.Net35.csproj index 86c7e270a..0ca4250a9 100644 --- a/test/MsgPack.UnitTest.Net35/MsgPack.UnitTest.Net35.csproj +++ b/test/MsgPack.UnitTest.Net35/MsgPack.UnitTest.Net35.csproj @@ -326,6 +326,9 @@ Serialization\StringKeyedCollection.cs + + Serialization\TempFileDependentAssemblyManager.cs + Serialization\TestValueType.cs @@ -350,6 +353,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj index bada802a5..c00df1ec6 100644 --- a/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj +++ b/test/MsgPack.UnitTest.Silverlight.WindowsPhone/MsgPack.UnitTest.Silverlight.WindowsPhone.csproj @@ -327,6 +327,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj index ad62213c9..7f1352914 100644 --- a/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj +++ b/test/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop/MsgPack.UnitTest.Unity.Il2cpp.Full.Desktop.csproj @@ -660,6 +660,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj index abec3bb42..6b840b41f 100644 --- a/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj +++ b/test/MsgPack.UnitTest.Uwp.Aot/MsgPack.UnitTest.Uwp.Aot.csproj @@ -1805,6 +1805,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj index c875552d0..09ff57633 100644 --- a/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj +++ b/test/MsgPack.UnitTest.Uwp/MsgPack.UnitTest.Uwp.csproj @@ -1784,6 +1784,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs @@ -1896,11 +1899,6 @@ - - - ..\..\src\MsgPack.CoreClr\bin\Debug\netstandard1.3\MsgPack.dll - - @@ -1916,6 +1914,16 @@ Designer + + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization + + 14.0 diff --git a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj index 67d2bd1e7..6e46a9327 100644 --- a/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj +++ b/test/MsgPack.UnitTest.WinRT.WindowsPhone/MsgPack.UnitTest.WinRT.WindowsPhone.csproj @@ -335,6 +335,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs @@ -446,9 +449,13 @@ - - {a1b322fc-aa39-4894-afa8-ab427a3fba09} - NetStandardProjectBuilder + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization {fc521316-ebcd-4ef1-8235-c976b2a31eb0} @@ -458,12 +465,6 @@ - - - False - ..\..\src\MsgPack.CoreClr\bin\Debug\netstandard1.1\MsgPack.dll - - 12.0 diff --git a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj index 04cba6b53..17d3e5bfc 100644 --- a/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj +++ b/test/MsgPack.UnitTest.WinRT/MsgPack.UnitTest.WinRT.csproj @@ -376,6 +376,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs @@ -498,9 +501,13 @@ - - {a1b322fc-aa39-4894-afa8-ab427a3fba09} - NetStandardProjectBuilder + + {08d9a49d-736e-4cad-919e-72ca8c1d4a9f} + MsgPack.Core + + + {153ced68-9905-4b1f-9790-f463840895e2} + MsgPack.Serialization {fc521316-ebcd-4ef1-8235-c976b2a31eb0} diff --git a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj index ff4e8801e..3de6c9c68 100644 --- a/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj +++ b/test/MsgPack.UnitTest.Xamarin.Android/MsgPack.UnitTest.Xamarin.Android.csproj @@ -1747,6 +1747,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj index 8fc94fff8..2623d4e00 100644 --- a/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj +++ b/test/MsgPack.UnitTest.Xamarin.iOS/MsgPack.UnitTest.Xamarin.iOS.csproj @@ -1799,6 +1799,9 @@ SplittingStream.cs + + StreamExtensions.cs + SubtreeUnpackerTest.cs diff --git a/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj b/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj index 53b7174a3..4056d7fb3 100644 --- a/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj +++ b/test/MsgPack.UnitTest/MsgPack.UnitTest.csproj @@ -576,6 +576,11 @@ + + True + True + ArrayReflectionBasedAutoMessagePackSerializerTest.tt + @@ -656,11 +661,6 @@ - - ArrayReflectionBasedAutoMessagePackSerializerTest.tt - True - True - ArrayReflectionBasedEnumSerializationTest.tt True @@ -770,6 +770,7 @@ + @@ -794,6 +795,7 @@ True + True diff --git a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs index 94bb272da..dba92a099 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs @@ -48,10 +48,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -120,11 +122,14 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -135,7 +140,8 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -146,6 +152,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -162,8 +170,9 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedEnumSerializationTest.cs index c7dff8434..1a3f8011a 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedEnumSerializationTest.cs @@ -29,9 +29,12 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +63,11 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +77,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +89,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +105,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs index 2f70be5cc..fb27bed16 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs @@ -48,10 +48,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else diff --git a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs index 5a36139d0..07180e3ce 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs @@ -48,10 +48,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -120,11 +122,14 @@ private bool CanDump get { return false; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -135,7 +140,8 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -146,6 +152,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -162,8 +170,9 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedEnumSerializationTest.cs index 653422d78..9f070de31 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedEnumSerializationTest.cs @@ -29,9 +29,12 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +63,11 @@ private bool CanDump get { return false; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +77,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +89,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +105,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude index 4d5282cab..df8dbc397 100644 --- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude +++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude @@ -1,18 +1,18 @@ <#@include file="AutoMessagePackSerializerTest.Polymorphism.ttinclude" #> <#+ -void Geneate( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump ) +void Geneate( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump, string language = "" ) { - GenerateCore( serializationMethod, emitterFlavor, builderTypeName, canDump, false ); + GenerateCore( serializationMethod, emitterFlavor, builderTypeName, language, canDump, false ); } void GeneateForIos( string serializationMethod ) { - GenerateCore( serializationMethod, "GenerationBased", null, false, true ); + GenerateCore( serializationMethod, "GenerationBased", null, String.Empty, false, true ); } -private void GenerateCore( string serializationMethod, string emitterFlavor, string builderTypeName, bool canDump, bool forIos ) +private void GenerateCore( string serializationMethod, string emitterFlavor, string builderTypeName, string language, bool canDump, bool forIos ) { - var testClassName = serializationMethod + emitterFlavor + ( String.IsNullOrWhiteSpace( builderTypeName ) ? "Reflection" : "Auto" ) + "MessagePackSerializerTest"; + var testClassName = serializationMethod + language + emitterFlavor + ( String.IsNullOrWhiteSpace( builderTypeName ) ? "Reflection" : "Auto" ) + "MessagePackSerializerTest"; var constructorParamterSpecs = new [] @@ -88,10 +88,14 @@ using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -200,7 +204,7 @@ namespace MsgPack.Serialization get { return <#= canDump.ToString().ToLowerInvariant() #>; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { @@ -213,7 +217,10 @@ namespace MsgPack.Serialization <#+ } #> + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -224,7 +231,17 @@ namespace MsgPack.Serialization Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + +<#+ + if ( emitterFlavor == "CodeTreeBased" || emitterFlavor == "CodeDomBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new <#= language #><#= builderTypeName #>( t, c ) ); +<#+ + } +#> SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -235,6 +252,8 @@ namespace MsgPack.Serialization [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -251,8 +270,17 @@ namespace MsgPack.Serialization } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; +<#+ + if ( emitterFlavor == "CodeDomBased" || emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); +<#+ + } +#> } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 <#+ diff --git a/test/MsgPack.UnitTest/Serialization/CompositeTest.cs b/test/MsgPack.UnitTest/Serialization/CompositeTest.cs index 0a8b23cf4..4d4f7af3d 100644 --- a/test/MsgPack.UnitTest/Serialization/CompositeTest.cs +++ b/test/MsgPack.UnitTest/Serialization/CompositeTest.cs @@ -26,7 +26,11 @@ using System.Globalization; using System.IO; using MsgPack.Serialization.AbstractSerializers; +#if !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; #if !MSTEST using NUnit.Framework; @@ -41,7 +45,11 @@ namespace MsgPack.Serialization { [TestFixture] +#if !NETSTANDARD1_3 public class CompositeTest +#else + public class CodeTreeCompositeTest +#endif { [SetUp] public void SetUp() @@ -55,8 +63,12 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - - SerializerDebugging.OnTheFlyCodeDomEnabled = true; + +#if !NETSTANDARD1_3 + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); +#else + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeTreeSerializerBuilder( t, c ) ); +#endif SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); } @@ -76,7 +88,7 @@ public void TearDown() } SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } [Test] diff --git a/test/MsgPack.UnitTest/Serialization/EnumSerializationTest.ttinclude b/test/MsgPack.UnitTest/Serialization/EnumSerializationTest.ttinclude index bbe1f9513..3429ed541 100644 --- a/test/MsgPack.UnitTest/Serialization/EnumSerializationTest.ttinclude +++ b/test/MsgPack.UnitTest/Serialization/EnumSerializationTest.ttinclude @@ -1,5 +1,5 @@ <#+ -private void GenerateCore( string serializationMethod, string emitterFlavor, bool canDump, bool forIos ) +private void GenerateCore( string serializationMethod, string emitterFlavor, bool canDump, bool forIos, string language = "" ) { var testCases = new [] @@ -99,9 +99,14 @@ using System.Threading.Tasks; if ( !forIos ) { #> -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT <#+ } #> @@ -120,7 +125,7 @@ namespace MsgPack.Serialization { [TestFixture] [Timeout( 30000 )] - public class <#= serializationMethod #><#= emitterFlavor #>EnumSerializerTest + public class <#= serializationMethod #><#= language #><#= emitterFlavor #>EnumSerializerTest { private SerializationContext GetSerializationContext() { @@ -150,7 +155,7 @@ namespace MsgPack.Serialization get { return <#= canDump.ToString().ToLowerInvariant() #>; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { @@ -163,6 +168,7 @@ namespace MsgPack.Serialization <#+ } #> +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -172,8 +178,24 @@ namespace MsgPack.Serialization Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +<#+ + if ( emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new <#= language #>CodeTreeSerializerBuilder( t, c ) ); +<#+ + } + else if ( emitterFlavor == "CodeDomBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); +<#+ + } +#> SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -184,6 +206,7 @@ namespace MsgPack.Serialization [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -199,9 +222,17 @@ namespace MsgPack.Serialization SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; +<#+ + if ( emitterFlavor == "CodeDomBased" || emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); +<#+ + } +#> } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 <#+ diff --git a/test/MsgPack.UnitTest/Serialization/FieldBasedNilImplicationTest.cs b/test/MsgPack.UnitTest/Serialization/FieldBasedNilImplicationTest.cs index 37654330c..352c26cb0 100644 --- a/test/MsgPack.UnitTest/Serialization/FieldBasedNilImplicationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/FieldBasedNilImplicationTest.cs @@ -24,9 +24,12 @@ using System.IO; using System.Linq; using System.Runtime.Serialization; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -53,7 +56,7 @@ private MessagePackSerializer CreateTarget( SerializationContext context ) { return MessagePackSerializer.CreateInternal( context, PolymorphismSchema.Default ); } -#if !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT && !UNITY #if MSTEST [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] @@ -66,6 +69,7 @@ public void Initialize( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.Te #endif public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,8 +79,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) { @@ -87,6 +91,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled ) { try @@ -98,9 +103,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/GenerationBasedNilImplicationTest.cs b/test/MsgPack.UnitTest/Serialization/GenerationBasedNilImplicationTest.cs index 25d8d6daa..15963883f 100644 --- a/test/MsgPack.UnitTest/Serialization/GenerationBasedNilImplicationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/GenerationBasedNilImplicationTest.cs @@ -24,9 +24,12 @@ using System.IO; using System.Linq; using System.Runtime.Serialization; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else diff --git a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs index 64d8db3a3..516f6842c 100644 --- a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs @@ -49,10 +49,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -121,11 +123,14 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -136,7 +141,8 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -147,6 +153,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -163,8 +171,9 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/MapFieldBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest/Serialization/MapFieldBasedEnumSerializationTest.cs index b59a9c1c9..dc12e1916 100644 --- a/test/MsgPack.UnitTest/Serialization/MapFieldBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapFieldBasedEnumSerializationTest.cs @@ -29,9 +29,12 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +63,11 @@ private bool CanDump get { return true; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +77,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +89,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +105,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs index 3493664b5..374f0ef09 100644 --- a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs @@ -48,10 +48,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else diff --git a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs index 8640db4eb..206ee14ea 100644 --- a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs @@ -49,10 +49,12 @@ using System.Threading; using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -121,11 +123,14 @@ private bool CanDump get { return false; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { + +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); + SerializerDebugging.DumpDirectory = TestContext.CurrentContext.WorkDirectory; //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -136,7 +141,8 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -147,6 +153,8 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 + if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -163,8 +171,9 @@ public void TearDown() } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 + SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedEnumSerializationTest.cs b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedEnumSerializationTest.cs index 91a882232..843a0d18b 100644 --- a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedEnumSerializationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedEnumSerializationTest.cs @@ -29,9 +29,12 @@ using System.Threading.Tasks; #endif // FEATURE_TAP -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -60,10 +63,11 @@ private bool CanDump get { return false; } } -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT [SetUp] public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -73,8 +77,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -85,6 +89,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled && this.CanDump ) { try @@ -100,9 +105,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 private static void TestEnumForByNameCore( Stream stream, T value, T deserialized, string property ) diff --git a/test/MsgPack.UnitTest/Serialization/NilImplicationTest.ttinclude b/test/MsgPack.UnitTest/Serialization/NilImplicationTest.ttinclude index dc6064187..6d651e131 100644 --- a/test/MsgPack.UnitTest/Serialization/NilImplicationTest.ttinclude +++ b/test/MsgPack.UnitTest/Serialization/NilImplicationTest.ttinclude @@ -1,15 +1,15 @@ <#+ -void Geneate( string emitterFlavor ) +void Geneate( string emitterFlavor, string language = "" ) { - GenerateCore( emitterFlavor, false ); + GenerateCore( emitterFlavor, language, false ); } void GeneateForIos() { - GenerateCore( "GenerationBased", true ); + GenerateCore( "GenerationBased", "", true ); } -private void GenerateCore( string emitterFlavor, bool forIos ) +private void GenerateCore( string emitterFlavor, string language, bool forIos ) { #> #region -- License Terms -- @@ -37,9 +37,14 @@ using System.Diagnostics; using System.IO; using System.Linq; using System.Runtime.Serialization; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -53,7 +58,7 @@ using Is = NUnit.Framework.Is; namespace MsgPack.Serialization { [TestFixture] - public class <#= emitterFlavor #>NilImplicationTest + public class <#= language #><#= emitterFlavor #>NilImplicationTest { private SerializationContext CreateSerializationContext() { @@ -96,7 +101,7 @@ namespace MsgPack.Serialization if ( !forIos ) { #> -#if !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT && !UNITY #if MSTEST [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] @@ -109,6 +114,7 @@ namespace MsgPack.Serialization #endif public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -118,8 +124,24 @@ namespace MsgPack.Serialization Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +<#+ + if ( emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new <#= language #>CodeTreeSerializerBuilder( t, c ) ); +<#+ + } + else if ( emitterFlavor == "CodeDomBased" ) + { +#> + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager( TestContext.CurrentContext.TestDirectory ); + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); +<#+ + } +#> SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) { @@ -130,6 +152,7 @@ namespace MsgPack.Serialization [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled ) { try @@ -141,9 +164,17 @@ namespace MsgPack.Serialization SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; +<#+ + if ( emitterFlavor == "CodeDomBased" || emitterFlavor == "CodeTreeBased" ) + { +#> + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); +<#+ + } +#> } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 <#+ diff --git a/test/MsgPack.UnitTest/Serialization/ReflectionBasedNilImplicationTest.cs b/test/MsgPack.UnitTest/Serialization/ReflectionBasedNilImplicationTest.cs index 77407e3ad..5d8e804de 100644 --- a/test/MsgPack.UnitTest/Serialization/ReflectionBasedNilImplicationTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ReflectionBasedNilImplicationTest.cs @@ -24,9 +24,12 @@ using System.IO; using System.Linq; using System.Runtime.Serialization; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; #else @@ -53,7 +56,7 @@ private MessagePackSerializer CreateTarget( SerializationContext context ) { return MessagePackSerializer.CreateInternal( context, PolymorphismSchema.Default ); } -#if !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT && !UNITY #if MSTEST [Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestInitialize] @@ -66,6 +69,7 @@ public void Initialize( Microsoft.VisualStudio.TestPlatform.UnitTestFramework.Te #endif public void SetUp() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.DeletePastTemporaries(); //SerializerDebugging.TraceEnabled = true; //SerializerDebugging.DumpEnabled = true; @@ -75,8 +79,8 @@ public void SetUp() Tracer.Emit.Switch.Level = SourceLevels.All; Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 - SerializerDebugging.OnTheFlyCodeDomEnabled = true; SerializerDebugging.AddRuntimeAssembly( this.GetType().Assembly.Location ); if ( this.GetType().Assembly != typeof( NilImplicationTestTargetForValueTypeMemberDefault ).Assembly ) { @@ -87,6 +91,7 @@ public void SetUp() [TearDown] public void TearDown() { +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 if ( SerializerDebugging.DumpEnabled ) { try @@ -98,9 +103,9 @@ public void TearDown() SerializationMethodGeneratorManager.Refresh(); } } +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; } #endif // !SILVERLIGHT && !AOT && !UNITY && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/TempFileDependentAssemblyManager.cs b/test/MsgPack.UnitTest/Serialization/TempFileDependentAssemblyManager.cs new file mode 100644 index 000000000..c2a0b1522 --- /dev/null +++ b/test/MsgPack.UnitTest/Serialization/TempFileDependentAssemblyManager.cs @@ -0,0 +1,133 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Threading; + +namespace MsgPack.Serialization +{ + internal sealed class TempFileDependentAssemblyManager : DependentAssemblyManager + { + private static int _wasDeleted; + private const string HistoryFile = "MsgPack.Serialization.SerializationGenerationDebugging.CodeDOM.History.txt"; + +#if NETSTANDARD1_3 + private readonly string _baseDirectory; + + public TempFileDependentAssemblyManager( string baseDirectory ) + { + this._baseDirectory = baseDirectory; + this.ResetDependentAssemblies(); + } + +#endif // NETSTANDARD1_3 + + protected override void Record( IEnumerable assemblies ) + { +#if !NETFX_35 && !UNITY + File.AppendAllLines( GetHistoryFilePath(), assemblies ); +#else + File.AppendAllText( GetHistoryFilePath(), String.Join( Environment.NewLine, assemblies.ToArray() ) + Environment.NewLine ); +#endif // !NETFX_35 && !UNITY + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For unit testing" )] + private static string GetHistoryFilePath() + { + return Path.Combine( Path.GetTempPath(), HistoryFile ); + } + + public override void DeletePastTemporaries() + { + if ( Interlocked.CompareExchange( ref _wasDeleted, 1, 0 ) != 0 ) + { + return; + } + + try + { + var historyFilePath = GetHistoryFilePath(); + if ( !File.Exists( historyFilePath ) ) + { + return; + } + + foreach ( var pastAssembly in File.ReadAllLines( historyFilePath ) ) + { + if ( !String.IsNullOrEmpty( pastAssembly ) ) + { + File.Delete( pastAssembly ); + } + } + + new FileStream( historyFilePath, FileMode.Truncate ).Close(); + } + catch ( IOException ) { } + } + + public override Assembly LoadAssembly( string path ) + { + return Assembly.LoadFrom( path ); + } + + protected override IEnumerable GetRuntimeAssemblies() + { +#if NETSTANDARD1_3 + if ( this._baseDirectory == null ) + { + yield break; + } + + // TODO: X-Plat + var referenceAssemblyDirectory = Path.Combine( Environment.GetFolderPath( Environment.SpecialFolder.ProgramFilesX86 ), @"Reference Assemblies\Microsoft\Framework\.NETCore\v4.5.1" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Runtime.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Collections.dll" ); + yield return Path.Combine( this._baseDirectory, "System.Collections.NonGeneric.dll" ); + yield return Path.Combine( this._baseDirectory, "System.Collections.Specialized.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Diagnostics.Debug.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Diagnostics.Tools.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Globalization.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Linq.dll" ); + yield return Path.Combine( this._baseDirectory, "System.Numerics.Vectors.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Reflection.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Reflection.Extensions.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Reflection.Primitives.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Runtime.Extensions.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Runtime.Numerics.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Runtime.Serialization.Primitives.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Threading.dll" ); + yield return Path.Combine( referenceAssemblyDirectory, "System.Threading.Tasks.dll" ); + yield return Path.Combine( this._baseDirectory, "MsgPack.Core.dll" ); + yield return Path.Combine( this._baseDirectory, "MsgPack.Serialization.dll" ); +#else + yield return typeof( Stack<> ).Assembly.Location; // System.dll +#if NETFX_35 + yield return typeof( Enumerable ).Assembly.Location ]; // System.Core.dll +#else + yield return typeof( Action<,,,,,,,,,,> ).Assembly.Location; // System.Core.dll + yield return typeof( System.Numerics.BigInteger ).Assembly.Location; // System.Numerics.dll +#endif // NETFX_35 +#endif // NETSTANDARD1_1 + } + } +} \ No newline at end of file diff --git a/test/MsgPack.UnitTest/Serialization/VersioningTest.cs b/test/MsgPack.UnitTest/Serialization/VersioningTest.cs index 8297e961e..df447d2d6 100644 --- a/test/MsgPack.UnitTest/Serialization/VersioningTest.cs +++ b/test/MsgPack.UnitTest/Serialization/VersioningTest.cs @@ -24,9 +24,14 @@ #endif // !NETFX_CORE && !WINDOWS_PHONE && !XAMARIN && !UNITY_IPHONE && !UNITY_ANDROID using System.IO; -#if !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#if !SILVERLIGHT && !AOT +#if !NETSTANDARD1_1 && !NETSTANDARD1_3 +using MsgPack.Serialization.CodeDomSerializers; +#else +using MsgPack.Serialization.CodeTreeSerializers; +#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 using MsgPack.Serialization.EmittingSerializers; -#endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 +#endif // !SILVERLIGHT && !AOT #if !MSTEST using NUnit.Framework; @@ -58,7 +63,10 @@ public void SetUp() Tracer.Emit.Listeners.Add( new ConsoleTraceListener() ); } - SerializerDebugging.OnTheFlyCodeDomEnabled = true; +#if !NETSTANDARD1_3 + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( ( t, c ) => new CodeDomSerializerBuilder( t, c ) ); +#else +#endif // NETSTANDARD1_3 SerializerDebugging.AddRuntimeAssembly( typeof( AddOnlyCollection<> ).Assembly.Location ); if ( typeof( AddOnlyCollection<> ).Assembly != this.GetType().Assembly ) { @@ -86,7 +94,7 @@ public void TearDown() } SerializerDebugging.Reset(); - SerializerDebugging.OnTheFlyCodeDomEnabled = false; + SerializerDebugging.SetOnTheFlyCodeGenerationBuilderFactory( null ); } #endif // !SILVERLIGHT && !AOT && !NETSTANDARD1_1 && !NETSTANDARD1_3 diff --git a/test/MsgPack.UnitTest/Serialization/_SetUpFixture.cs b/test/MsgPack.UnitTest/Serialization/_SetUpFixture.cs index f83bd12fc..64848f6ab 100644 --- a/test/MsgPack.UnitTest/Serialization/_SetUpFixture.cs +++ b/test/MsgPack.UnitTest/Serialization/_SetUpFixture.cs @@ -2,7 +2,7 @@ // // MessagePack for CLI // -// Copyright (C) 2010-2012 FUJIWARA, Yusuke +// Copyright (C) 2010-2016 FUJIWARA, Yusuke // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -42,7 +42,9 @@ public sealed class _SetUpFixture [SetUp] public void SetupCurrentNamespaceTests() { + var b = "a" == "A"; Contract.ContractFailed += ( sender, e ) => e.SetUnwind(); + SerializerDebugging.DependentAssemblyManager = new TempFileDependentAssemblyManager(); } } #endif diff --git a/test/MsgPack.UnitTest/StreamExtensions.cs b/test/MsgPack.UnitTest/StreamExtensions.cs new file mode 100644 index 000000000..85aa68046 --- /dev/null +++ b/test/MsgPack.UnitTest/StreamExtensions.cs @@ -0,0 +1,80 @@ +#region -- License Terms -- +// +// MessagePack for CLI +// +// Copyright (C) 2010-2016 FUJIWARA, Yusuke +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#endregion -- License Terms -- + +using System; +using System.IO; + +namespace MsgPack +{ + internal static class StreamExtensions + { + public static void Write( this Stream source, byte[] buffer ) + { + if ( source == null ) + { + throw new ArgumentNullException( "source" ); + } + + if ( buffer == null ) + { + throw new ArgumentNullException( "buffer" ); + } + + source.Write( buffer, 0, buffer.Length ); + } + + public static void Feed( this Stream source, byte[] buffer ) + { + if ( source == null ) + { + throw new ArgumentNullException( "source" ); + } + + if ( buffer == null ) + { + throw new ArgumentNullException( "buffer" ); + } + + if ( !source.CanSeek ) + { + throw new NotSupportedException(); + } + + source.Write( buffer, 0, buffer.Length ); + source.Position -= buffer.Length; + } + + public static void Feed( this Stream source, byte value ) + { + if ( source == null ) + { + throw new ArgumentNullException( "source" ); + } + + if ( !source.CanSeek ) + { + throw new NotSupportedException(); + } + + source.WriteByte( value ); + source.Position--; + } + } +} \ No newline at end of file diff --git a/test/MsgPack.UnitTest/UnpackerTest.Skip.cs b/test/MsgPack.UnitTest/UnpackerTest.Skip.cs index 4fcf77f60..a7dc93af9 100644 --- a/test/MsgPack.UnitTest/UnpackerTest.Skip.cs +++ b/test/MsgPack.UnitTest/UnpackerTest.Skip.cs @@ -822,60 +822,4 @@ public async Task TestSkipAsync_BetweenSubtreeReader_NestedMap_AsIs() #endif // FEATURE_TAP } - - // TODO: NLiblet - internal static class StreamExtensions - { - public static void Write( this Stream source, byte[] buffer ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( buffer == null ) - { - throw new ArgumentNullException( "buffer" ); - } - - source.Write( buffer, 0, buffer.Length ); - } - - public static void Feed( this Stream source, byte[] buffer ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( buffer == null ) - { - throw new ArgumentNullException( "buffer" ); - } - - if ( !source.CanSeek ) - { - throw new NotSupportedException(); - } - - source.Write( buffer, 0, buffer.Length ); - source.Position -= buffer.Length; - } - - public static void Feed( this Stream source, byte value ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( !source.CanSeek ) - { - throw new NotSupportedException(); - } - - source.WriteByte( value ); - source.Position--; - } - } } diff --git a/test/MsgPack.UnitTest/UnpackerTest.Skip.tt b/test/MsgPack.UnitTest/UnpackerTest.Skip.tt index 2953ea5a8..851b97292 100644 --- a/test/MsgPack.UnitTest/UnpackerTest.Skip.tt +++ b/test/MsgPack.UnitTest/UnpackerTest.Skip.tt @@ -461,62 +461,6 @@ foreach( var isAsync in new [] { false, true } ) } #> } - - // TODO: NLiblet - internal static class StreamExtensions - { - public static void Write( this Stream source, byte[] buffer ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( buffer == null ) - { - throw new ArgumentNullException( "buffer" ); - } - - source.Write( buffer, 0, buffer.Length ); - } - - public static void Feed( this Stream source, byte[] buffer ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( buffer == null ) - { - throw new ArgumentNullException( "buffer" ); - } - - if ( !source.CanSeek ) - { - throw new NotSupportedException(); - } - - source.Write( buffer, 0, buffer.Length ); - source.Position -= buffer.Length; - } - - public static void Feed( this Stream source, byte value ) - { - if ( source == null ) - { - throw new ArgumentNullException( "source" ); - } - - if ( !source.CanSeek ) - { - throw new NotSupportedException(); - } - - source.WriteByte( value ); - source.Position--; - } - } } <#+