From e9815009dde61cabacdc87e81ce4c36334fecdd0 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 20 Aug 2026 09:32:43 +0000 Subject: [PATCH 1/3] Add tests for duplicate reference instance serialization Added DuplicateInstanceContainer, SharedClassItem, and SharedClassNested models along with a SharedReferenceInstancesRoundTrip unit test to verify serialization and view reading for shared reference type instances. --- tests/SerializationModels.cs | 21 +++++++++++++++++++++ tests/SerializationTests.cs | 27 +++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/tests/SerializationModels.cs b/tests/SerializationModels.cs index 6a8dfad..780f95d 100644 --- a/tests/SerializationModels.cs +++ b/tests/SerializationModels.cs @@ -294,6 +294,27 @@ public struct StrictBlittableStruct public int Value { get; init; } } +[ZeroSerializer] +public class DuplicateInstanceContainer +{ + public SharedClassItem? Foo { get; set; } + public SharedClassItem? Bar { get; set; } + public SharedClassItem? Baz { get; set; } +} + +[ZeroSerializer] +public class SharedClassItem +{ + public int Value { get; set; } + public SharedClassNested? Nested { get; set; } +} + +[ZeroSerializer] +public class SharedClassNested +{ + public int NestedValue { get; set; } +} + [ZeroSerializer] public record SimpleCsharpRecord { diff --git a/tests/SerializationTests.cs b/tests/SerializationTests.cs index fc25670..f9840ed 100644 --- a/tests/SerializationTests.cs +++ b/tests/SerializationTests.cs @@ -1228,4 +1228,31 @@ public void BlittableRecordStructNestedPropertyRoundTrip() TestAssert.True(viewNulls.Values.IsEmpty, nameof(viewNulls.Values.IsEmpty)); TestAssert.Equal(writtenBytesNulls, viewNulls.GetByteLength(), "Nulls GetByteLength"); } + + [Fact] + public void SharedReferenceInstancesRoundTrip() + { + var sharedNested = new SharedClassNested { NestedValue = 42 }; + var sharedItem = new SharedClassItem { Value = 100, Nested = sharedNested }; + var container = new DuplicateInstanceContainer + { + Foo = sharedItem, + Bar = sharedItem, + Baz = sharedItem, + }; + + var buffer = new byte[256]; + int writtenBytes = container.Serialize(buffer); + var view = new DuplicateInstanceContainerView(buffer.AsMemory(0, writtenBytes)); + + TestAssert.Equal(100, view.Foo.Value, nameof(view.Foo.Value)); + TestAssert.Equal(100, view.Bar.Value, nameof(view.Bar.Value)); + TestAssert.Equal(100, view.Baz.Value, nameof(view.Baz.Value)); + + TestAssert.Equal(42, view.Foo.Nested.NestedValue, nameof(view.Foo.Nested.NestedValue)); + TestAssert.Equal(42, view.Bar.Nested.NestedValue, nameof(view.Bar.Nested.NestedValue)); + TestAssert.Equal(42, view.Baz.Nested.NestedValue, nameof(view.Baz.Nested.NestedValue)); + + TestAssert.Equal(writtenBytes, view.GetByteLength(), "SharedReferenceInstances GetByteLength"); + } } From 286e91f2d3ee02f8ace7ff2a393f546c57084142 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 20 Aug 2026 10:01:20 +0000 Subject: [PATCH 2/3] Expand shared reference instance unit test for complex sharing Updated SharedReferenceInstancesRoundTrip to verify both complete instance sharing across Foo, Bar, and Baz, as well as complex graph sharing where Foo and Bar share an instance while Baz is a distinct item sharing a nested instance. --- tests/SerializationTests.cs | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/tests/SerializationTests.cs b/tests/SerializationTests.cs index f9840ed..0950f1c 100644 --- a/tests/SerializationTests.cs +++ b/tests/SerializationTests.cs @@ -1234,7 +1234,9 @@ public void SharedReferenceInstancesRoundTrip() { var sharedNested = new SharedClassNested { NestedValue = 42 }; var sharedItem = new SharedClassItem { Value = 100, Nested = sharedNested }; - var container = new DuplicateInstanceContainer + + // 1. Foo, Bar, and Baz all share the same SharedClassItem instance + var allSharedContainer = new DuplicateInstanceContainer { Foo = sharedItem, Bar = sharedItem, @@ -1242,7 +1244,7 @@ public void SharedReferenceInstancesRoundTrip() }; var buffer = new byte[256]; - int writtenBytes = container.Serialize(buffer); + int writtenBytes = allSharedContainer.Serialize(buffer); var view = new DuplicateInstanceContainerView(buffer.AsMemory(0, writtenBytes)); TestAssert.Equal(100, view.Foo.Value, nameof(view.Foo.Value)); @@ -1254,5 +1256,27 @@ public void SharedReferenceInstancesRoundTrip() TestAssert.Equal(42, view.Baz.Nested.NestedValue, nameof(view.Baz.Nested.NestedValue)); TestAssert.Equal(writtenBytes, view.GetByteLength(), "SharedReferenceInstances GetByteLength"); + + // 2. Foo and Bar share SharedClassItem instance; Baz has a distinct SharedClassItem instance but shares the same SharedClassNested instance + var distinctItemWithSharedNested = new SharedClassItem { Value = 200, Nested = sharedNested }; + var complexContainer = new DuplicateInstanceContainer + { + Foo = sharedItem, + Bar = sharedItem, + Baz = distinctItemWithSharedNested, + }; + + int complexWrittenBytes = complexContainer.Serialize(buffer); + var complexView = new DuplicateInstanceContainerView(buffer.AsMemory(0, complexWrittenBytes)); + + TestAssert.Equal(100, complexView.Foo.Value, nameof(complexView.Foo.Value)); + TestAssert.Equal(100, complexView.Bar.Value, nameof(complexView.Bar.Value)); + TestAssert.Equal(200, complexView.Baz.Value, nameof(complexView.Baz.Value)); + + TestAssert.Equal(42, complexView.Foo.Nested.NestedValue, nameof(complexView.Foo.Nested.NestedValue)); + TestAssert.Equal(42, complexView.Bar.Nested.NestedValue, nameof(complexView.Bar.Nested.NestedValue)); + TestAssert.Equal(42, complexView.Baz.Nested.NestedValue, nameof(complexView.Baz.Nested.NestedValue)); + + TestAssert.Equal(complexWrittenBytes, complexView.GetByteLength(), "ComplexSharedReferenceInstances GetByteLength"); } } From 18e0b3bbcedba59d14b6aee726b3fbe122b32f23 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 20 Aug 2026 10:19:27 +0000 Subject: [PATCH 3/3] Update shared reference instance unit test per review feedback Removed simple duplicate instance test case and retained complex sharing case where Foo and Bar share a SharedClassItem instance while Baz has a distinct SharedClassItem instance sharing the same nested SharedClassNested instance. --- tests/SerializationTests.cs | 33 ++++++--------------------------- 1 file changed, 6 insertions(+), 27 deletions(-) diff --git a/tests/SerializationTests.cs b/tests/SerializationTests.cs index 0950f1c..f76c11b 100644 --- a/tests/SerializationTests.cs +++ b/tests/SerializationTests.cs @@ -1234,49 +1234,28 @@ public void SharedReferenceInstancesRoundTrip() { var sharedNested = new SharedClassNested { NestedValue = 42 }; var sharedItem = new SharedClassItem { Value = 100, Nested = sharedNested }; + var distinctItemWithSharedNested = new SharedClassItem { Value = 200, Nested = sharedNested }; - // 1. Foo, Bar, and Baz all share the same SharedClassItem instance - var allSharedContainer = new DuplicateInstanceContainer + // Foo and Bar share SharedClassItem instance; Baz has a distinct SharedClassItem instance but shares the same SharedClassNested instance + var container = new DuplicateInstanceContainer { Foo = sharedItem, Bar = sharedItem, - Baz = sharedItem, + Baz = distinctItemWithSharedNested, }; var buffer = new byte[256]; - int writtenBytes = allSharedContainer.Serialize(buffer); + int writtenBytes = container.Serialize(buffer); var view = new DuplicateInstanceContainerView(buffer.AsMemory(0, writtenBytes)); TestAssert.Equal(100, view.Foo.Value, nameof(view.Foo.Value)); TestAssert.Equal(100, view.Bar.Value, nameof(view.Bar.Value)); - TestAssert.Equal(100, view.Baz.Value, nameof(view.Baz.Value)); + TestAssert.Equal(200, view.Baz.Value, nameof(view.Baz.Value)); TestAssert.Equal(42, view.Foo.Nested.NestedValue, nameof(view.Foo.Nested.NestedValue)); TestAssert.Equal(42, view.Bar.Nested.NestedValue, nameof(view.Bar.Nested.NestedValue)); TestAssert.Equal(42, view.Baz.Nested.NestedValue, nameof(view.Baz.Nested.NestedValue)); TestAssert.Equal(writtenBytes, view.GetByteLength(), "SharedReferenceInstances GetByteLength"); - - // 2. Foo and Bar share SharedClassItem instance; Baz has a distinct SharedClassItem instance but shares the same SharedClassNested instance - var distinctItemWithSharedNested = new SharedClassItem { Value = 200, Nested = sharedNested }; - var complexContainer = new DuplicateInstanceContainer - { - Foo = sharedItem, - Bar = sharedItem, - Baz = distinctItemWithSharedNested, - }; - - int complexWrittenBytes = complexContainer.Serialize(buffer); - var complexView = new DuplicateInstanceContainerView(buffer.AsMemory(0, complexWrittenBytes)); - - TestAssert.Equal(100, complexView.Foo.Value, nameof(complexView.Foo.Value)); - TestAssert.Equal(100, complexView.Bar.Value, nameof(complexView.Bar.Value)); - TestAssert.Equal(200, complexView.Baz.Value, nameof(complexView.Baz.Value)); - - TestAssert.Equal(42, complexView.Foo.Nested.NestedValue, nameof(complexView.Foo.Nested.NestedValue)); - TestAssert.Equal(42, complexView.Bar.Nested.NestedValue, nameof(complexView.Bar.Nested.NestedValue)); - TestAssert.Equal(42, complexView.Baz.Nested.NestedValue, nameof(complexView.Baz.Nested.NestedValue)); - - TestAssert.Equal(complexWrittenBytes, complexView.GetByteLength(), "ComplexSharedReferenceInstances GetByteLength"); } }