django.forms.DateField - python examples

Here are the examples of the python api django.forms.DateField taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

32 Examples 7

3 View Complete Implementation : forms.py
Copyright GNU General Public License v3.0
Author : CodigoSur
    def __init__(self, *args, **kwargs):
        super(DateSearchForm, self).__init__(*args, **kwargs)
        if cyc_settings.CYCLOPE_SEARCH_DATE :
            date_format = ['%d-%m-%Y',      # '25-12-2006'
                           '%d-%m-%y',      # '25-12-06'
                           '%d/%m/%Y',      # '25/12/2006'
                           '%d/%m/%y']      # '25/12/06'
            self.fields.insert(1, 'start_date', forms.DateField(label=_('Desde'), required=False, input_formats=date_format, help_text=_('ejemplo: 25/12/2015')))
            self.fields.insert(2, 'end_date', forms.DateField(label=_('Hasta'), required=False, input_formats=date_format, help_text=_('ejemplo: 25/12/2015')))

3 View Complete Implementation : filter.py
Copyright MIT License
Author : f213
    def __init__(self, *args, **kwargs):
        """
        Automaticaly generate form fields with dynamic names based on the filtering field name
        """
        self.field_name = kwargs.pop('field_name', 'date')
        self.satle = kwargs.pop('satle', 'Date').satle()
        super(DateRangeForm, self).__init__(*args, **kwargs)

        self.fields['%s_start' % self.field_name] = forms.DateField(
            widget=SuitDateWidget(attrs={'placeholder': self.satle, 'style': 'width=330px;'}), label=pgettext('date', 'From'), required=False)
        self.fields['%s_end' % self.field_name] = forms.DateField(
            widget=SuitDateWidget(attrs={'placeholder': self.satle}), label=pgettext('date', 'To'), required=False)

3 View Complete Implementation : test_fields.py
Copyright MIT License
Author : labd
    def test_date_field(self):
        data = self.get_form_field_data('date')
        cls = wsf_fields.DateField()
        field = cls.get_formfield(data)

        self.astertIsInstance(field, forms.DateField)
        self.astertIsInstance(field.widget, forms.widgets.DateInput)
        self.astertEqual(field.label, data['label'])
        self.astertEqual(field.required, data['required'])
        self.astertEqual(field.help_text, data['help_text'])
        self.astertEqual(field.initial, data['default_value'])

3 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_2(self):
        f = DateField(required=False)
        self.astertIsNone(f.clean(None))
        self.astertEqual('None', repr(f.clean(None)))
        self.astertIsNone(f.clean(''))
        self.astertEqual('None', repr(f.clean('')))

3 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_3(self):
        f = DateField(input_formats=['%Y %m %d'])
        self.astertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
        self.astertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
        self.astertEqual(date(2006, 10, 25), f.clean('2006 10 25'))
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('2006-10-25')
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('10/25/2006')
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('10/25/06')

3 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_4(self):
        # Test whitespace stripping behavior (#5714)
        f = DateField()
        self.astertEqual(date(2006, 10, 25), f.clean(' 10/25/2006 '))
        self.astertEqual(date(2006, 10, 25), f.clean(' 10/25/06 '))
        self.astertEqual(date(2006, 10, 25), f.clean(' Oct 25   2006 '))
        self.astertEqual(date(2006, 10, 25), f.clean(' October  25 2006 '))
        self.astertEqual(date(2006, 10, 25), f.clean(' October 25, 2006 '))
        self.astertEqual(date(2006, 10, 25), f.clean(' 25 October 2006 '))
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('   ')

3 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_strptime(self):
        """field.strptime() doesn't raise a UnicodeEncodeError (#16123)"""
        f = DateField()
        try:
            f.strptime('31 мая 2011', '%d-%b-%y')
        except Exception as e:
            # astertIsInstance or astertRaises cannot be used because UnicodeEncodeError
            # is a subclast of ValueError
            self.astertEqual(e.__clast__, ValueError)

3 View Complete Implementation : test_error_messages.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield(self):
        e = {
            'required': 'REQUIRED',
            'invalid': 'INVALID',
        }
        f = DateField(error_messages=e)
        self.astertFormErrors(['REQUIRED'], f.clean, '')
        self.astertFormErrors(['INVALID'], f.clean, 'abc')

3 View Complete Implementation : test_selectdatewidget.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_selectdate_required(self):
        clast GetNotRequiredDate(Form):
            mydate = DateField(widget=SelectDateWidget, required=False)

        clast GetRequiredDate(Form):
            mydate = DateField(widget=SelectDateWidget, required=True)

        self.astertFalse(GetNotRequiredDate().fields['mydate'].widget.is_required)
        self.astertTrue(GetRequiredDate().fields['mydate'].widget.is_required)

