Refs #32873 -- Removed settings.USE_L10N per deprecation timeline.

8 files changed, 72 insertions, 425 deletions

diff --git a/tests/deprecation/test_use_l10n.py b/tests/deprecation/test_use_l10n.py
deleted file mode 100644
index c654a0466a..0000000000
--- a/tests/deprecation/test_use_l10n.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import sys
-from types import ModuleType
-
-from django.conf import USE_L10N_DEPRECATED_MSG, Settings, settings
-from django.test import TestCase, ignore_warnings
-from django.utils.deprecation import RemovedInDjango50Warning
-
-
-class DeprecationTests(TestCase):
-    msg = USE_L10N_DEPRECATED_MSG
-
-    def test_override_settings_warning(self):
-        # Warning is raised when USE_L10N is set in UserSettingsHolder (used by
-        # the @override_settings decorator).
-        with self.assertRaisesMessage(RemovedInDjango50Warning, self.msg):
-            with self.settings(USE_L10N=True):
-                pass
-
-    def test_settings_init_warning(self):
-        settings_module = ModuleType("fake_settings_module")
-        settings_module.SECRET_KEY = "foo"
-        settings_module.USE_TZ = True
-        settings_module.USE_L10N = False
-        sys.modules["fake_settings_module"] = settings_module
-        try:
-            with self.assertRaisesMessage(RemovedInDjango50Warning, self.msg):
-                Settings("fake_settings_module")
-        finally:
-            del sys.modules["fake_settings_module"]
-
-    def test_access_warning(self):
-        with self.assertRaisesMessage(RemovedInDjango50Warning, self.msg):
-            settings.USE_L10N
-        # Works a second time.
-        with self.assertRaisesMessage(RemovedInDjango50Warning, self.msg):
-            settings.USE_L10N
-
-    @ignore_warnings(category=RemovedInDjango50Warning)
-    def test_access(self):
-        with self.settings(USE_L10N=False):
-            self.assertIs(settings.USE_L10N, False)
-            # Works a second time.
-            self.assertIs(settings.USE_L10N, False)
diff --git a/tests/forms_tests/field_tests/test_decimalfield.py b/tests/forms_tests/field_tests/test_decimalfield.py
index 119a74292c..4e24d553f3 100644
--- a/tests/forms_tests/field_tests/test_decimalfield.py
+++ b/tests/forms_tests/field_tests/test_decimalfield.py
@@ -2,9 +2,8 @@ import decimal
 
 from django.core.exceptions import ValidationError
 from django.forms import DecimalField, NumberInput, Widget
-from django.test import SimpleTestCase, ignore_warnings, override_settings
+from django.test import SimpleTestCase, override_settings
 from django.utils import formats, translation
-from django.utils.deprecation import RemovedInDjango50Warning
 
 from . import FormFieldAssertionsMixin
 
@@ -195,31 +194,22 @@ class DecimalFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
             localized_d = formats.localize_input(d)  # -> '0,1' in French
             self.assertFalse(f.has_changed(d, localized_d))
 
-    # RemovedInDjango50Warning: When the deprecation ends, remove
-    # @ignore_warnings and USE_L10N=False. The test should remain because
-    # format-related settings will take precedence over locale-dictated
-    # formats.
-    @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=",")
+    @override_settings(DECIMAL_SEPARATOR=",")
     def test_decimalfield_support_decimal_separator(self):
-        f = DecimalField(localize=True)
-        self.assertEqual(f.clean("1001,10"), decimal.Decimal("1001.10"))
-        self.assertEqual(f.clean("1001.10"), decimal.Decimal("1001.10"))
+        with translation.override(None):
+            f = DecimalField(localize=True)
+            self.assertEqual(f.clean("1001,10"), decimal.Decimal("1001.10"))
+            self.assertEqual(f.clean("1001.10"), decimal.Decimal("1001.10"))
 
-    # RemovedInDjango50Warning: When the deprecation ends, remove
-    # @ignore_warnings and USE_L10N=False. The test should remain because
-    # format-related settings will take precedence over locale-dictated
-    # formats.
-    @ignore_warnings(category=RemovedInDjango50Warning)
     @override_settings(
-        USE_L10N=False,
         DECIMAL_SEPARATOR=",",
         USE_THOUSAND_SEPARATOR=True,
         THOUSAND_SEPARATOR=".",
     )
     def test_decimalfield_support_thousands_separator(self):
-        f = DecimalField(localize=True)
-        self.assertEqual(f.clean("1.001,10"), decimal.Decimal("1001.10"))
-        msg = "'Enter a number.'"
-        with self.assertRaisesMessage(ValidationError, msg):
-            f.clean("1,001.1")
+        with translation.override(None):
+            f = DecimalField(localize=True)
+            self.assertEqual(f.clean("1.001,10"), decimal.Decimal("1001.10"))
+            msg = "'Enter a number.'"
+            with self.assertRaisesMessage(ValidationError, msg):
+                f.clean("1,001.1")
diff --git a/tests/forms_tests/field_tests/test_floatfield.py b/tests/forms_tests/field_tests/test_floatfield.py
index 94676fb9ee..459ea878de 100644
--- a/tests/forms_tests/field_tests/test_floatfield.py
+++ b/tests/forms_tests/field_tests/test_floatfield.py
@@ -2,10 +2,9 @@ from django.core.exceptions import ValidationError
 from django.forms import FloatField, NumberInput
 from django.test import SimpleTestCase
 from django.test.selenium import SeleniumTestCase
-from django.test.utils import ignore_warnings, override_settings
+from django.test.utils import override_settings
 from django.urls import reverse
 from django.utils import formats, translation
-from django.utils.deprecation import RemovedInDjango50Warning
 
 from . import FormFieldAssertionsMixin
 
@@ -111,34 +110,25 @@ class FloatFieldTest(FormFieldAssertionsMixin, SimpleTestCase):
             localized_n = formats.localize_input(n)  # -> '4,35' in French
             self.assertFalse(f.has_changed(n, localized_n))
 
-    # RemovedInDjango50Warning: When the deprecation ends, remove
-    # @ignore_warnings and USE_L10N=False. The test should remain because
-    # format-related settings will take precedence over locale-dictated
-    # formats.
-    @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DECIMAL_SEPARATOR=",")
-    def test_decimalfield_support_decimal_separator(self):
-        f = FloatField(localize=True)
-        self.assertEqual(f.clean("1001,10"), 1001.10)
-        self.assertEqual(f.clean("1001.10"), 1001.10)
+    @override_settings(DECIMAL_SEPARATOR=",")
+    def test_floatfield_support_decimal_separator(self):
+        with translation.override(None):
+            f = FloatField(localize=True)
+            self.assertEqual(f.clean("1001,10"), 1001.10)
+            self.assertEqual(f.clean("1001.10"), 1001.10)
 
-    # RemovedInDjango50Warning: When the deprecation ends, remove
-    # @ignore_warnings and USE_L10N=False. The test should remain because
-    # format-related settings will take precedence over locale-dictated
-    # formats.
-    @ignore_warnings(category=RemovedInDjango50Warning)
     @override_settings(
-        USE_L10N=False,
         DECIMAL_SEPARATOR=",",
         USE_THOUSAND_SEPARATOR=True,
         THOUSAND_SEPARATOR=".",
     )
-    def test_decimalfield_support_thousands_separator(self):
-        f = FloatField(localize=True)
-        self.assertEqual(f.clean("1.001,10"), 1001.10)
-        msg = "'Enter a number.'"
-        with self.assertRaisesMessage(ValidationError, msg):
-            f.clean("1,001.1")
+    def test_floatfield_support_thousands_separator(self):
+        with translation.override(None):
+            f = FloatField(localize=True)
+            self.assertEqual(f.clean("1.001,10"), 1001.10)
+            msg = "'Enter a number.'"
+            with self.assertRaisesMessage(ValidationError, msg):
+                f.clean("1,001.1")
 
 
 @override_settings(ROOT_URLCONF="forms_tests.urls")
