def test_parse_integrated_4(self):
indata = '2-3/4*2+1'
actual = parsing.parse_definition(indata)
d34 = parsing.ParsedBinOp([['/', 3, 4]])
d34m2 = parsing.ParsedBinOp([['*', d34, 2]])
s2d34m2 = parsing.ParsedBinOp([['-', 2, d34m2]])
expected = parsing.ParsedBinOp([['+', s2d34m2, 1]])
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertEqual(actual, expected, 'Integrated #4 operator parsing failed')
def test_parse_integrated_1(self):
indata = '2-17.3*x**2'
actual = parsing.parse_definition(indata)
x = parsing.ParsedVariable([['x']])
x2 = parsing.ParsedBinOp([['**', x, 2]])
m17p3x2 = parsing.ParsedBinOp([['*', 17.3, x2]])
expected = parsing.ParsedBinOp([['-', 2, m17p3x2]])
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertEqual(actual, expected, 'Integrated #1 operator parsing failed')
def test_unique_same_names_unset(self):
indata = [DimensionDesc('x'), DimensionDesc('x')]
actual = DimensionDesc.unique(indata)
expected = OrderedDict([(indata[0].name, indata[0])])
print_test_message('DimensionDesc.unique([d1, d1])',
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(
actual, expected,
'DimensionDesc.unique fails with same names, all unset')
def test_func_mean_physarray_2d(self):
key = 'mean'
indata = PhysArray([[1.0, 2.0], [3.0, 4.0]], mask=[[False, False], [True, False]],
name='x', units='m', dimensions=('t', 'u'))
testname = '{}({})'.format(key, indata)
func = functions.find(key)
fobj = func(indata, 't')
actual = fobj[:]
expected = PhysArray([1.0, 3.0], name='mean(x, dims=[t])', units='m', dimensions=('u',))
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, '{} failed'.format(testname))
def test_op_pow_float(self):
key = '**'
left = 2.4
right = 3.2
testname = '({} {} {})'.format(left, key, right)
func = functions.find(key, 2)
actual = func(left, right)[:]
expected = 2.4 ** 3.2
print_test_message(testname, actual=actual,
expected=expected, left=left, right=right)
self.assertEqual(actual, expected, '{} failed'.format(testname))
def test_output_dataset_variable_files(self):
outds = OutputDatasetDesc('myoutds', self.dsdict)
actual = {v.name:v.files.keys() for v in outds.variables.itervalues()}
expected = {'X': ['var1.nc', 'var2.nc'],
'Y': ['var1.nc', 'var2.nc'],
'T': ['var1.nc', 'var2.nc'],
'W': ['var1.nc'],
'V1': ['var1.nc', 'var2.nc'],
'V2': ['var2.nc']}
print_test_message('OutputDatasetDesc.variables.files', actual=actual, expected=expected)
self.assertEqual(actual, expected, 'OutputDatasetDesc has wrong variable files')
def test_convert(self):
xdata = numpy.array(2., dtype='d')
X = PhysArray(xdata, name='X', units='km')
indata = 'm'
testname = 'X.convert({})'.format(indata)
actual = X.convert(Unit(indata))
new_name = "convert({}, from={}, to={})".format(
X.name, X.units, indata)
expected = PhysArray(2000., name=new_name, units=indata)
print_test_message(testname, actual=actual, expected=expected, X=X)
self.assertPhysArraysEqual(actual, expected, testname=testname)
def test_init_dimensions_value_error(self):
invalid_input = [(1, 2), ['a', 'b', 'c'], []]
for indata in invalid_input:
testname = 'PhysArray([1,2,3], name="X", dimensions={!r})'.format(
indata)
expected = ValueError
print_test_message(testname, units=indata, expected=expected)
self.assertRaises(expected,
PhysArray, [1, 2, 3],
dimensions=indata,
name='X')
def test_size(self):
indata = 1
ddesc = DimensionDesc('x', size=indata)
actual = ddesc.size
expected = indata
print_test_message('DimensionDesc.size',
input=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected,
'DimensionDesc.size is not set properly')
def test_pst_init_args(self):
indata = (['x', 1, -3.2], {})
pst = parsing.FuncType(indata)
actual = type(pst)
expected = parsing.FuncType
testname = 'FuncType.__init__({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected, 'Types do not match')
def test_parse_neg_func(self):
indata = '-f()'
actual = parsing.parse_definition(indata)
f = parsing.FuncType('f')
expected = parsing.OpType('-', [f])
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected, 'Negation parsing failed')
def test_parse_neg_var(self):
indata = '-x'
actual = parsing.parse_definition(indata)
x = parsing.VarType('x')
expected = parsing.OpType('-', [x])
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected, 'Negation parsing failed')
def test_varpst_init(self):
indata = ['x']
pst = parsing.VarType(*indata)
actual = type(pst)
expected = parsing.VarType
testname = 'VarType.__init__({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected, 'Types do not match')
def test_execute_chunks_2D_t_y(self):
testname = 'DataFlow().execute()'
df = dataflow.DataFlow(self.inpds, self.outds)
df.execute(chunks=OrderedDict([('t', 2), ('y', 3)]))
actual = all(exists(f) for f in self.outfiles.itervalues())
expected = True
print_test_message(testname, actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
for f in self.outfiles:
print_ncfile(self.outfiles[f])
print
def test_execute_all(self):
testname = 'DataFlow().execute()'
df = dataflow.DataFlow(self.inpds, self.outds)
df.execute(history=True)
actual = all(exists(f) for f in self.outfiles.itervalues())
expected = True
print_test_message(testname, actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
for f in self.outfiles:
print_ncfile(self.outfiles[f])
print
def test_units(self):
indata = 'm'
vdesc = VariableDesc('x', attributes={'units': indata})
actual = vdesc.units()
expected = indata
print_test_message('VariableDesc.units()',
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected,
'Default VariableDesc.units() not {}'.format(indata))
def test_parse_int_mul_int(self):
indata = '2*1'
actual = parsing.parse_definition(indata)
expected = 2
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected,
'Multiplication operator parsing failed')
def test_init_dimensions_type_error(self):
invalid_input = [1, 'x', -3.4]
for indata in invalid_input:
testname = 'PhysArray([1,2,3], name="X", dimensions={!r})'.format(
indata)
expected = TypeError
print_test_message(testname, units=indata, expected=expected)
self.assertRaises(expected,
PhysArray, [1, 2, 3],
dimensions=indata,
name='X')
def test_parse_float_sub_float(self):
indata = '2.4-1e7'
actual = parsing.parse_definition(indata)
expected = 2.4 - 1e7
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected,
'Subtraction operator parsing failed')
def test_positive_valid_str(self):
nlist = range(3)
valid_indata = ['up', 'Up', 'UP', 'down', 'Down', 'DOWN', 'doWN']
for indata in valid_indata:
testname = 'PhysArray({}, positive={!r}).positive'.format(
nlist, indata)
X = PhysArray(nlist, positive=indata, name='X')
actual = X.positive
expected = indata.lower()
print_test_message(testname, actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
def test_pst_func_args(self):
indata = ['x', [1, -3.2], {}]
pst = parsing.FuncType(*indata)
actual = pst.args
expected = indata[1]
testname = 'FuncType.__init__({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected, 'Args do not match')
def test_autoparse_time_variable_hidden(self):
indata = (VariableDesc('a'), VariableDesc('b'), VariableDesc('_t'))
fdesc = FileDesc('test.nc', variables=indata, autoparse_time_variable='_t')
actual = fdesc.variables
expected = OrderedDict((d.name, d) for d in indata)
print_test_message('FileDesc.variables', input=indata, actual=actual, expected=expected)
self.assertEqual(actual, expected, 'FileDesc.variables failed')
actual = fdesc.dimensions
expected = OrderedDict()
print_test_message('FileDesc.dimensions', input=indata, actual=actual, expected=expected)
self.assertEqual(actual, expected, 'FileDesc.dimensions failed')
def test_parse_integrated_4(self):
indata = '2-3/4*2+1'
actual = parsing.parse_definition(indata)
expected = 3
testname = 'parse_definition({0!r})'.format(indata)
print_test_message(testname,
indata=indata,
actual=actual,
expected=expected)
self.assertEqual(actual, expected,
'Integrated #4 operator parsing failed')
def test_op_neg_int(self):
key = '-'
indata = 3
testname = '({}{})'.format(key, indata)
funcref = functions.find(key, 1)
func = funcref(indata)
actual = func[:]
expected = op.neg(indata)
print_test_message(testname, input=indata,
actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
def test_reset(self):
expected = DimensionDesc('x', 1)
actual = DimensionDesc('y', 2)
actual.set(expected)
print_test_message('DimensionDesc.set()',
actual=str(actual),
expected=str(expected))
self.assertEqual(actual.name, 'y',
'DimensionDesc name not correct after set')
self.assertEqual(actual.size, expected.size,
'DimensionDesc size not correct after set')
def test_func_sqrt_float(self):
key = 'sqrt'
indata = 4.0
testname = '{}({})'.format(key, indata)
func = functions.find(key)
fobj = func(indata)
actual = fobj[:]
expected = np.sqrt(indata)
print_test_message(testname, input=indata,
actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
def test_equals_same_unset(self):
ddesc1 = DimensionDesc('x')
ddesc2 = DimensionDesc('x')
actual = ddesc1
expected = ddesc2
print_test_message('DimensionDesc(1) == DimensionDesc(2)',
actual=str(actual),
expected=str(expected))
self.assertEqual(
actual, expected,
'Unset DimensionsDesc not equal to unset DimensionDesc')
def test_func_limit(self):
key = 'limit'
indata = PhysArray([2.5, 7.3, 8.2, 1.4], name='x', units='m', dimensions=('t',))
below_val = 3.0
above_val = 7.5
testname = '{}({}, above={}, below={})'.format(key, indata, above_val, below_val)
func = functions.find(key)
actual = func(indata, above=above_val, below=below_val)[:]
expected = PhysArray([3.0, 7.3, 7.5, 3.0], name=testname, units='m', dimensions=('t',))
print_test_message(testname, indata=indata, actual=actual, expected=expected)
self.assertPhysArraysEqual(actual, expected, '{} failed'.format(testname))
def test_equals_diff_dims(self):
vdims1 = tuple(DimensionDesc(d) for d in ('a', 'b'))
vdims2 = tuple(DimensionDesc(d) for d in ('a', 'b', 'c'))
actual = VariableDesc('x', dimensions=vdims1)
expected = VariableDesc('x', dimensions=vdims2)
print_test_message('VariableDesc(dims1) != VariableDesc(dims2)',
actual=str(actual),
expected=str(expected))
self.assertNotEqual(
actual, expected,
'Differently dimensioned VariableDesc objects equal')
def test_func_mean_sumlike(self):
key = 'mean'
indata = PhysArray([1.0, 2.0, 3.0, 4.0, 5.0],
name='x', units='m', dimensions=('t',))
testname = '{}({}).sumlike_dimensions'.format(key, indata)
func = functions.find(key)
fobj = func(indata, 't')
fobj[None]
actual = fobj.sumlike_dimensions
expected = set(['t'])
print_test_message(testname, actual=actual, expected=expected)
self.assertEqual(actual, expected, '{} failed'.format(testname))
