Beispiel #1
0
    def test_log_scale(self, mock_resolve, mock_log10):
        mock_resolve.return_value = self.data
        mock_log10.return_value = [0, 1]
        self.ax.get_ylim.return_value = [1, 10]
        self.ax.get_yaxis().get_scale.return_value = 'log'
        self.ax.reset_mock()

        frequency.add_cum_kappa(self.ax,
                                self.data,
                                direction='x',
                                main=False,
                                scale=True,
                                fill=False,
                                invert=False)

        self.ax.plot.assert_called_once()
        self.ax.set_xlabel.assert_not_called()
        self.ax.set_ylabel.assert_not_called()
        self.ax.set_xlim.assert_not_called()
        self.ax.set_ylim.assert_not_called()
        self.ax.get_xlim.assert_called_once()
        self.ax.get_ylim.assert_called_once()
        self.ax.get_xaxis().get_scale.assert_called_once()
        self.ax.get_yaxis().get_scale.assert_called_once()
        mock_log10.assert_called_once()
    def test_not_main(self, mock_resolve):
        mock_resolve.return_value = self.data

        frequency.add_cum_kappa(self.ax, self.data, direction='x', main=False,
                                scale=False, fill=False, invert=False)

        self.ax.plot.assert_called_once()
        self.ax.set_xlabel.assert_not_called()
        self.ax.set_ylabel.assert_not_called()
        self.ax.set_xlim.assert_not_called()
        self.ax.set_ylim.assert_not_called()
        mock_resolve.assert_called_once()
    def test_fill(self, mock_resolve):
        mock_resolve.return_value = self.data

        frequency.add_cum_kappa(self.ax, self.data, direction='x', main=True,
                                scale=False, fill=True, invert=False)

        self.ax.fill_between.assert_called_once()
        self.ax.set_xlabel.assert_called_once()
        self.ax.set_ylabel.assert_called_once()
        self.ax.set_xlim.assert_called_once_with(0, 1)
        self.ax.set_ylim.assert_called_once_with(0, 2)
        mock_resolve.assert_called_once()
    def test_invert(self, mock_resolve):
        mock_resolve.return_value = self.data

        frequency.add_cum_kappa(self.ax, self.data, direction='x', main=True,
                                scale=False, fill=False, invert=True)

        self.ax.plot.assert_called_once()
        self.ax.set_xlabel.assert_called_once()
        self.ax.set_ylabel.assert_not_called()
        self.ax.tick_params.assert_called_once()
        self.ax.set_xlim.assert_called_once_with(0, 2)
        self.ax.set_ylim.assert_called_once_with(0, 1)
        mock_resolve.assert_called_once()
Beispiel #5
0
 def setUpClass(cls):
     cls.d = {
         'frequency': [0, 1],
         'mode_kappa': [[[[[0, 2]]]]],
         'temperature': [11],
         'meta': {}
     }
     cls.fig, cls.ax = one_small_legend()
     cls.ax = frequency.add_cum_kappa(cls.ax,
                                      cls.d,
                                      direction='x',
                                      main=True,
                                      scale=False)
Beispiel #6
0
 def setUpClass(cls):
     cls.d = {
         'frequency': [0, 1],
         'mode_kappa': [[[[[0, 2]]]]],
         'temperature': [11],
         'meta': {}
     }
     cls.fig, cls.ax = one_small_legend()
     cls.ylim = cls.ax.get_ylim()
     cls.ax.set_yscale('log')
     cls.ylim = (10, 100)
     cls.ax.set_ylim(cls.ylim)
     cls.ax = frequency.add_cum_kappa(cls.ax,
                                      cls.d,
                                      direction='x',
                                      main=False,
                                      scale=True)