diff --git a/tests/forms_tests/tests/test_input_formats.py b/tests/forms_tests/tests/test_input_formats.py
index cd3817d421..1923319759 100644
--- a/tests/forms_tests/tests/test_input_formats.py
+++ b/tests/forms_tests/tests/test_input_formats.py
@@ -120,7 +120,7 @@ class LocalizedTimeTests(SimpleTestCase):
         self.assertEqual(text, "13:30:00")
 
 
-@translation.override(None)  # RemovedInDjango50Warning.
+@translation.override(None)
 @override_settings(TIME_INPUT_FORMATS=["%I:%M:%S %p", "%I:%M %p"])
 class CustomTimeInputFormatsTests(SimpleTestCase):
     def test_timeField(self):
@@ -434,7 +434,7 @@ class LocalizedDateTests(SimpleTestCase):
         self.assertEqual(text, "21.12.2010")
 
 
-@translation.override(None)  # RemovedInDjango50Warning.
+@translation.override(None)
 @override_settings(DATE_INPUT_FORMATS=["%d.%m.%Y", "%d-%m-%Y"])
 class CustomDateInputFormatsTests(SimpleTestCase):
     def test_dateField(self):
@@ -756,7 +756,7 @@ class LocalizedDateTimeTests(SimpleTestCase):
         self.assertEqual(text, "21.12.2010 13:30:00")
 
 
-@translation.override(None)  # RemovedInDjango50Warning.
+@translation.override(None)
 @override_settings(DATETIME_INPUT_FORMATS=["%I:%M:%S %p %d/%m/%Y", "%I:%M %p %d-%m-%Y"])
 class CustomDateTimeInputFormatsTests(SimpleTestCase):
     def test_dateTimeField(self):
diff --git a/tests/forms_tests/widget_tests/test_datetimeinput.py b/tests/forms_tests/widget_tests/test_datetimeinput.py
index 9871a66b36..2a9cfdf599 100644
--- a/tests/forms_tests/widget_tests/test_datetimeinput.py
+++ b/tests/forms_tests/widget_tests/test_datetimeinput.py
@@ -1,9 +1,7 @@
 from datetime import datetime
 
 from django.forms import CharField, DateTimeInput, Form
-from django.test import ignore_warnings
 from django.utils import translation
-from django.utils.deprecation import RemovedInDjango50Warning
 
 from .base import WidgetTest
 
@@ -65,39 +63,6 @@ class DateTimeInputTest(WidgetTest):
             html=('<input type="text" name="date" value="17.09.2007 12:51:34">'),
         )
 
-    @translation.override("de-at")
-    def test_locale_aware(self):
-        d = datetime(2007, 9, 17, 12, 51, 34, 482548)
-        # RemovedInDjango50Warning: When the deprecation ends, remove
-        # @ignore_warnings and USE_L10N=False. The assertion should remain
-        # because format-related settings will take precedence over
-        # locale-dictated formats.
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            with self.settings(USE_L10N=False):
-                with self.settings(
-                    DATETIME_INPUT_FORMATS=[
-                        "%Y-%m-%d %H:%M:%S",
-                        "%Y-%m-%d %H:%M:%S.%f",
-                        "%Y-%m-%d %H:%M",
-                    ]
-                ):
-                    self.check_html(
-                        self.widget,
-                        "date",
-                        d,
-                        html=(
-                            '<input type="text" name="date" '
-                            'value="2007-09-17 12:51:34">'
-                        ),
-                    )
-        with translation.override("es"):
-            self.check_html(
-                self.widget,
-                "date",
-                d,
-                html='<input type="text" name="date" value="17/09/2007 12:51:34">',
-            )
-
     def test_fieldset(self):
         class TestForm(Form):
             template_name = "forms_tests/use_fieldset.html"
