Python QSettings.clear方法代码示例

# 需要导入模块: from qgis.PyQt.QtCore import QSettings [as 别名]
# 或者: from qgis.PyQt.QtCore.QSettings import clear [as 别名]
class TestNeedsProfile(NeedsProfile):
    """Since we don't want to change the actual minimum needs settings in
    QSettings, we are using a mock profile.

    :param test_profile: The mock replacement of Minimum Needs
    """
    # noinspection PyMissingConstructor

    def __init__(self, test_profile='Test Minimum Needs Settings'):
        self.settings = QSettings(test_profile)
        self.settings.clear()
        self.settings = QSettings(test_profile)
        self.local = 'en'
        minimum_needs = self._defaults()
        minimum_needs['provenance'] = 'Test'
        minimum_needs['profile'] = 'Test'
        self._root_directory = None
        self.minimum_needs = minimum_needs

    def __del__(self):
        self.settings.clear()

# 需要导入模块: from qgis.PyQt.QtCore import QSettings [as 别名]
# 或者: from qgis.PyQt.QtCore.QSettings import clear [as 别名]
    def test_get_displacement_rate_and_affected_with_qsetting(self):
        """Test for get_displacement_rate and is_affected with QSettings."""
        # Create custom qsettings
        qsettings = QSettings(INASAFE_TEST)
        qsettings.clear()
        # Save the default profile to qsettings
        default_profile = generate_default_profile()
        set_setting('population_preference', default_profile, qsettings)

        # Check the default one first
        default_profile = generate_default_profile()
        class_key = flood_hazard_classes['classes'][0]['key']
        value = is_affected(
            hazard_flood['key'],
            flood_hazard_classes['key'],
            class_key,
            qsettings)
        expected_value = default_profile[
            hazard_flood['key']][flood_hazard_classes['key']][class_key][
            'affected']
        self.assertEqual(value, expected_value)

        value = get_displacement_rate(
            hazard_flood['key'],
            flood_hazard_classes['key'],
            class_key,
            qsettings)
        expected_value = default_profile[
            hazard_flood['key']][flood_hazard_classes['key']][class_key][
            'displacement_rate']
        self.assertEqual(value, expected_value)

        # Change displacement rate
        new_displacement_rate = 1
        default_profile[
            hazard_flood['key']][flood_hazard_classes['key']][class_key][
            'displacement_rate'] = 1
        set_setting('population_preference', default_profile, qsettings)
        value = get_displacement_rate(
            hazard_flood['key'],
            flood_hazard_classes['key'],
            class_key,
            qsettings)
        self.assertEqual(value, new_displacement_rate)

        # Change affected value
        new_affected = False
        default_profile[
            hazard_flood['key']][flood_hazard_classes['key']][class_key][
            'affected'] = new_affected
        set_setting('population_preference', default_profile, qsettings)
        value = is_affected(
            hazard_flood['key'],
            flood_hazard_classes['key'],
            class_key,
            qsettings)
        self.assertEqual(value, new_affected)
        value = get_displacement_rate(
            hazard_flood['key'],
            flood_hazard_classes['key'],
            class_key,
            qsettings)
        # Should be 0 since it's not affected
        self.assertEqual(value, 0)

