Commit db2c5699 authored by Javier Vegas-Regidor's avatar Javier Vegas-Regidor
Browse files

Added missing tests for general diagnostics

parent f5ca425f
......@@ -43,9 +43,8 @@ class Relink(Diagnostic):
self.grid = grid
def __str__(self):
return 'Relink output Startdate: {0} Member: {1} Chunk: {2} Move old: {5} ' \
'Variable: {3}:{4} Grid: {6}'.format(self.startdate, self.member, self.chunk, self.domain, self.variable,
self.move_old, self.grid)
return 'Relink output Startdate: {0.startdate} Member: {0.member} Chunk: {0.chunk} Move old: {0.move_old} ' \
'Variable: {0.domain}:{0.variable} Grid: {0.grid}'.format(self)
def __eq__(self, other):
return self.startdate == other.startdate and self.member == other.member and self.chunk == other.chunk and \
......
......@@ -3,6 +3,7 @@ import iris
import iris.analysis
import iris.exceptions
from diagnostic import DiagnosticOption
from earthdiagnostics.box import Box
from earthdiagnostics.diagnostic import Diagnostic, DiagnosticFloatOption, DiagnosticDomainOption, \
DiagnosticVariableOption
......@@ -38,7 +39,7 @@ class VerticalMeanMetersIris(Diagnostic):
alias = 'vmean'
"Diagnostic alias for the configuration file"
def __init__(self, data_manager, startdate, member, chunk, domain, variable, box, grid_point):
def __init__(self, data_manager, startdate, member, chunk, domain, variable, box):
Diagnostic.__init__(self, data_manager)
self.startdate = startdate
self.member = member
......@@ -46,9 +47,6 @@ class VerticalMeanMetersIris(Diagnostic):
self.domain = domain
self.variable = variable
self.box = box
self.required_vars = [variable]
self.generated_vars = [variable + 'vmean']
self.grid_point = grid_point
def __eq__(self, other):
return self.startdate == other.startdate and self.member == other.member and self.chunk == other.chunk and \
......@@ -84,7 +82,7 @@ class VerticalMeanMetersIris(Diagnostic):
job_list = list()
for startdate, member, chunk in diags.config.experiment.get_chunk_list():
job_list.append(VerticalMeanMetersIris(diags.data_manager, startdate, member, chunk,
options['domain'], options['variable'], box, options['grid_point']))
options['domain'], options['variable'], box))
return job_list
def request_data(self):
......
......@@ -72,7 +72,7 @@ class YearlyMean(Diagnostic):
options_available = (DiagnosticDomainOption(),
DiagnosticVariableOption(),
DiagnosticFrequencyOption(),
DiagnosticFrequencyOption(default_value=diags.config.frequency),
DiagnosticOption('grid', ''))
options = cls.process_options(options, options_available)
job_list = list()
......
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption
from earthdiagnostics.box import Box
from earthdiagnostics.general.module import Module
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestModule(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.model_version = 'model_version'
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = Module.generate_jobs(self.diags, ['diagnostic', 'atmos', 'varu', 'varv', 'varmodule'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Module(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos,
'varu', 'varv', 'varmodule', ''))
self.assertEqual(jobs[1], Module(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos,
'varu', 'varv', 'varmodule', ''))
jobs = Module.generate_jobs(self.diags, ['diagnostic', 'seaIce', 'varu', 'varv', 'varmodule', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Module(self.data_manager, '20010101', 0, 0, ModelingRealms.seaIce,
'varu', 'varv', 'varmodule', 'grid'))
self.assertEqual(jobs[1], Module(self.data_manager, '20010101', 0, 1, ModelingRealms.seaIce,
'varu', 'varv', 'varmodule', 'grid'))
with self.assertRaises(Exception):
Module.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(Exception):
Module.generate_jobs(self.diags, ['diagnostic', '0', '0', '0', '0', '0', '0', '0'])
def test_str(self):
mixed = Module(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'varu', 'varv', 'varmodule', 'grid')
self.assertEquals(str(mixed), 'Calculate module Startdate: 20010101 Member: 0 Chunk: 0 '
'Variables: atmos:varu,varv,varmodule Grid: grid')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption
from earthdiagnostics.box import Box
from earthdiagnostics.general.relink import Relink
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestRelink(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.model_version = 'model_version'
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = Relink.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Relink(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos,
'var', True, ''))
self.assertEqual(jobs[1], Relink(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos,
'var', True, ''))
jobs = Relink.generate_jobs(self.diags, ['diagnostic', 'seaIce', 'var', 'False'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Relink(self.data_manager, '20010101', 0, 0, ModelingRealms.seaIce,
'var', False, ''))
self.assertEqual(jobs[1], Relink(self.data_manager, '20010101', 0, 1, ModelingRealms.seaIce,
'var', False, ''))
jobs = Relink.generate_jobs(self.diags, ['diagnostic', 'ocean', 'var', 'True', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Relink(self.data_manager, '20010101', 0, 0, ModelingRealms.ocean,
'var', True, 'grid'))
self.assertEqual(jobs[1], Relink(self.data_manager, '20010101', 0, 1, ModelingRealms.ocean,
'var', True, 'grid'))
with self.assertRaises(Exception):
Relink.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(Exception):
Relink.generate_jobs(self.diags, ['diagnostic', '0', '0', '0', '0', '0', '0', '0'])
def test_str(self):
mixed = Relink(self.data_manager, '20010101', 0, 0, ModelingRealms.ocean, 'var', True, 'grid')
self.assertEquals(str(mixed), 'Relink output Startdate: 20010101 Member: 0 Chunk: 0 Move old: True '
'Variable: ocean:var Grid: grid')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption
from earthdiagnostics.box import Box
from earthdiagnostics.general.relinkall import RelinkAll
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestRelinkAll(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.experiment.startdates = ['20010101', ]
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = RelinkAll.generate_jobs(self.diags, ['diagnostic'])
self.assertEqual(len(jobs), 1)
self.assertEqual(jobs[0], RelinkAll(self.data_manager, '20010101'))
with self.assertRaises(Exception):
RelinkAll.generate_jobs(self.diags, ['diagnostic', '0'])
def test_str(self):
mixed = RelinkAll(self.data_manager, '20010101')
self.assertEquals(str(mixed), 'Relink all output Startdate: 20010101')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption, DiagnosticOptionError
from earthdiagnostics.box import Box
from earthdiagnostics.general.scale import Scale
from earthdiagnostics.frequency import Frequencies
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestScale(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.experiment.startdates = ['20010101', ]
self.diags.config.frequency = Frequencies.monthly
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = Scale.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '0'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Scale(self.data_manager, '20010101', 0, 0, 0, 0, ModelingRealms.atmos, 'var', '',
float('nan'), float('nan'), Frequencies.monthly))
self.assertEqual(jobs[1], Scale(self.data_manager, '20010101', 0, 1, 0, 0, ModelingRealms.atmos, 'var', '',
float('nan'), float('nan'), Frequencies.monthly))
jobs = Scale.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '0', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Scale(self.data_manager, '20010101', 0, 0, 0, 0, ModelingRealms.atmos, 'var', 'grid',
float('nan'), float('nan'), Frequencies.monthly))
self.assertEqual(jobs[1], Scale(self.data_manager, '20010101', 0, 1, 0, 0, ModelingRealms.atmos, 'var', 'grid',
float('nan'), float('nan'), Frequencies.monthly))
jobs = Scale.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '0', 'grid', '0', '100'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Scale(self.data_manager, '20010101', 0, 0, 0, 0, ModelingRealms.atmos, 'var', 'grid',
0, 100, Frequencies.monthly))
self.assertEqual(jobs[1], Scale(self.data_manager, '20010101', 0, 1, 0, 0, ModelingRealms.atmos, 'var', 'grid',
0, 100, Frequencies.monthly))
jobs = Scale.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '0', 'grid', '0', '100', '3hr'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], Scale(self.data_manager, '20010101', 0, 0, 0, 0, ModelingRealms.atmos, 'var', 'grid',
0, 100, Frequencies.three_hourly))
self.assertEqual(jobs[1], Scale(self.data_manager, '20010101', 0, 1, 0, 0, ModelingRealms.atmos, 'var', 'grid',
0, 100, Frequencies.three_hourly))
with self.assertRaises(DiagnosticOptionError):
Scale.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(DiagnosticOptionError):
Scale.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '0', 'grid', '0', '100', '3hr',
'extra'])
def test_str(self):
mixed = Scale(self.data_manager, '20010101', 0, 0, 0, 0, ModelingRealms.atmos, 'var', 'grid', 0, 100,
Frequencies.three_hourly)
self.assertEquals(str(mixed), 'Scale output Startdate: 20010101 Member: 0 Chunk: 0 Scale value: 0 Offset: 0 '
'Variable: atmos:var Frequency: 3hr')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableListOption, DiagnosticOptionError
from earthdiagnostics.box import Box
from earthdiagnostics.general.select_levels import SelectLevels
from earthdiagnostics.frequency import Frequencies
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestSelectLevels(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.experiment.startdates = ['20010101', ]
self.diags.config.frequency = Frequencies.monthly
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value.split('-')
@patch.object(DiagnosticVariableListOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = SelectLevels.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '20'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], SelectLevels(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var',
'', 0, 20))
self.assertEqual(jobs[1], SelectLevels(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos, 'var',
'', 0, 20))
jobs = SelectLevels.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var1-var2', '0', '20'])
self.assertEqual(len(jobs), 4)
self.assertEqual(jobs[0], SelectLevels(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var1',
'', 0, 20))
self.assertEqual(jobs[1], SelectLevels(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos, 'var1',
'', 0, 20))
self.assertEqual(jobs[2], SelectLevels(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var2',
'', 0, 20))
self.assertEqual(jobs[3], SelectLevels(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos, 'var2',
'', 0, 20))
jobs = SelectLevels.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '20', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], SelectLevels(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var',
'grid', 0, 20))
self.assertEqual(jobs[1], SelectLevels(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos, 'var',
'grid', 0, 20))
with self.assertRaises(DiagnosticOptionError):
SelectLevels.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(DiagnosticOptionError):
SelectLevels.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', '0', '20', 'grid', 'extra'])
def test_str(self):
mixed = SelectLevels(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var', 'grid', 0, 20)
self.assertEquals(str(mixed), 'Select levels Startdate: 20010101 Member: 0 Chunk: 0 Variable: atmos:var '
'Levels: 0-20 Grid: grid')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableListOption, DiagnosticOptionError
from earthdiagnostics.box import Box
from earthdiagnostics.general.simplify_dimensions import SimplifyDimensions
from earthdiagnostics.frequency import Frequencies
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestSimplifyDimensions(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.experiment.startdates = ['20010101', ]
self.diags.config.frequency = Frequencies.monthly
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
return value.split('-')
@patch.object(DiagnosticVariableListOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = SimplifyDimensions.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], SimplifyDimensions(self.data_manager, '20010101', 0, 0,
ModelingRealms.atmos, 'var', ''))
self.assertEqual(jobs[1], SimplifyDimensions(self.data_manager, '20010101', 0, 1,
ModelingRealms.atmos, 'var', ''))
jobs = SimplifyDimensions.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], SimplifyDimensions(self.data_manager, '20010101', 0, 0,
ModelingRealms.atmos, 'var', 'grid'))
self.assertEqual(jobs[1], SimplifyDimensions(self.data_manager, '20010101', 0, 1,
ModelingRealms.atmos, 'var', 'grid'))
with self.assertRaises(DiagnosticOptionError):
SimplifyDimensions.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(DiagnosticOptionError):
SimplifyDimensions.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', 'grid', 'extra'])
def test_str(self):
mixed = SimplifyDimensions(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var', 'grid')
self.assertEquals(str(mixed), 'Simplify dimension Startdate: 20010101 Member: 0 Chunk: 0 Variable: atmos:var '
'Grid: grid')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption, DiagnosticOptionError
from earthdiagnostics.box import Box
from earthdiagnostics.general.verticalmeanmetersiris import VerticalMeanMetersIris
from earthdiagnostics.frequency import Frequencies
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestVerticalMeanMetersIris(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.experiment.startdates = ['20010101', ]
self.diags.config.frequency = Frequencies.monthly
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
def fake_parse(self, value):
if not value:
raise DiagnosticOptionError
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
box = Box(True)
jobs = VerticalMeanMetersIris.generate_jobs(self.diags, ['diagnostic', 'var'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 0,
ModelingRealms.ocean, 'var', box))
self.assertEqual(jobs[1], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 1,
ModelingRealms.ocean, 'var', box))
box = Box(True)
box.min_depth = 0
box.max_depth = 100
jobs = VerticalMeanMetersIris.generate_jobs(self.diags, ['diagnostic', 'var', '0', '100'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 0,
ModelingRealms.ocean, 'var', box))
self.assertEqual(jobs[1], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 1,
ModelingRealms.ocean, 'var', box))
jobs = VerticalMeanMetersIris.generate_jobs(self.diags, ['diagnostic', 'var', '0', '100', 'seaIce'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 0,
ModelingRealms.seaIce, 'var', box))
self.assertEqual(jobs[1], VerticalMeanMetersIris(self.data_manager, '20010101', 0, 1,
ModelingRealms.seaIce, 'var', box))
with self.assertRaises(DiagnosticOptionError):
VerticalMeanMetersIris.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(DiagnosticOptionError):
VerticalMeanMetersIris.generate_jobs(self.diags, ['diagnostic', 'var', '0', '100', 'seaIce', 'extra'])
def test_str(self):
box = Box(True)
box.min_depth = 0
box.max_depth = 100
mixed = VerticalMeanMetersIris(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var', box)
self.assertEquals(str(mixed), 'Vertical mean meters Startdate: 20010101 Member: 0 Chunk: 0 Variable: atmos:var '
'Box: 0-100m')
# coding=utf-8
from unittest import TestCase
from earthdiagnostics.diagnostic import DiagnosticVariableOption
from earthdiagnostics.box import Box
from earthdiagnostics.frequency import Frequencies
from earthdiagnostics.general.yearlymean import YearlyMean
from mock import Mock, patch
from earthdiagnostics.modelingrealm import ModelingRealms
class TestYearlyMean(TestCase):
def setUp(self):
self.data_manager = Mock()
self.diags = Mock()
self.diags.config.experiment.get_chunk_list.return_value = (('20010101', 0, 0), ('20010101', 0, 1))
self.diags.config.frequency = Frequencies.monthly
self.box = Box()
self.box.min_depth = 0
self.box.max_depth = 100
self.mixed = YearlyMean(self.data_manager, '20000101', 1, 1, ModelingRealms.ocean, 'var', 'freq', '')
def fake_parse(self, value):
return value
@patch.object(DiagnosticVariableOption, 'parse', fake_parse)
def test_generate_jobs(self):
jobs = YearlyMean.generate_jobs(self.diags, ['diagnostic', 'ocean', 'var'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], YearlyMean(self.data_manager, '20010101', 0, 0, ModelingRealms.ocean, 'var',
Frequencies.monthly, ''))
self.assertEqual(jobs[1], YearlyMean(self.data_manager, '20010101', 0, 1, ModelingRealms.ocean, 'var',
Frequencies.monthly, ''))
jobs = YearlyMean.generate_jobs(self.diags, ['diagnostic', 'atmos', 'var', 'day'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], YearlyMean(self.data_manager, '20010101', 0, 0, ModelingRealms.atmos, 'var',
Frequencies.daily, ''))
self.assertEqual(jobs[1], YearlyMean(self.data_manager, '20010101', 0, 1, ModelingRealms.atmos, 'var',
Frequencies.daily, ''))
jobs = YearlyMean.generate_jobs(self.diags, ['diagnostic', 'seaice', 'var', 'mon', 'grid'])
self.assertEqual(len(jobs), 2)
self.assertEqual(jobs[0], YearlyMean(self.data_manager, '20010101', 0, 0, ModelingRealms.seaIce, 'var',
Frequencies.monthly, 'grid'))
self.assertEqual(jobs[1], YearlyMean(self.data_manager, '20010101', 0, 1, ModelingRealms.seaIce, 'var',
Frequencies.monthly, 'grid'))
with self.assertRaises(Exception):
YearlyMean.generate_jobs(self.diags, ['diagnostic'])
with self.assertRaises(Exception):
YearlyMean.generate_jobs(self.diags, ['diagnostic', '0', '0', '0', '0', '0', '0', '0'])
def test_str(self):
self.assertEquals(str(self.mixed), 'Calculate yearly mean Startdate: 20000101 Member: 1 Chunk: 1 '
'Variable: ocean:var Original frequency: freq Grid: ')
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment