msgpack
diff --git a/‎test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs‎
Lines changed: 20 additions & 20 deletions b/‎test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs‎
Lines changed: 20 additions & 20 deletions
diff --git a/‎test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs‎
Lines changed: 20 additions & 20 deletions b/‎test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs‎
Lines changed: 20 additions & 20 deletions
@@ -1603,7 +1603,7 @@ public void TestHasInitOnlyFieldWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1656,7 +1656,7 @@ public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1814,7 +1814,7 @@ public void TestHasReadWriteFieldWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1867,7 +1867,7 @@ public void TestHasReadWriteFieldWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1978,7 +1978,7 @@ public void TestHasGetOnlyPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2031,7 +2031,7 @@ public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2189,7 +2189,7 @@ public void TestHasPrivateSetterPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2242,7 +2242,7 @@ public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2400,7 +2400,7 @@ public void TestHasPublicSetterPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2453,7 +2453,7 @@ public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2613,7 +2613,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success(
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2667,7 +2667,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Suc
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2828,7 +2828,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2882,7 +2882,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Su
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3043,7 +3043,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Succes
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3097,7 +3097,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_S
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3258,7 +3258,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3312,7 +3312,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstru
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3473,7 +3473,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_S
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3527,7 +3527,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstruc
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
 
@@ -1606,7 +1606,7 @@ public void TestHasInitOnlyFieldWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1661,7 +1661,7 @@ public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1825,7 +1825,7 @@ public void TestHasReadWriteFieldWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1880,7 +1880,7 @@ public void TestHasReadWriteFieldWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -1995,7 +1995,7 @@ public void TestHasGetOnlyPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2050,7 +2050,7 @@ public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2214,7 +2214,7 @@ public void TestHasPrivateSetterPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2269,7 +2269,7 @@ public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2433,7 +2433,7 @@ public void TestHasPublicSetterPropertyWithBothConstructor_Success()
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( "123" ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2488,7 +2488,7 @@ public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success()
 				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 );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2654,7 +2654,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success(
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2710,7 +2710,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Suc
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2877,7 +2877,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -2933,7 +2933,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Su
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3100,7 +3100,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Succes
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3156,7 +3156,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_S
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3323,7 +3323,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3379,7 +3379,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstru
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3546,7 +3546,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_S
 				var result = serializer.Unpack( stream );
 				// check the member value deserialized properly.
 				Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
 
@@ -3602,7 +3602,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstruc
 				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<string>() ) );
-				Assert.That( result.WasProperConstructorUsed );
+				Assert.That( result.WasProperConstructorUsed() );
 			}
 		}
Original file line number	Diff line number	Diff line change
`@@ -1603,7 +1603,7 @@ public void TestHasInitOnlyFieldWithBothConstructor_Success()`
`1603`	`1603`	`var result = serializer.Unpack( stream );`
`1604`	`1604`	`// check the member value deserialized properly.`
`1605`	`1605`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1606`		`- Assert.That( result.WasProperConstructorUsed );`
	`1606`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1607`	`1607`	`}`
`1608`	`1608`	`}`
`1609`	`1609`
`@@ -1656,7 +1656,7 @@ public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success()`
`1656`	`1656`	`var result = serializer.Unpack( stream );`
`1657`	`1657`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`1658`	`1658`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`1659`		`- Assert.That( result.WasProperConstructorUsed );`
	`1659`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1660`	`1660`	`}`
`1661`	`1661`	`}`
`1662`	`1662`
`@@ -1814,7 +1814,7 @@ public void TestHasReadWriteFieldWithBothConstructor_Success()`
`1814`	`1814`	`var result = serializer.Unpack( stream );`
`1815`	`1815`	`// check the member value deserialized properly.`
`1816`	`1816`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1817`		`- Assert.That( result.WasProperConstructorUsed );`
	`1817`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1818`	`1818`	`}`