3 View Complete Implementation : test_forms.py
Copyright Apache License 2.0
Author : ooknosi
    def test_MaterialForm_materializes_DateField(self):
        """django.forms.widgets.DateInput should be converted to
        material_widgets.widgets.MaterialDateInput.
        """

        clast DateInputForm(MaterialForm):
            date_input = forms.DateField()

        form = DateInputForm()
        self.astertEqual(
            type(form.fields['date_input'].widget),
            widgets.MaterialDateInput,
            )

3 View Complete Implementation : filter.py
Copyright MIT License
Author : silentsokolov
    def _get_form_fields(self):
        return OrderedDict(
            (
                (self.lookup_kwarg_gte, forms.DateField(
                    label='',
                    widget=AdminDateWidget(attrs={'placeholder': _('From date')}),
                    localize=True,
                    required=False
                )),
                (self.lookup_kwarg_lte, forms.DateField(
                    label='',
                    widget=AdminDateWidget(attrs={'placeholder': _('To date')}),
                    localize=True,
                    required=False
                )),
            )
        )

0 View Complete Implementation : fields.py
Copyright Apache License 2.0
Author : BeanWei
    def __init__(self, *args, **kwargs):
        fields = (
            forms.DateField(),
            forms.DateField())
        super(DateRangeField, self).__init__(fields, *args, **kwargs)

0 View Complete Implementation : __init__.py
Copyright GNU General Public License v2.0
Author : blackye
    def formfield(self, **kwargs):
        defaults = {'form_clast': forms.DateField}
        defaults.update(kwargs)
        return super(DateField, self).formfield(**defaults)

0 View Complete Implementation : converter.py
Copyright MIT License
Author : graphql-python
@convert_form_field.register(forms.DateField)
def convert_form_field_to_date(field):
    return Date(description=field.help_text, required=field.required)

0 View Complete Implementation : test_converter.py
Copyright MIT License
Author : graphql-python
def test_should_date_convert_date():
    astert_conversion(forms.DateField, Date)

0 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    @override_settings(USE_L10N=True)
    @translation.override('nl')
    def test_l10n_date_changed(self):
        """
        DateField.has_changed() with SelectDateWidget works with a localized
        date format (#17165).
        """
        # With Field.show_hidden_initial=False
        b = GetDate({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '1',
        }, initial={'mydate': date(2008, 4, 1)})
        self.astertFalse(b.has_changed())

        b = GetDate({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '2',
        }, initial={'mydate': date(2008, 4, 1)})
        self.astertTrue(b.has_changed())

        # With Field.show_hidden_initial=True
        clast GetDateShowHiddenInitial(Form):
            mydate = DateField(widget=SelectDateWidget, show_hidden_initial=True)

        b = GetDateShowHiddenInitial({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '1',
            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
        }, initial={'mydate': date(2008, 4, 1)})
        self.astertFalse(b.has_changed())

        b = GetDateShowHiddenInitial({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '22',
            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
        }, initial={'mydate': date(2008, 4, 1)})
        self.astertTrue(b.has_changed())

        b = GetDateShowHiddenInitial({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '22',
            'initial-mydate': HiddenInput().format_value(date(2008, 4, 1)),
        }, initial={'mydate': date(2008, 4, 22)})
        self.astertTrue(b.has_changed())

        b = GetDateShowHiddenInitial({
            'mydate_year': '2008',
            'mydate_month': '4',
            'mydate_day': '22',
            'initial-mydate': HiddenInput().format_value(date(2008, 4, 22)),
        }, initial={'mydate': date(2008, 4, 1)})
        self.astertFalse(b.has_changed())

0 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_1(self):
        f = DateField()
        self.astertEqual(date(2006, 10, 25), f.clean(date(2006, 10, 25)))
        self.astertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30)))
        self.astertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59)))
        self.astertEqual(date(2006, 10, 25), f.clean(datetime(2006, 10, 25, 14, 30, 59, 200)))
        self.astertEqual(date(2006, 10, 25), f.clean('2006-10-25'))
        self.astertEqual(date(2006, 10, 25), f.clean('10/25/2006'))
        self.astertEqual(date(2006, 10, 25), f.clean('10/25/06'))
        self.astertEqual(date(2006, 10, 25), f.clean('Oct 25 2006'))
        self.astertEqual(date(2006, 10, 25), f.clean('October 25 2006'))
        self.astertEqual(date(2006, 10, 25), f.clean('October 25, 2006'))
        self.astertEqual(date(2006, 10, 25), f.clean('25 October 2006'))
        self.astertEqual(date(2006, 10, 25), f.clean('25 October, 2006'))
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('2006-4-31')
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('200a-10-25')
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('25/10/06')
        with self.astertRaisesMessage(ValidationError, "'This field is required.'"):
            f.clean(None)

