def test_hazards_for_layer(self):
        """Test for hazards_for_layer"""
        impact_function_manager = ImpactFunctionManager()
        hazards = impact_function_manager.hazards_for_layer(
            'polygon', 'single_event')
        # print [x['key'] for x in hazards]
        expected = [
            hazard_flood,
            hazard_tsunami,
            hazard_earthquake,
            hazard_volcano,
            hazard_volcanic_ash,
            hazard_generic
        ]
        self.assertItemsEqual(hazards, expected)

        hazards = impact_function_manager.hazards_for_layer('polygon')
        expected = [hazard_flood, hazard_tsunami, hazard_earthquake,
                    hazard_volcano, hazard_volcanic_ash, hazard_generic]
        self.assertItemsEqual(hazards, expected)

        hazards = impact_function_manager.hazards_for_layer(
            'point', 'single_event')
        expected = [hazard_volcano]
        self.assertItemsEqual(hazards, expected)

    def test_available_hazards(self):
        """Test available_hazards API."""
        impact_function_manager = ImpactFunctionManager()

        result = impact_function_manager.available_hazards(
            'single_event')
        print [x['key'] for x in result]

    def test_functions_for_constraint(self):
        """Test functions_for_constraint."""
        ifm = ImpactFunctionManager()
        impact_functions = ifm.functions_for_constraint(
            'earthquake',
            'population',
            'raster',
            'raster',
            'continuous',
            'continuous',
        )
        expected = [
            ITBFatalityFunction.metadata().as_dict(),
            ITBBayesianFatalityFunction.metadata().as_dict(),
            PAGFatalityFunction.metadata().as_dict(),
            ContinuousHazardPopulationFunction.metadata().as_dict()]

        for key in impact_functions[0].keys():
            if key == 'parameters':
                # We do not check the parameters since they are mutable.
                continue
            result = [x[key] for x in impact_functions]
            hope = [x[key] for x in expected]
            message = key
            self.assertItemsEqual(result, hope, message)

    def test_get_functions_for_constraint(self):
        """Test get_functions_for_constraint."""
        impact_function_manager = ImpactFunctionManager()
        hazard = hazard_earthquake
        exposure = exposure_structure

        expected_result = [
            EarthquakeBuildingImpactFunction.Metadata.get_metadata(),
            ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata()]
        result = impact_function_manager.get_functions_for_constraint(
            hazard, exposure)
        message = ('I expect %s but I got %s.' % (expected_result, result))
        self.assertItemsEqual(expected_result, result, message)

        hazard_constraint = layer_raster_continuous
        exposure_constraint = None

        expected_result = [
            EarthquakeBuildingImpactFunction.Metadata.get_metadata()]
        result = impact_function_manager.get_functions_for_constraint(
            hazard, exposure, hazard_constraint, exposure_constraint)
        message = ('I expect %s but I got %s.' % (expected_result, result))
        self.assertItemsEqual(expected_result, result, message)

        hazard_constraint = layer_vector_polygon
        exposure_constraint = layer_vector_line

        expected_result = []
        result = impact_function_manager.get_functions_for_constraint(
            hazard, exposure, hazard_constraint, exposure_constraint)
        message = ('I expect %s but I got %s.' % (expected_result, result))
        self.assertItemsEqual(expected_result, result, message)

 def test_exposure_units_for_layer(self):
     """Test for exposure_units_for_layer"""
     impact_function_manager = ImpactFunctionManager()
     exposure_units = impact_function_manager.exposure_units_for_layer(
         'population', 'raster', 'continuous')
     expected = [count_exposure_unit, density_exposure_unit]
     self.assertItemsEqual(exposure_units, expected)

    def test_available_hazard_layer_modes(self):
        """Test for available_hazard_layer_modes."""
        ifm = ImpactFunctionManager()
        hazard_layer_mode = ifm.available_hazard_layer_modes(
            'earthquake', 'raster', 'single_event')
        expected = [layer_mode_continuous, layer_mode_classified]

        self.assertItemsEqual(hazard_layer_mode, expected)

 def test_available_exposures(self):
     """Test available_exposures API."""
     impact_function_manager = ImpactFunctionManager()
     result = impact_function_manager.available_exposures()
     expected_result = [
         exposure_structure, exposure_road, exposure_population]
     message = ('I expect %s but I got %s.' % (expected_result, result))
     self.assertItemsEqual(result, expected_result, message)

    def test_available_exposure_layer_modes(self):
        """Test for available_exposure_layer_modes."""
        ifm = ImpactFunctionManager()
        exposure_layer_mode = ifm.available_exposure_layer_modes(
            'population', 'raster')
        expected = [layer_mode_continuous]

        self.assertItemsEqual(exposure_layer_mode, expected)