`1819`	`1819`	`}`
`1820`	`1820`
`@@ -1867,7 +1867,7 @@ public void TestHasReadWriteFieldWithAnnotatedConstructor_Success()`
`1867`	`1867`	`var result = serializer.Unpack( stream );`
`1868`	`1868`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`1869`	`1869`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`1870`		`- Assert.That( result.WasProperConstructorUsed );`
	`1870`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1871`	`1871`	`}`
`1872`	`1872`	`}`
`1873`	`1873`
`@@ -1978,7 +1978,7 @@ public void TestHasGetOnlyPropertyWithBothConstructor_Success()`
`1978`	`1978`	`var result = serializer.Unpack( stream );`
`1979`	`1979`	`// check the member value deserialized properly.`
`1980`	`1980`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1981`		`- Assert.That( result.WasProperConstructorUsed );`
	`1981`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1982`	`1982`	`}`
`1983`	`1983`	`}`
`1984`	`1984`
`@@ -2031,7 +2031,7 @@ public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success()`
`2031`	`2031`	`var result = serializer.Unpack( stream );`
`2032`	`2032`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2033`	`2033`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2034`		`- Assert.That( result.WasProperConstructorUsed );`
	`2034`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2035`	`2035`	`}`
`2036`	`2036`	`}`
`2037`	`2037`
`@@ -2189,7 +2189,7 @@ public void TestHasPrivateSetterPropertyWithBothConstructor_Success()`
`2189`	`2189`	`var result = serializer.Unpack( stream );`
`2190`	`2190`	`// check the member value deserialized properly.`
`2191`	`2191`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`2192`		`- Assert.That( result.WasProperConstructorUsed );`
	`2192`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2193`	`2193`	`}`
`2194`	`2194`	`}`
`2195`	`2195`
`@@ -2242,7 +2242,7 @@ public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success()`
`2242`	`2242`	`var result = serializer.Unpack( stream );`
`2243`	`2243`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2244`	`2244`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2245`		`- Assert.That( result.WasProperConstructorUsed );`
	`2245`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2246`	`2246`	`}`
`2247`	`2247`	`}`
`2248`	`2248`
`@@ -2400,7 +2400,7 @@ public void TestHasPublicSetterPropertyWithBothConstructor_Success()`
`2400`	`2400`	`var result = serializer.Unpack( stream );`
`2401`	`2401`	`// check the member value deserialized properly.`
`2402`	`2402`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`2403`		`- Assert.That( result.WasProperConstructorUsed );`
	`2403`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2404`	`2404`	`}`
`2405`	`2405`	`}`
`2406`	`2406`
`@@ -2453,7 +2453,7 @@ public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success()`
`2453`	`2453`	`var result = serializer.Unpack( stream );`
`2454`	`2454`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2455`	`2455`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2456`		`- Assert.That( result.WasProperConstructorUsed );`
	`2456`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2457`	`2457`	`}`
`2458`	`2458`	`}`
`2459`	`2459`
`@@ -2613,7 +2613,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success(`
`2613`	`2613`	`var result = serializer.Unpack( stream );`
`2614`	`2614`	`// check the member value deserialized properly.`
`2615`	`2615`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`2616`		`- Assert.That( result.WasProperConstructorUsed );`
	`2616`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2617`	`2617`	`}`
`2618`	`2618`	`}`
`2619`	`2619`
`@@ -2667,7 +2667,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Suc`
`2667`	`2667`	`var result = serializer.Unpack( stream );`
`2668`	`2668`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2669`	`2669`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`2670`		`- Assert.That( result.WasProperConstructorUsed );`
	`2670`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2671`	`2671`	`}`
`2672`	`2672`	`}`
`2673`	`2673`
`@@ -2828,7 +2828,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success`
`2828`	`2828`	`var result = serializer.Unpack( stream );`
`2829`	`2829`	`// check the member value deserialized properly.`
`2830`	`2830`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`2831`		`- Assert.That( result.WasProperConstructorUsed );`
	`2831`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2832`	`2832`	`}`
`2833`	`2833`	`}`
`2834`	`2834`
`@@ -2882,7 +2882,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Su`
`2882`	`2882`	`var result = serializer.Unpack( stream );`
`2883`	`2883`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2884`	`2884`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`2885`		`- Assert.That( result.WasProperConstructorUsed );`
	`2885`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2886`	`2886`	`}`
`2887`	`2887`	`}`
`2888`	`2888`
`@@ -3043,7 +3043,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Succes`
`3043`	`3043`	`var result = serializer.Unpack( stream );`
`3044`	`3044`	`// check the member value deserialized properly.`
`3045`	`3045`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3046`		`- Assert.That( result.WasProperConstructorUsed );`
	`3046`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3047`	`3047`	`}`
`3048`	`3048`	`}`
`3049`	`3049`
`@@ -3097,7 +3097,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_S`
`3097`	`3097`	`var result = serializer.Unpack( stream );`
`3098`	`3098`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3099`	`3099`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3100`		`- Assert.That( result.WasProperConstructorUsed );`
	`3100`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3101`	`3101`	`}`
`3102`	`3102`	`}`
`3103`	`3103`
`@@ -3258,7 +3258,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_`
`3258`	`3258`	`var result = serializer.Unpack( stream );`
`3259`	`3259`	`// check the member value deserialized properly.`
`3260`	`3260`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3261`		`- Assert.That( result.WasProperConstructorUsed );`
	`3261`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3262`	`3262`	`}`
`3263`	`3263`	`}`
`3264`	`3264`
`@@ -3312,7 +3312,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstru`
`3312`	`3312`	`var result = serializer.Unpack( stream );`
`3313`	`3313`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3314`	`3314`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3315`		`- Assert.That( result.WasProperConstructorUsed );`
	`3315`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3316`	`3316`	`}`
`3317`	`3317`	`}`
`3318`	`3318`
`@@ -3473,7 +3473,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_S`
`3473`	`3473`	`var result = serializer.Unpack( stream );`
`3474`	`3474`	`// check the member value deserialized properly.`
`3475`	`3475`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3476`		`- Assert.That( result.WasProperConstructorUsed );`
	`3476`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3477`	`3477`	`}`
`3478`	`3478`	`}`
`3479`	`3479`
`@@ -3527,7 +3527,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstruc`
`3527`	`3527`	`var result = serializer.Unpack( stream );`
`3528`	`3528`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3529`	`3529`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3530`		`- Assert.That( result.WasProperConstructorUsed );`
	`3530`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3531`	`3531`	`}`
`3532`	`3532`	`}`
`3533`	`3533`
Original file line number	Diff line number	Diff line change
`@@ -1606,7 +1606,7 @@ public void TestHasInitOnlyFieldWithBothConstructor_Success()`
`1606`	`1606`	`var result = serializer.Unpack( stream );`
`1607`	`1607`	`// check the member value deserialized properly.`
`1608`	`1608`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1609`		`- Assert.That( result.WasProperConstructorUsed );`
	`1609`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1610`	`1610`	`}`
`1611`	`1611`	`}`
`1612`	`1612`
`@@ -1661,7 +1661,7 @@ public void TestHasInitOnlyFieldWithAnnotatedConstructor_Success()`
`1661`	`1661`	`var result = serializer.Unpack( stream );`
`1662`	`1662`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`1663`	`1663`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`1664`		`- Assert.That( result.WasProperConstructorUsed );`
	`1664`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1665`	`1665`	`}`
`1666`	`1666`	`}`
`1667`	`1667`
`@@ -1825,7 +1825,7 @@ public void TestHasReadWriteFieldWithBothConstructor_Success()`
`1825`	`1825`	`var result = serializer.Unpack( stream );`
`1826`	`1826`	`// check the member value deserialized properly.`
`1827`	`1827`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1828`		`- Assert.That( result.WasProperConstructorUsed );`
	`1828`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1829`	`1829`	`}`