diff --git a/tests/forms_tests/widget_tests/test_selectdatewidget.py b/tests/forms_tests/widget_tests/test_selectdatewidget.py
index cc1b6918eb..cfcd037987 100644
--- a/tests/forms_tests/widget_tests/test_selectdatewidget.py
+++ b/tests/forms_tests/widget_tests/test_selectdatewidget.py
@@ -1,10 +1,9 @@
 from datetime import date
 
 from django.forms import DateField, Form, SelectDateWidget
-from django.test import ignore_warnings, override_settings
+from django.test import override_settings
 from django.utils import translation
 from django.utils.dates import MONTHS_AP
-from django.utils.deprecation import RemovedInDjango50Warning
 
 from .base import WidgetTest
 
@@ -542,32 +541,28 @@ class SelectDateWidgetTest(WidgetTest):
             "13-08-0001",
         )
 
-    # RemovedInDjango50Warning: When the deprecation ends, remove
-    # @ignore_warnings and USE_L10N=False. The test should remain because
-    # format-related settings will take precedence over locale-dictated
-    # formats.
-    @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False, DATE_INPUT_FORMATS=["%d.%m.%Y"])
+    @override_settings(DATE_INPUT_FORMATS=["%d.%m.%Y"])
     def test_custom_input_format(self):
         w = SelectDateWidget(years=("0001", "1899", "2009", "2010"))
