text: import json
  
  from django.conf import settings
  from django.db.utils import IntegrityError
  from django.test import TestCase
  
  from localized_fields.fields import LocalizedField
  from localized_fields.forms import LocalizedFieldForm
  from localized_fields.value import LocalizedValue
  
  from .data import get_init_values
  from .fake_model import get_fake_model
  
  
  class LocalizedFieldTestCase(TestCase):
      """Tests the :see:LocalizedField class."""
  
      @staticmethod
      def test_init():
          """Tests whether the :see:__init__ function
          correctly handles parameters"""
  
          field = LocalizedField(blank=True)
          assert field.required == []
  
          field = LocalizedField(blank=False)
          assert field.required == [settings.LANGUAGE_CODE]
  
          field = LocalizedField(required=True)
          assert field.required == [lang_code for lang_code, _ in
                                    settings.LANGUAGES]
  
          field = LocalizedField(required=False)
          assert field.required == []
  
  
      @staticmethod
      def test_from_db_value():
          """Tests whether the :see:from_db_value function
          produces the expected :see:LocalizedValue."""
  
          input_data = get_init_values()
          localized_value = LocalizedField().from_db_value(input_data)
  
          for lang_code, _ in settings.LANGUAGES:
              assert getattr(localized_value, lang_code) == input_data[lang_code]
  
      @staticmethod
      def test_from_db_value_none():
          """Tests whether the :see:from_db_value function
          correctly handles None values."""
  
          localized_value = LocalizedField().from_db_value(None)
  
          for lang_code, _ in settings.LANGUAGES:
              assert localized_value.get(lang_code) is None
  
      def test_from_db_value_none_return_none(self):
          """Tests whether the :see:from_db_value function
          correctly handles None values when LOCALIZED_FIELDS_EXPERIMENTAL
          is set to True."""
  
          with self.settings(LOCALIZED_FIELDS_EXPERIMENTAL=True):
              localized_value = LocalizedField.from_db_value(None)
  
          assert localized_value is None
  
      @staticmethod
      def test_to_python():
          """Tests whether the :see:to_python function
          produces the expected :see:LocalizedValue."""
  
          input_data = get_init_values()
          localized_value = LocalizedField().to_python(input_data)
  
          for language, value in input_data.items():
              assert localized_value.get(language) == value
  
      @staticmethod
      def test_to_python_non_json():
          """Tests whether the :see:to_python function
          properly handles a string that is not JSON."""
  
          localized_value = LocalizedField().to_python('my value')
          assert localized_value.get() == 'my value'
  
      @staticmethod
      def test_to_python_none():
          """Tests whether the :see:to_python function
          produces the expected :see:LocalizedValue
          instance when it is passes None."""
  
          localized_value = LocalizedField().to_python(None)
          assert localized_value
  
          for lang_code, _ in settings.LANGUAGES:
              assert localized_value.get(lang_code) is None
  
      @staticmethod
      def test_to_python_non_dict():
          """Tests whether the :see:to_python function produces
          the expected :see:LocalizedValue when it is
          passed a non-dictionary value."""
  
          localized_value = LocalizedField().to_python(list())
          assert localized_value
  
          for lang_code, _ in settings.LANGUAGES:
              assert localized_value.get(lang_code) is None
  
      @staticmethod
      def test_to_python_str():
          """Tests whether the :see:to_python function produces
          the expected :see:LocalizedValue when it is
          passed serialized string value."""
  
          serialized_str = json.dumps(get_init_values())
          localized_value = LocalizedField().to_python(serialized_str)
          assert isinstance(localized_value, LocalizedValue)
  
          for language, value in get_init_values().items():
              assert localized_value.get(language) == value
              assert getattr(localized_value, language) == value
  
      @staticmethod
      def test_get_prep_value():
          """"Tests whether the :see:get_prep_value function
          produces the expected dictionary."""
  
          input_data = get_init_values()
          localized_value = LocalizedValue(input_data)
  
          output_data = LocalizedField().get_prep_value(localized_value)
  
          for language, value in input_data.items():
              assert language in output_data
              assert output_data.get(language) == value
  
      @staticmethod
      def test_get_prep_value_none():
          """Tests whether the :see:get_prep_value function
          produces the expected output when it is passed None."""
  
          output_data = LocalizedField().get_prep_value(None)
          assert not output_data
  
      @staticmethod
      def test_get_prep_value_no_localized_value():
          """Tests whether the :see:get_prep_value function
          produces the expected output when it is passed a
          non-LocalizedValue value."""
  
          output_data = LocalizedField().get_prep_value(['huh'])
          assert not output_data
  
      def test_get_prep_value_clean(self):
          """Tests whether the :see:get_prep_value produces
          None as the output when it is passed an empty, but
          valid LocalizedValue value but, only when null=True."""
  
          localized_value = LocalizedValue()
  
          with self.assertRaises(IntegrityError):
              LocalizedField(null=False).get_prep_value(localized_value)
  
          assert not LocalizedField(null=True).get_prep_value(localized_value)
          assert not LocalizedField().clean(None)
          assert not LocalizedField().clean(['huh'])
  
      @staticmethod
      def test_formfield():
          """Tests whether the :see:formfield function
          correctly returns a valid form."""
  
          assert isinstance(
              LocalizedField().formfield(),
              LocalizedFieldForm
          )
  
          # case optional filling
          field = LocalizedField(blank=True, required=[])
          assert not field.formfield().required
          for field in field.formfield().fields:
              assert not field.required
  
          # case required for any language
          field = LocalizedField(blank=False, required=[])
          assert field.formfield().required
          for field in field.formfield().fields:
              assert not field.required
  
          # case required for specific languages
          required_langs = ['ro', 'nl']
          field = LocalizedField(blank=False, required=required_langs)
          assert field.formfield().required
          for field in field.formfield().fields:
              if field.label in required_langs:
                  assert field.required
              else:
                  assert not field.required
  
          # case required for all languages
          field = LocalizedField(blank=False, required=True)
          assert field.formfield().required
          for field in field.formfield().fields:
              assert field.required
  
      def test_required_all(self):
          """Tests whether passing required=True properly validates
          that all languages are filled in."""
  
          model = get_fake_model(dict(
              title=LocalizedField(required=True)
          ))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(ro='romanian', nl='dutch'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(nl='dutch'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(random='random'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict())
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=None)
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title='')
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title='         ')
  
      def test_required_some(self):
          """Tests whether passing an array to required,
          properly validates whether the specified languages
          are marked as required."""
  
          model = get_fake_model(dict(
              title=LocalizedField(required=['nl', 'ro'])
          ))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(ro='romanian', nl='dutch'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(nl='dutch'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict(random='random'))
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=dict())
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title=None)
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title='')
  
          with self.assertRaises(IntegrityError):
              model.objects.create(title='         ')
  