`1830`	`1830`	`}`
`1831`	`1831`
`@@ -1880,7 +1880,7 @@ public void TestHasReadWriteFieldWithAnnotatedConstructor_Success()`
`1880`	`1880`	`var result = serializer.Unpack( stream );`
`1881`	`1881`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`1882`	`1882`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`1883`		`- Assert.That( result.WasProperConstructorUsed );`
	`1883`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1884`	`1884`	`}`
`1885`	`1885`	`}`
`1886`	`1886`
`@@ -1995,7 +1995,7 @@ public void TestHasGetOnlyPropertyWithBothConstructor_Success()`
`1995`	`1995`	`var result = serializer.Unpack( stream );`
`1996`	`1996`	`// check the member value deserialized properly.`
`1997`	`1997`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`1998`		`- Assert.That( result.WasProperConstructorUsed );`
	`1998`	`+ Assert.That( result.WasProperConstructorUsed() );`
`1999`	`1999`	`}`
`2000`	`2000`	`}`
`2001`	`2001`
`@@ -2050,7 +2050,7 @@ public void TestHasGetOnlyPropertyWithAnnotatedConstructor_Success()`
`2050`	`2050`	`var result = serializer.Unpack( stream );`
`2051`	`2051`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2052`	`2052`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2053`		`- Assert.That( result.WasProperConstructorUsed );`
	`2053`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2054`	`2054`	`}`
`2055`	`2055`	`}`
`2056`	`2056`
`@@ -2214,7 +2214,7 @@ public void TestHasPrivateSetterPropertyWithBothConstructor_Success()`
`2214`	`2214`	`var result = serializer.Unpack( stream );`
`2215`	`2215`	`// check the member value deserialized properly.`
`2216`	`2216`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`2217`		`- Assert.That( result.WasProperConstructorUsed );`
	`2217`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2218`	`2218`	`}`
`2219`	`2219`	`}`
`2220`	`2220`
`@@ -2269,7 +2269,7 @@ public void TestHasPrivateSetterPropertyWithAnnotatedConstructor_Success()`
`2269`	`2269`	`var result = serializer.Unpack( stream );`
`2270`	`2270`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2271`	`2271`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2272`		`- Assert.That( result.WasProperConstructorUsed );`
	`2272`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2273`	`2273`	`}`
`2274`	`2274`	`}`
`2275`	`2275`
`@@ -2433,7 +2433,7 @@ public void TestHasPublicSetterPropertyWithBothConstructor_Success()`
`2433`	`2433`	`var result = serializer.Unpack( stream );`
`2434`	`2434`	`// check the member value deserialized properly.`
`2435`	`2435`	`Assert.That( result.Member, Is.EqualTo( "123" ) );`
`2436`		`- Assert.That( result.WasProperConstructorUsed );`
	`2436`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2437`	`2437`	`}`
`2438`	`2438`	`}`
`2439`	`2439`
`@@ -2488,7 +2488,7 @@ public void TestHasPublicSetterPropertyWithAnnotatedConstructor_Success()`
`2488`	`2488`	`var result = serializer.Unpack( stream );`
`2489`	`2489`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2490`	`2490`	`Assert.That( result.Member, Is.EqualTo( "ABC" ) );`
`2491`		`- Assert.That( result.WasProperConstructorUsed );`
	`2491`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2492`	`2492`	`}`
`2493`	`2493`	`}`
`2494`	`2494`
`@@ -2654,7 +2654,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithBothConstructor_Success(`
`2654`	`2654`	`var result = serializer.Unpack( stream );`
`2655`	`2655`	`// check the member value deserialized properly.`
`2656`	`2656`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`2657`		`- Assert.That( result.WasProperConstructorUsed );`
	`2657`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2658`	`2658`	`}`
`2659`	`2659`	`}`
`2660`	`2660`
`@@ -2710,7 +2710,7 @@ public void TestHasInitOnlyAppendableCollectionFieldWithAnnotatedConstructor_Suc`
`2710`	`2710`	`var result = serializer.Unpack( stream );`
`2711`	`2711`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2712`	`2712`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`2713`		`- Assert.That( result.WasProperConstructorUsed );`
	`2713`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2714`	`2714`	`}`
`2715`	`2715`	`}`
`2716`	`2716`
`@@ -2877,7 +2877,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithBothConstructor_Success`
`2877`	`2877`	`var result = serializer.Unpack( stream );`
`2878`	`2878`	`// check the member value deserialized properly.`
`2879`	`2879`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`2880`		`- Assert.That( result.WasProperConstructorUsed );`
	`2880`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2881`	`2881`	`}`
`2882`	`2882`	`}`
`2883`	`2883`
`@@ -2933,7 +2933,7 @@ public void TestHasReadWriteAppendableCollectionFieldWithAnnotatedConstructor_Su`
`2933`	`2933`	`var result = serializer.Unpack( stream );`
`2934`	`2934`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`2935`	`2935`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`2936`		`- Assert.That( result.WasProperConstructorUsed );`
	`2936`	`+ Assert.That( result.WasProperConstructorUsed() );`
`2937`	`2937`	`}`
`2938`	`2938`	`}`
`2939`	`2939`
`@@ -3100,7 +3100,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithBothConstructor_Succes`
`3100`	`3100`	`var result = serializer.Unpack( stream );`
`3101`	`3101`	`// check the member value deserialized properly.`
`3102`	`3102`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3103`		`- Assert.That( result.WasProperConstructorUsed );`
	`3103`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3104`	`3104`	`}`