-        for values, expected_value in (
-            (("0001", "8", "13"), "13.08.0001"),
-            (("1899", "7", "11"), "11.07.1899"),
-            (("2009", "3", "7"), "07.03.2009"),
-        ):
-            with self.subTest(values=values):
-                data = {
-                    "field_%s" % field: value
-                    for field, value in zip(("year", "month", "day"), values)
-                }
-                self.assertEqual(
-                    w.value_from_datadict(data, {}, "field"), expected_value
-                )
-                expected_dict = {
-                    field: int(value)
-                    for field, value in zip(("year", "month", "day"), values)
-                }
-                self.assertEqual(w.format_value(expected_value), expected_dict)
+        with translation.override(None):
+            for values, expected_value in (
+                (("0001", "8", "13"), "13.08.0001"),
+                (("1899", "7", "11"), "11.07.1899"),
+                (("2009", "3", "7"), "07.03.2009"),
+            ):
+                with self.subTest(values=values):
+                    data = {
+                        "field_%s" % field: value
+                        for field, value in zip(("year", "month", "day"), values)
+                    }
+                    self.assertEqual(
+                        w.value_from_datadict(data, {}, "field"), expected_value
+                    )
+                    expected_dict = {
+                        field: int(value)
+                        for field, value in zip(("year", "month", "day"), values)
+                    }
+                    self.assertEqual(w.format_value(expected_value), expected_dict)
 
     def test_format_value(self):
         valid_formats = [
diff --git a/tests/i18n/tests.py b/tests/i18n/tests.py
index 0adacb765e..e4f00fca48 100644
--- a/tests/i18n/tests.py
+++ b/tests/i18n/tests.py
@@ -18,15 +18,8 @@ from django.conf import settings
 from django.conf.locale import LANG_INFO
 from django.conf.urls.i18n import i18n_patterns
 from django.template import Context, Template
-from django.test import (
-    RequestFactory,
-    SimpleTestCase,
-    TestCase,
-    ignore_warnings,
-    override_settings,
-)
+from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
 from django.utils import translation
-from django.utils.deprecation import RemovedInDjango50Warning
 from django.utils.formats import (
     date_format,
     get_format,
@@ -656,181 +649,6 @@ class FormattingTests(SimpleTestCase):
                 "⌚ 10:15", Template('{{ t|time:"⌚ H:i" }}').render(self.ctxt)
             )
 
-    @ignore_warnings(category=RemovedInDjango50Warning)
-    @override_settings(USE_L10N=False)
-    def test_l10n_disabled(self):
-        """
-        Catalan locale with format i18n disabled translations will be used,
-        but not formats
-        """
-        with translation.override("ca", deactivate=True):
-            self.maxDiff = 3000
-            self.assertEqual("N j, Y", get_format("DATE_FORMAT"))
-            self.assertEqual(0, get_format("FIRST_DAY_OF_WEEK"))
-            self.assertEqual(".", get_format("DECIMAL_SEPARATOR"))
-            self.assertEqual("10:15 a.m.", time_format(self.t))
-            self.assertEqual("Des. 31, 2009", date_format(self.d))
-            self.assertEqual("desembre 2009", date_format(self.d, "YEAR_MONTH_FORMAT"))
-            self.assertEqual(
-                "12/31/2009 8:50 p.m.", date_format(self.dt, "SHORT_DATETIME_FORMAT")
-            )
-            self.assertEqual("No localizable", localize("No localizable"))
-            self.assertEqual("66666.666", localize(self.n))
-            self.assertEqual("99999.999", localize(self.f))
-            self.assertEqual("10000", localize(self.long))
-            self.assertEqual("Des. 31, 2009", localize(self.d))
-            self.assertEqual("Des. 31, 2009, 8:50 p.m.", localize(self.dt))
-            self.assertEqual("66666.666", Template("{{ n }}").render(self.ctxt))
-            self.assertEqual("99999.999", Template("{{ f }}").render(self.ctxt))
-            self.assertEqual("Des. 31, 2009", Template("{{ d }}").render(self.ctxt))
-            self.assertEqual(
-                "Des. 31, 2009, 8:50 p.m.", Template("{{ dt }}").render(self.ctxt)
-            )
-            self.assertEqual(
-                "66666.67", Template('{{ n|floatformat:"2u" }}').render(self.ctxt)
-            )
-            self.assertEqual(
-                "100000.0", Template('{{ f|floatformat:"u" }}').render(self.ctxt)
-            )
-            self.assertEqual(
-                "66666.67",
-                Template('{{ n|floatformat:"2gu" }}').render(self.ctxt),
-            )
-            self.assertEqual(
-                "100000.0",
-                Template('{{ f|floatformat:"ug" }}').render(self.ctxt),
-            )
-            self.assertEqual(
-                "10:15 a.m.", Template('{{ t|time:"TIME_FORMAT" }}').render(self.ctxt)
-            )
-            self.assertEqual(
-                "12/31/2009",
-                Template('{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt),
-            )
-            self.assertEqual(
-                "12/31/2009 8:50 p.m.",
-                Template('{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt),
-            )
-
-            form = I18nForm(
-                {
-                    "decimal_field": "66666,666",
-                    "float_field": "99999,999",
-                    "date_field": "31/12/2009",
-                    "datetime_field": "31/12/2009 20:50",
-                    "time_field": "20:50",
-                    "integer_field": "1.234",
-                }
-            )
-            self.assertFalse(form.is_valid())
-            self.assertEqual(["Introdu\xefu un n\xfamero."], form.errors["float_field"])
-            self.assertEqual(
-                ["Introdu\xefu un n\xfamero."], form.errors["decimal_field"]
-            )
-            self.assertEqual(
-                ["Introdu\xefu una data v\xe0lida."], form.errors["date_field"]
-            )
-            self.assertEqual(
-                ["Introdu\xefu una data/hora v\xe0lides."],
-                form.errors["datetime_field"],
-            )
-            self.assertEqual(
-                ["Introdu\xefu un n\xfamero enter."], form.errors["integer_field"]
-            )
-
-            form2 = SelectDateForm(
-                {
-                    "date_field_month": "12",
-                    "date_field_day": "31",
-                    "date_field_year": "2009",
-                }
-            )
-            self.assertTrue(form2.is_valid())
-            self.assertEqual(
-                datetime.date(2009, 12, 31), form2.cleaned_data["date_field"]
-            )
-            self.assertHTMLEqual(
-                '<select name="mydate_month" id="id_mydate_month">'
-                '<option value="">---</option>'
-                '<option value="1">gener</option>'
-                '<option value="2">febrer</option>'
-                '<option value="3">mar\xe7</option>'
-                '<option value="4">abril</option>'
-                '<option value="5">maig</option>'
-                '<option value="6">juny</option>'
-                '<option value="7">juliol</option>'
-                '<option value="8">agost</option>'
-                '<option value="9">setembre</option>'
-                '<option value="10">octubre</option>'
-                '<option value="11">novembre</option>'
-                '<option value="12" selected>desembre</option>'
-                "</select>"
-                '<select name="mydate_day" id="id_mydate_day">'
-                '<option value="">---</option>'
-                '<option value="1">1</option>'
-                '<option value="2">2</option>'
-                '<option value="3">3</option>'
-                '<option value="4">4</option>'
-                '<option value="5">5</option>'
-                '<option value="6">6</option>'
-                '<option value="7">7</option>'
-                '<option value="8">8</option>'
-                '<option value="9">9</option>'
-                '<option value="10">10</option>'
-                '<option value="11">11</option>'
-                '<option value="12">12</option>'
-                '<option value="13">13</option>'
-                '<option value="14">14</option>'
-                '<option value="15">15</option>'
-                '<option value="16">16</option>'
-                '<option value="17">17</option>'
-                '<option value="18">18</option>'
-                '<option value="19">19</option>'
-                '<option value="20">20</option>'
-                '<option value="21">21</option>'
-                '<option value="22">22</option>'
-                '<option value="23">23</option>'
-                '<option value="24">24</option>'
-                '<option value="25">25</option>'
-                '<option value="26">26</option>'
-                '<option value="27">27</option>'
-                '<option value="28">28</option>'
-                '<option value="29">29</option>'
-                '<option value="30">30</option>'
-                '<option value="31" selected>31</option>'
-                "</select>"
-                '<select name="mydate_year" id="id_mydate_year">'
-                '<option value="">---</option>'
-                '<option value="2009" selected>2009</option>'
-                '<option value="2010">2010</option>'
-                '<option value="2011">2011</option>'
-                '<option value="2012">2012</option>'
-                '<option value="2013">2013</option>'
-                '<option value="2014">2014</option>'
-                '<option value="2015">2015</option>'
-                '<option value="2016">2016</option>'
-                '<option value="2017">2017</option>'
-                '<option value="2018">2018</option>'
-                "</select>",
-                forms.SelectDateWidget(years=range(2009, 2019)).render(
-                    "mydate", datetime.date(2009, 12, 31)
-                ),
-            )
-
-            # We shouldn't change the behavior of the floatformat filter re:
-            # thousand separator and grouping when localization is disabled
-            # even if the USE_THOUSAND_SEPARATOR, NUMBER_GROUPING and
-            # THOUSAND_SEPARATOR settings are specified.
-            with self.settings(
-                USE_THOUSAND_SEPARATOR=True, NUMBER_GROUPING=1, THOUSAND_SEPARATOR="!"
-            ):
-                self.assertEqual(
-                    "66666.67", Template('{{ n|floatformat:"2u" }}').render(self.ctxt)
-                )
-                self.assertEqual(
-                    "100000.0", Template('{{ f|floatformat:"u" }}').render(self.ctxt)
-                )
-
     def test_false_like_locale_formats(self):
         """
         The active locale's formats take precedence over the default settings
@@ -1422,7 +1240,7 @@ class FormattingTests(SimpleTestCase):
                 self.assertEqual(sanitize_separators("77\xa0777,777"), "77777.777")
                 self.assertEqual(sanitize_separators("12 345"), "12345")
                 self.assertEqual(sanitize_separators("77 777,777"), "77777.777")
-            with translation.override(None):  # RemovedInDjango50Warning
+            with translation.override(None):
                 with self.settings(USE_THOUSAND_SEPARATOR=True, THOUSAND_SEPARATOR="."):
                     self.assertEqual(sanitize_separators("12\xa0345"), "12\xa0345")
 
@@ -1434,25 +1252,20 @@ class FormattingTests(SimpleTestCase):
                 # Suspicion that user entered dot as decimal separator (#22171)
                 self.assertEqual(sanitize_separators("10.10"), "10.10")
 
-        # RemovedInDjango50Warning: When the deprecation ends, remove
-        # @ignore_warnings and USE_L10N=False. The assertions should remain
-        # because format-related settings will take precedence over
-        # locale-dictated formats.
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            with self.settings(USE_L10N=False):
-                with self.settings(DECIMAL_SEPARATOR=","):
-                    self.assertEqual(sanitize_separators("1001,10"), "1001.10")
-                    self.assertEqual(sanitize_separators("1001.10"), "1001.10")
-                with self.settings(
-                    DECIMAL_SEPARATOR=",",
-                    THOUSAND_SEPARATOR=".",
-                    USE_THOUSAND_SEPARATOR=True,
-                ):
-                    self.assertEqual(sanitize_separators("1.001,10"), "1001.10")
-                    self.assertEqual(sanitize_separators("1001,10"), "1001.10")
-                    self.assertEqual(sanitize_separators("1001.10"), "1001.10")
-                    # Invalid output.
-                    self.assertEqual(sanitize_separators("1,001.10"), "1.001.10")
+        with translation.override(None):
+            with self.settings(DECIMAL_SEPARATOR=","):
+                self.assertEqual(sanitize_separators("1001,10"), "1001.10")
+                self.assertEqual(sanitize_separators("1001.10"), "1001.10")
+            with self.settings(
+                DECIMAL_SEPARATOR=",",
+                THOUSAND_SEPARATOR=".",
+                USE_THOUSAND_SEPARATOR=True,
+            ):
+                self.assertEqual(sanitize_separators("1.001,10"), "1001.10")
+                self.assertEqual(sanitize_separators("1001,10"), "1001.10")
+                self.assertEqual(sanitize_separators("1001.10"), "1001.10")
+                # Invalid output.
+                self.assertEqual(sanitize_separators("1,001.10"), "1.001.10")
 
     def test_iter_format_modules(self):
         """
@@ -1525,10 +1338,6 @@ class FormattingTests(SimpleTestCase):
             "{% load l10n %}{{ int }}/{{ float }}/{{ date }}; "
             "{{ int|unlocalize }}/{{ float|unlocalize }}/{{ date|unlocalize }}"
         )
-        template4 = Template(
-            "{% load l10n %}{{ int }}/{{ float }}/{{ date }}; "
-            "{{ int|localize }}/{{ float|localize }}/{{ date|localize }}"
-        )
         expected_localized = "1.455/3,14/31. Dezember 2016"
         expected_unlocalized = "1455/3.14/Dez. 31, 2016"
         output1 = "; ".join([expected_localized, expected_localized])
@@ -1536,22 +1345,7 @@ class FormattingTests(SimpleTestCase):
             [expected_localized, expected_unlocalized, expected_localized]
         )
         output3 = "; ".join([expected_localized, expected_unlocalized])
-        output4 = "; ".join([expected_unlocalized, expected_localized])
         with translation.override("de", deactivate=True):
-            # RemovedInDjango50Warning: When the deprecation ends, remove
-            # @ignore_warnings and USE_L10N=False. The assertions should remain
-            # because format-related settings will take precedence over
-            # locale-dictated formats.
-            with ignore_warnings(category=RemovedInDjango50Warning):
-                with self.settings(
-                    USE_L10N=False,
-                    DATE_FORMAT="N j, Y",
-                    DECIMAL_SEPARATOR=".",
-                    NUMBER_GROUPING=0,
-                    USE_THOUSAND_SEPARATOR=True,
-                ):
-                    self.assertEqual(template1.render(context), output1)
-                    self.assertEqual(template4.render(context), output4)
             with self.settings(USE_THOUSAND_SEPARATOR=True):
                 self.assertEqual(template1.render(context), output1)
                 self.assertEqual(template2.render(context), output2)
@@ -1573,16 +1367,6 @@ class FormattingTests(SimpleTestCase):
             NUMBER_GROUPING=2,
         ):
             self.assertEqual(template.render(context), "1455/3.14/24.1567")