0 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_5(self):
        # Test null bytes (#18982)
        f = DateField()
        with self.astertRaisesMessage(ValidationError, "'Enter a valid date.'"):
            f.clean('a\x00b')

0 View Complete Implementation : test_datefield.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_datefield_changed(self):
        format = '%d/%m/%Y'
        f = DateField(input_formats=[format])
        d = date(2007, 9, 17)
        self.astertFalse(f.has_changed(d, '17/09/2007'))

0 View Complete Implementation : test_error_messages.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_subclasting_errorlist(self):
        clast TestForm(Form):
            first_name = CharField()
            last_name = CharField()
            birthday = DateField()

            def clean(self):
                raise ValidationError("I like to be awkward.")

        clast CustomErrorList(utils.ErrorList):
            def __str__(self):
                return self.as_divs()

            def as_divs(self):
                if not self:
                    return ''
                return mark_safe('<div clast="error">%s</div>' % ''.join('<p>%s</p>' % e for e in self))

        # This form should print errors the default way.
        form1 = TestForm({'first_name': 'John'})
        self.astertHTMLEqual(
            str(form1['last_name'].errors),
            '<ul clast="errorlist"><li>This field is required.</li></ul>'
        )
        self.astertHTMLEqual(
            str(form1.errors['__all__']),
            '<ul clast="errorlist nonfield"><li>I like to be awkward.</li></ul>'
        )

        # This one should wrap error groups in the customized way.
        form2 = TestForm({'first_name': 'John'}, error_clast=CustomErrorList)
        self.astertHTMLEqual(str(form2['last_name'].errors), '<div clast="error"><p>This field is required.</p></div>')
        self.astertHTMLEqual(str(form2.errors['__all__']), '<div clast="error"><p>I like to be awkward.</p></div>')

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField(self):
        "DateFields can parse dates in the default format"
        f = forms.DateField()
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21/12/2010')

        # ISO formats are accepted, even if not specified in formats.py
        self.astertEqual(f.clean('2010-12-21'), date(2010, 12, 21))

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip
        text = f.widget.format_value(result)
        self.astertEqual(text, '21.12.2010')

        # Parse a date in a valid, but non-default format, get a parsed result
        result = f.clean('21.12.10')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField(self):
        "Localized DateFields act as unlocalized widgets"
        f = forms.DateField(localize=True)
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21/12/2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, '21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.10')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField_with_inputformat(self):
        "DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"])
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')
        with self.astertRaises(forms.ValidationError):
            f.clean('21/12/2010')
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12.21.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12-21-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField_with_inputformat(self):
        "Localized DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"], localize=True)
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')
        with self.astertRaises(forms.ValidationError):
            f.clean('21/12/2010')
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12.21.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12-21-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField(self):
        "DateFields can parse dates in the default format"
        f = forms.DateField()
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip
        text = f.widget.format_value(result)
        self.astertEqual(text, '21.12.2010')

        # Parse a date in a valid, but non-default format, get a parsed result
        result = f.clean('21-12-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField(self):
        "Localized DateFields act as unlocalized widgets"
        f = forms.DateField(localize=True)
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, '21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21-12-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField_with_inputformat(self):
        "DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"])
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12.21.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12-21-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField_with_inputformat(self):
        "Localized DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"], localize=True)
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12.21.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12-21-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "21.12.2010")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField(self):
        "DateFields can parse dates in the default format"
        f = forms.DateField()
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('2010-12-21')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

        # Parse a date in a valid, but non-default format, get a parsed result
        result = f.clean('12/21/2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField(self):
        "Localized DateFields in a non-localized environment act as unlocalized widgets"
        f = forms.DateField()
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('21.12.2010')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('2010-12-21')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('12/21/2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_dateField_with_inputformat(self):
        "DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%d.%m.%Y", "%d-%m-%Y"])
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21-12-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

0 View Complete Implementation : test_input_formats.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_localized_dateField_with_inputformat(self):
        "Localized DateFields with manually specified input formats can accept those formats"
        f = forms.DateField(input_formats=["%d.%m.%Y", "%d-%m-%Y"], localize=True)
        # Parse a date in an unaccepted format; get an error
        with self.astertRaises(forms.ValidationError):
            f.clean('2010-12-21')

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21.12.2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to the same format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")

        # Parse a date in a valid format, get a parsed result
        result = f.clean('21-12-2010')
        self.astertEqual(result, date(2010, 12, 21))

        # The parsed result does a round trip to default format
        text = f.widget.format_value(result)
        self.astertEqual(text, "2010-12-21")