`3105`	`3105`	`}`
`3106`	`3106`
`@@ -3156,7 +3156,7 @@ public void TestHasGetOnlyAppendableCollectionPropertyWithAnnotatedConstructor_S`
`3156`	`3156`	`var result = serializer.Unpack( stream );`
`3157`	`3157`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3158`	`3158`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3159`		`- Assert.That( result.WasProperConstructorUsed );`
	`3159`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3160`	`3160`	`}`
`3161`	`3161`	`}`
`3162`	`3162`
`@@ -3323,7 +3323,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithBothConstructor_`
`3323`	`3323`	`var result = serializer.Unpack( stream );`
`3324`	`3324`	`// check the member value deserialized properly.`
`3325`	`3325`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3326`		`- Assert.That( result.WasProperConstructorUsed );`
	`3326`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3327`	`3327`	`}`
`3328`	`3328`	`}`
`3329`	`3329`
`@@ -3379,7 +3379,7 @@ public void TestHasPrivateSetterAppendableCollectionPropertyWithAnnotatedConstru`
`3379`	`3379`	`var result = serializer.Unpack( stream );`
`3380`	`3380`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3381`	`3381`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3382`		`- Assert.That( result.WasProperConstructorUsed );`
	`3382`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3383`	`3383`	`}`
`3384`	`3384`	`}`
`3385`	`3385`
`@@ -3546,7 +3546,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithBothConstructor_S`
`3546`	`3546`	`var result = serializer.Unpack( stream );`
`3547`	`3547`	`// check the member value deserialized properly.`
`3548`	`3548`	`Assert.That( result.Member, Is.EqualTo( new List<string>{ "123" } ) );`
`3549`		`- Assert.That( result.WasProperConstructorUsed );`
	`3549`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3550`	`3550`	`}`
`3551`	`3551`	`}`
`3552`	`3552`
`@@ -3602,7 +3602,7 @@ public void TestHasPublicSetterAppendableCollectionPropertyWithAnnotatedConstruc`
`3602`	`3602`	`var result = serializer.Unpack( stream );`
`3603`	`3603`	`// dummy annotated constructor does not take the value, so the deserialized value should be "default" of the type.`
`3604`	`3604`	`Assert.That( result.Member, Is.EqualTo( new List<string>() ) );`
`3605`		`- Assert.That( result.WasProperConstructorUsed );`
	`3605`	`+ Assert.That( result.WasProperConstructorUsed() );`
`3606`	`3606`	`}`
`3607`	`3607`	`}`
`3608`	`3608`