-        # RemovedInDjango50Warning.
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            with self.settings(
-                USE_L10N=False,
-                DECIMAL_SEPARATOR=",",
-                USE_THOUSAND_SEPARATOR=True,
-                THOUSAND_SEPARATOR="°",
-                NUMBER_GROUPING=2,
-            ):
-                self.assertEqual(template.render(context), "1455/3.14/24.1567")
 
     def test_localized_as_text_as_hidden_input(self):
         """
diff --git a/tests/timezones/tests.py b/tests/timezones/tests.py
index dab481068b..f5c8d17a3c 100644
--- a/tests/timezones/tests.py
+++ b/tests/timezones/tests.py
@@ -38,7 +38,7 @@ from django.test import (
 )
 from django.test.utils import requires_tz_support
 from django.urls import reverse
-from django.utils import timezone
+from django.utils import timezone, translation
 from django.utils.deprecation import RemovedInDjango50Warning
 from django.utils.timezone import timedelta
 
@@ -968,18 +968,9 @@ class SerializationTests(SimpleTestCase):
                 self.assertEqual(obj.dt, dt)
 
 
-# RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
-# USE_L10N=False. The tests should remain because format-related settings will
-# take precedence over locale-dictated formats.
-@override_settings(
-    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=True
-)
+@translation.override(None)
+@override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=True)
 class TemplateTests(SimpleTestCase):
-    @classmethod
-    def setUpClass(cls):
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            super().setUpClass()
-
     @requires_tz_support
     def test_localtime_templatetag_and_filters(self):
         """
