[Fact]
        public static void ChangingShouldSerializeToNullUsesIgnoreConditionSpecifiedInOptions()
        {
            SomeService service = new();
            service.WithConfiguredJsonSerializerOptions((options) =>
            {
                options.DefaultIgnoreCondition = /* read from config file, for simplicity: */ JsonIgnoreCondition.WhenWritingDefault;

                if (options.TypeInfoResolver is DefaultJsonTypeInfoResolver resolver)
                {
                    resolver.Modifiers.Add(RestoreIgnoreConditionForLongToDefault);
                }
                else
                {
                    throw new Exception("resolver is not DefaultJsonTypeInfoResolver");
                }
            });

            ClassWithUlong obj = new();

            obj.UlongValue = 0;
            Assert.Equal("""{}""", service.SerializeObject(obj));

            obj.UlongValue = 44;
            Assert.Equal("""{"UlongValue":"44"}""", service.SerializeObject(obj));

            obj.UlongValue = ulong.MaxValue;
            Assert.Equal($"{{\"UlongValue\":\"{ulong.MaxValue}\"}}", service.SerializeObject(obj));

            static void RestoreIgnoreConditionForLongToDefault(JsonTypeInfo typeInfo)
            {
                foreach (JsonPropertyInfo prop in typeInfo.Properties)
                {
                    prop.ShouldSerialize = null;

                    // oterwise
                    //switch (typeInfo.Options.DefaultIgnoreCondition)
                    //{
                    //    case JsonIgnoreCondition.WhenWritingDefault:
                    //    // ... user has to do mapping themselves
                    //}
                }
            }
        }

        class ClassWithUlong
        {
            public ulong UlongValue { get; set; }
        }

        class SomeService
        {
            private JsonSerializerOptions _options = new()
            {
                TypeInfoResolver = new DefaultJsonTypeInfoResolver() { Modifiers = { LongAndULongModifier } }
            };

            public SomeService WithConfiguredJsonSerializerOptions(Action<JsonSerializerOptions> configureOptions)
            {
                configureOptions(_options);
                return this;
            }

            public string SerializeObject<T>(T obj)
            {
                return JsonSerializer.Serialize(obj, _options);
            }

            static void LongAndULongModifier(JsonTypeInfo typeInfo)
            {
                foreach (JsonPropertyInfo propertyInfo in typeInfo.Properties)
                {
                    if (propertyInfo.PropertyType == typeof(long) || propertyInfo.PropertyType == typeof(ulong))
                    {
                        propertyInfo.ShouldSerialize = (obj, val) =>
                        {
                            if (val is long longVal)
                            {
                                return longVal != long.MaxValue;
                            }
                            else if (val is ulong ulongVal)
                            {
                                return ulongVal != ulong.MaxValue;
                            }
                            else
                            {
                                throw new Exception("something is wrong");
                            }
                        };
                    }
                }

                // some other unrelated changes here
                if (typeInfo.Type == typeof(long) || typeInfo.Type == typeof(ulong))
                {
                    typeInfo.NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString;
                }
            }
        }