From 57d47b5989ebc9fdd754077ae612980c25c84cc5 Mon Sep 17 00:00:00 2001
From: Dan Quan <dan@quan.io>
Date: Thu, 19 Dec 2019 07:21:26 -0800
Subject: [PATCH 1/2] Add failing tests for issues with wrapped values where
 the value is the default

---
 ruby/tests/basic.rb | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/ruby/tests/basic.rb b/ruby/tests/basic.rb
index 1cb8d3463ed4..d73ea074855e 100644
--- a/ruby/tests/basic.rb
+++ b/ruby/tests/basic.rb
@@ -276,6 +276,48 @@ def test_map_wrappers
       assert_equal m5, m
     end
 
+    def test_map_wrappers_with_default_values
+      run_asserts = ->(m) {
+        assert_equal 0.0, m.map_double[0].value
+        assert_equal 0.0, m.map_float[0].value
+        assert_equal 0, m.map_int32[0].value
+        assert_equal 0, m.map_int64[0].value
+        assert_equal 0, m.map_uint32[0].value
+        assert_equal 0, m.map_uint64[0].value
+        assert_equal false, m.map_bool[0].value
+        assert_equal '', m.map_string[0].value
+        assert_equal '', m.map_bytes[0].value
+      }
+
+      m = proto_module::Wrapper.new(
+        map_double: {0 => Google::Protobuf::DoubleValue.new(value: 0.0)},
+        map_float: {0 => Google::Protobuf::FloatValue.new(value: 0.0)},
+        map_int32: {0 => Google::Protobuf::Int32Value.new(value: 0)},
+        map_int64: {0 => Google::Protobuf::Int64Value.new(value: 0)},
+        map_uint32: {0 => Google::Protobuf::UInt32Value.new(value: 0)},
+        map_uint64: {0 => Google::Protobuf::UInt64Value.new(value: 0)},
+        map_bool: {0 => Google::Protobuf::BoolValue.new(value: false)},
+        map_string: {0 => Google::Protobuf::StringValue.new(value: '')},
+        map_bytes: {0 => Google::Protobuf::BytesValue.new(value: '')},
+      )
+
+      run_asserts.call(m)
+      serialized = proto_module::Wrapper::encode(m)
+      m2 = proto_module::Wrapper::decode(serialized)
+      run_asserts.call(m2)
+
+      # Test the case where we are serializing directly from the parsed form
+      # (before anything lazy is materialized).
+      m3 = proto_module::Wrapper::decode(serialized)
+      serialized2 = proto_module::Wrapper::encode(m3)
+      m4 = proto_module::Wrapper::decode(serialized2)
+      run_asserts.call(m4)
+
+      # Test that the lazy form compares equal to the expanded form.
+      m5 = proto_module::Wrapper::decode(serialized2)
+      assert_equal m5, m
+    end
+
     def test_concurrent_decoding
       o = Outer.new
       o.items[0] = Inner.new

From 1da3ddda7c033f31cee81436f7e8f25ef6ddba54 Mon Sep 17 00:00:00 2001
From: Dan Quan <dan@quan.io>
Date: Thu, 19 Dec 2019 07:36:39 -0800
Subject: [PATCH 2/2] Add test for wrapped values without a value set

---
 ruby/tests/basic.rb | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/ruby/tests/basic.rb b/ruby/tests/basic.rb
index d73ea074855e..7d92ee2b79a3 100644
--- a/ruby/tests/basic.rb
+++ b/ruby/tests/basic.rb
@@ -318,6 +318,43 @@ def test_map_wrappers_with_default_values
       assert_equal m5, m
     end
 
+    def test_map_wrappers_with_no_value
+      run_asserts = ->(m) {
+        assert_equal nil, m.map_double[0]
+        assert_equal nil, m.map_float[0]
+        assert_equal nil, m.map_int32[0]
+        assert_equal nil, m.map_int64[0]
+        assert_equal nil, m.map_uint32[0]
+        assert_equal nil, m.map_uint64[0]
+        assert_equal nil, m.map_bool[0]
+        assert_equal nil, m.map_string[0]
+        assert_equal nil, m.map_bytes[0]
+      }
+
+      m = proto_module::Wrapper.new(
+        map_double: {0 => Google::Protobuf::DoubleValue.new()},
+        map_float: {0 => Google::Protobuf::FloatValue.new()},
+        map_int32: {0 => Google::Protobuf::Int32Value.new()},
+        map_int64: {0 => Google::Protobuf::Int64Value.new()},
+        map_uint32: {0 => Google::Protobuf::UInt32Value.new()},
+        map_uint64: {0 => Google::Protobuf::UInt64Value.new()},
+        map_bool: {0 => Google::Protobuf::BoolValue.new()},
+        map_string: {0 => Google::Protobuf::StringValue.new()},
+        map_bytes: {0 => Google::Protobuf::BytesValue.new()},
+      )
+
+      serialized = proto_module::Wrapper::encode(m)
+      m2 = proto_module::Wrapper::decode(serialized)
+      run_asserts.call(m2)
+
+      # Test the case where we are serializing directly from the parsed form
+      # (before anything lazy is materialized).
+      m3 = proto_module::Wrapper::decode(serialized)
+      serialized2 = proto_module::Wrapper::encode(m3)
+      m4 = proto_module::Wrapper::decode(serialized2)
+      run_asserts.call(m4)
+    end
+
     def test_concurrent_decoding
       o = Outer.new
       o.items[0] = Inner.new