@@ -1280,18 +1271,8 @@ class TemplateTests(SimpleTestCase):
             self.assertEqual(tpl.render(Context({})), "+0700")
 
 
-# RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
-# USE_L10N=False. The tests should remain because format-related settings will
-# take precedence over locale-dictated formats.
-@override_settings(
-    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=False
-)
+@override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=False)
 class LegacyFormsTests(TestCase):
-    @classmethod
-    def setUpClass(cls):
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            super().setUpClass()
-
     def test_form(self):
         form = EventForm({"dt": "2011-09-01 13:20:30"})
         self.assertTrue(form.is_valid())
@@ -1336,18 +1317,8 @@ class LegacyFormsTests(TestCase):
         self.assertEqual(e.dt, datetime.datetime(2011, 9, 1, 13, 20, 30))
 
 
-# RemovedInDjango50Warning: When the deprecation ends, remove setUpClass() and
-# USE_L10N=False. The tests should remain because format-related settings will
-# take precedence over locale-dictated formats.
-@override_settings(
-    DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_L10N=False, USE_TZ=True
-)
+@override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=True)
 class NewFormsTests(TestCase):
-    @classmethod
-    def setUpClass(cls):
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            super().setUpClass()
-
     @requires_tz_support
     def test_form(self):
         form = EventForm({"dt": "2011-09-01 13:20:30"})
@@ -1426,20 +1397,15 @@ class NewFormsTests(TestCase):
             self.assertIn("2011-09-01 17:20:30", str(form))
 
 
+@translation.override(None)
 @override_settings(
     DATETIME_FORMAT="c",
     TIME_ZONE="Africa/Nairobi",
-    USE_L10N=False,
     USE_TZ=True,
     ROOT_URLCONF="timezones.urls",
 )
 class AdminTests(TestCase):
     @classmethod
-    def setUpClass(cls):
-        with ignore_warnings(category=RemovedInDjango50Warning):
-            super().setUpClass()
-
-    @classmethod
     def setUpTestData(cls):
         cls.u1 = User.objects.create_user(
             password="secret",