def analysis_setup(command_line_arguments, hazard, exposure, aggregation=None):
    """Sets up an analysis object.

    .. versionadded:: 3.2

    :param command_line_arguments: User inputs.
    :type command_line_arguments: CommandLineArguments

    :param hazard: Hazard layer
    :type hazard: QgsLayer

    :param exposure: Exposure Layer
    :type exposure: QgsLayer

    :param aggregation: Aggregation Layer
    :type aggregation: QgsLayer

    :raises: Exception
    """
    # IF
    impact_function_manager = ImpactFunctionManager()
    impact_function = impact_function_manager.get(command_line_arguments.impact_function)
    keyword_io = KeywordIO()

    try:
        from safe.utilities.analysis import Analysis
    except ImportError as ie:
        LOGGER.debug("Import error for Analysis module")
        print ie.message
        raise ImportError
    analysis = Analysis()
    analysis.impact_function = impact_function
    analysis.hazard = hazard
    analysis.exposure = exposure
    analysis.aggregation = aggregation
    # analysis.hazard_keyword = keyword_io.read_keywords(hazard)
    # analysis.exposure_keyword = keyword_io.read_keywords(exposure)
    analysis.clip_hard = False
    analysis.show_intermediate_layers = False
    analysis.run_in_thread_flag = False
    analysis.map_canvas = CANVAS
    # QSetting context
    settings = QSettings()
    crs = settings.value("inasafe/analysis_extent_crs", "", type=str)
    analysis.user_extent_crs = QgsCoordinateReferenceSystem(crs)
    try:
        analysis.user_extent = QgsRectangle(
            float(command_line_arguments.extent[0]),
            float(command_line_arguments.extent[1]),
            float(command_line_arguments.extent[2]),
            float(command_line_arguments.extent[3]),
        )
    except AttributeError:
        print "No extents"
        pass
    analysis.setup_analysis()
    return analysis

    def test_available_exposure_constraints(self):
        """Test for available_exposure_constraints."""
        ifm = ImpactFunctionManager()
        exposure_constraints = ifm.available_exposure_constraints(
            'population')
        expected = [
            (layer_mode_continuous, layer_geometry_raster),
        ]

        self.assertItemsEqual(exposure_constraints, expected)

    def test_exposure_class_fields(self):
        """Test for exposure_class_fields."""
        ifm = ImpactFunctionManager()
        additional_keywords = ifm.exposure_class_fields(
            layer_mode_key='classified',
            layer_geometry_key='polygon',
            exposure_key='structure'
        )
        expected = [structure_class_field]

        self.assertItemsEqual(additional_keywords, expected)

 def test_available_exposures(self):
     """Test available_exposures API."""
     impact_function_manager = ImpactFunctionManager()
     result = impact_function_manager.available_exposures()
     expected_result = [
         exposure_structure,
         exposure_road,
         exposure_population,
         exposure_place,
         exposure_land_cover]
     self.assertItemsEqual(result, expected_result)

    def test_hazard_additional_keywords(self):
        """Test for hazard_additional_keywords."""
        ifm = ImpactFunctionManager()
        additional_keywords = ifm.hazard_additional_keywords(
            layer_mode_key='classified',
            layer_geometry_key='polygon',
            hazard_category_key='single_event',
            hazard_key='flood'
        )
        expected = []

        self.assertItemsEqual(additional_keywords, expected)

def analysis_execution():

    from safe.test.utilities import get_qgis_app

    # get_qgis_app must be called before importing Analysis
    QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app()

    from safe.utilities.analysis import Analysis
    from safe.utilities.keyword_io import KeywordIO

    analysis = Analysis()

    arg = AnalysisArguments.read_arguments()

    register_impact_functions()

    registry = ImpactFunctionManager().registry

    function = registry.get_instance(arg.impact_function_name)

    hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename))
    exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename))
    if arg.aggregation_filename:
        aggregation_layer = safe_to_qgis_layer(read_layer(
            arg.aggregation_filename))

    keywords_io = KeywordIO()

    try:
        analysis.map_canvas = IFACE.mapCanvas()
        analysis.hazard_layer = hazard_layer
        analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer)
        analysis.exposure_layer = exposure_layer
        analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer)
        if aggregation_layer:
            analysis.aggregation_layer = aggregation_layer
            analysis.aggregation_keyword = keywords_io.read_keywords(
                aggregation_layer)
        analysis.impact_function = function

        analysis.setup_analysis()
        print 'Setup analysis done'
        analysis.run_analysis()
        print 'Analysis done'
    except Exception as e:
        print e.message

    impact = analysis.impact_layer
    qgis_impact = safe_to_qgis_layer(impact)

    generate_styles(impact, qgis_impact)

    copy_impact_layer(impact, arg.impact_filename)

    def test_available_hazard_constraints(self):
        """Test for available_hazard_constraints."""
        ifm = ImpactFunctionManager()
        hazard_constraints = ifm.available_hazard_constraints(
            'earthquake', 'single_event')
        expected = [
            (layer_mode_continuous, layer_geometry_raster),
            (layer_mode_classified, layer_geometry_raster),
            (layer_mode_classified, layer_geometry_polygon),
        ]

        print [(x[0]['key'], x[1]['key']) for x in hazard_constraints]

    def test_exposures_for_layer(self):
        """Test for exposures_for_layer"""
        impact_function_manager = ImpactFunctionManager()
        exposures = impact_function_manager.exposures_for_layer(
            'polygon')
        expected = [exposure_structure]
        self.assertItemsEqual(exposures, expected)

        exposures = impact_function_manager.exposures_for_layer(
            'line')
        expected = [exposure_road]
        self.assertItemsEqual(exposures, expected)

 def test_get_functions_for_hazard_id(self):
     """Test get_functions_for_hazard_id API."""
     impact_function_manager = ImpactFunctionManager()
     result = impact_function_manager.get_functions_for_hazard_id(
         hazard_volcano['id'])
     expected_result = [
         VolcanoBuildingImpact.Metadata.get_metadata(),
         VolcanoPolygonHazardPopulation.Metadata.get_metadata(),
         ContinuousHazardPopulationImpactFunction.Metadata.get_metadata(),
         ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata(),
         ClassifiedHazardPopulationImpactFunction.Metadata.get_metadata()]
     message = ('I expect %s but I got %s.' % (expected_result, result))
     self.assertItemsEqual(result, expected_result, message)

    def test_get_available_hazards(self):
        """Test get_available_hazards API."""
        impact_function_manager = ImpactFunctionManager()

        result = impact_function_manager.get_available_hazards()
        expected_result = hazard_all
        message = ('I expect %s but I got %s.' % (expected_result, result))
        self.assertItemsEqual(result, expected_result, message)

        impact_function = EarthquakeBuildingImpactFunction()
        result = impact_function_manager.get_available_hazards(impact_function)
        expected_result = [hazard_earthquake]
        message = ('I expect %s but I got %s.' % (expected_result, result))
        self.assertItemsEqual(result, expected_result, message)

 def test_get_functions_for_exposure_id(self):
     """Test get_functions_for_exposure_id API."""
     impact_function_manager = ImpactFunctionManager()
     result = impact_function_manager.get_functions_for_exposure_id(
         exposure_structure['id'])
     expected_result = [
         VolcanoBuildingImpact.Metadata.get_metadata(),
         EarthquakeBuildingImpactFunction.Metadata.get_metadata(),
         FloodRasterBuildingImpactFunction.Metadata.get_metadata(),
         FloodVectorBuildingImpactFunction.Metadata.get_metadata(),
         FloodNativePolygonExperimentalFunction.Metadata.get_metadata(),
         ClassifiedHazardBuildingImpactFunction.Metadata.get_metadata()]
     message = ('I expect %s but I got %s.' % (expected_result, result))
     self.assertItemsEqual(result, expected_result, message)

def show_impact_function_names(impact_functions):
    """Prints a list of impact functions.

    .. versionadded:: 3.2

    :param impact_functions: A list of impact function ids.
    :type: list of strings.
    """
    manager = ImpactFunctionManager()
    print ""
    print "Available Impact Function:"
    for impact_function in impact_functions:
        print manager.get_function_id(impact_function)
    print ""