# 需要导入模块: from qgis.PyQt.QtCore import QSettings [as 别名]
# 或者: from qgis.PyQt.QtCore.QSettings import clear [as 别名]
class TestOptionsDialog(unittest.TestCase):

    """Test Options Dialog."""

    def setUp(self):
        """Fixture run before all tests."""
        self.qsetting = QSettings(INASAFE_TEST)
        self.qsetting.clear()

    def tearDown(self):
        """Fixture run after each test."""
        # Make sure it's empty
        self.qsetting.clear()

    def test_setup_dialog(self):
        """Test Setup Options Dialog."""
        dialog = OptionsDialog(
            parent=PARENT, iface=IFACE, qsetting=INASAFE_TEST)
        self.assertIsNotNone(dialog)

        # Check default values
        self.assertEqual(
            dialog.cbxVisibleLayersOnly.isChecked(),
            inasafe_default_settings['visibleLayersOnlyFlag'])
        self.assertEqual(
            dialog.cbxSetLayerNameFromTitle.isChecked(),
            inasafe_default_settings['set_layer_from_title_flag'])
        self.assertEqual(
            dialog.cbxZoomToImpact.isChecked(),
            inasafe_default_settings['setZoomToImpactFlag'])
        self.assertEqual(
            dialog.cbxHideExposure.isChecked(),
            inasafe_default_settings['setHideExposureFlag'])
        self.assertEqual(
            dialog.cbxUseSelectedFeaturesOnly.isChecked(),
            inasafe_default_settings['useSelectedFeaturesOnly'])
        self.assertEqual(
            dialog.leKeywordCachePath.text(),
            inasafe_default_settings['keywordCachePath'])
        self.assertEqual(
            dialog.template_warning_checkbox.isChecked(),
            inasafe_default_settings['template_warning_verbose'])
        self.assertEqual(
            dialog.organisation_on_dock_checkbox.isChecked(),
            inasafe_default_settings['showOrganisationLogoInDockFlag'])
        self.assertEqual(
            dialog.cbxDevMode.isChecked(),
            inasafe_default_settings['developer_mode'])

        self.assertEqual(
            dialog.leNorthArrowPath.text(), default_north_arrow_path())
        self.assertEqual(
            dialog.organisation_logo_path_line_edit.text(),
            supporters_logo_path())
        self.assertEqual(dialog.leReportTemplatePath.text(), '')
        self.assertEqual(dialog.txtDisclaimer.toPlainText(), disclaimer())
        self.assertEqual(
            dialog.leUserDirectoryPath.text(), temp_dir('impacts'))

        self.assertEqual(
            dialog.organisation_line_edit.text(),
            inasafe_default_settings['ISO19115_ORGANIZATION'])
        self.assertEqual(
            dialog.website_line_edit.text(),
            inasafe_default_settings['ISO19115_URL'])
        self.assertEqual(
            dialog.email_line_edit.text(),
            inasafe_default_settings['ISO19115_EMAIL'])
        self.assertEqual(
            dialog.license_line_edit.text(),
            inasafe_default_settings['ISO19115_LICENSE'])

    def test_update_settings(self):
        """Test update InaSAFE Option works."""
        # Create new option dialog
        dialog = OptionsDialog(
            parent=PARENT, iface=IFACE, qsetting=INASAFE_TEST)

        # Update some state
        new_state = not inasafe_default_settings['visibleLayersOnlyFlag']
        dialog.cbxVisibleLayersOnly.setChecked(new_state)

        new_organization = 'Super Organization'
        dialog.organisation_line_edit.setText(new_organization)

        # Accept the dialog
        dialog.accept()

        # Check the value in QSettings
        # Next two lines a hack because windows qsettings returns a string
        # rather than a bool...TS
        value = self.qsetting.value('inasafe/visibleLayersOnlyFlag')
        if value == 'false':
            value = False
        if value == 'true':
            value = True
        self.assertEqual(
            new_state, value)
        self.assertEqual(
            new_organization,
#.........这里部分代码省略.........

# 需要导入模块: from qgis.PyQt.QtCore import QSettings [as 别名]
# 或者: from qgis.PyQt.QtCore.QSettings import clear [as 别名]
class TestSettings(unittest.TestCase):
    """Test Settings."""

    def setUp(self):
        """Fixture run before all tests."""
        self.qsettings = QSettings(INASAFE_TEST)
        self.qsettings.clear()

    def tearDown(self):
        """Fixture run after each test."""
        # Make sure it's empty
        self.qsettings.clear()

    def test_read_write_setting(self):
        """Test read and write setting."""
        # General Setting
        set_general_setting('key', 'value', self.qsettings)
        self.assertEqual(
            'value', general_setting('key', qsettings=self.qsettings))
        delete_general_setting('key', qsettings=self.qsettings)
        self.assertEqual('default', general_setting(
            'key', default='default', qsettings=self.qsettings))

        set_general_setting('key', 'True', self.qsettings)
        self.assertEqual(
            'True',
            general_setting(
                'key', qsettings=self.qsettings, expected_type=str))
        self.assertEqual(
            True,
            general_setting(
                'key', qsettings=self.qsettings, expected_type=bool))
        delete_general_setting('key', qsettings=self.qsettings)
        self.assertEqual('default', general_setting(
            'key', default='default', qsettings=self.qsettings))

        set_general_setting('key', 'false', self.qsettings)
        self.assertEqual(
            'false',
            general_setting(
                'key', qsettings=self.qsettings, expected_type=str))
        self.assertEqual(
            False,
            general_setting(
                'key', qsettings=self.qsettings, expected_type=bool))
        delete_general_setting('key', qsettings=self.qsettings)
        self.assertEqual('default', general_setting(
            'key', default='default', qsettings=self.qsettings))

        # Under InaSAFE scope
        set_setting('key', 'value', self.qsettings)
        self.assertEqual('value', setting('key', qsettings=self.qsettings))
        delete_setting('key', qsettings=self.qsettings)
        self.assertEqual('default', setting(
            'key', default='default', qsettings=self.qsettings))

        # Using InaSAFE setting default
        key = 'developer_mode'
        actual_value = inasafe_default_settings.get(key)
        self.assertEqual(actual_value, setting(key, qsettings=self.qsettings))

    def test_read_write_dictionary(self):
        """Test for reading and writing dictionary in QSettings."""
        dictionary = {
            'a': 'a',
            'b': 1,
            'c': {
                'd': True,
                'e': {
                    'f': 1.0,
                    'g': 2
                }
            }
        }
        set_setting('key', dictionary, self.qsettings)
        value = setting('key', qsettings=self.qsettings)
        self.assertDictEqual(dictionary, value)

        profile_dictionary = generate_default_profile()
        set_setting(
            'population_preference',
            profile_dictionary,
            self.qsettings)
        value = setting('population_preference', qsettings=self.qsettings)
        self.assertDictEqual(profile_dictionary, value)

    def test_export_import_setting(self):
        """Test for export_setting method."""
        profile_file = unique_filename(
            suffix='.json', dir='population_preference')
        original_settings = {
            'key': 'value',
            'key_bool': True,
            'population_preference': generate_default_profile(),
            'key_int': 1,
            'key_float': 2.0
        }
        # Write
        for key, value in list(original_settings.items()):
            set_setting(key, value, self.qsettings)
#.........这里部分代码省略.........