mirror of
https://github.com/google/earthengine-api.git
synced 2025-12-08 19:26:12 +00:00
1155 lines
33 KiB
Python
1155 lines
33 KiB
Python
#!/usr/bin/env python3
|
|
"""Test for the ee.number module."""
|
|
|
|
import json
|
|
from typing import Any, Dict
|
|
import unittest
|
|
|
|
import unittest
|
|
import ee
|
|
from ee import apitestcase
|
|
|
|
|
|
def make_expression_graph(
|
|
function_invocation_value: Dict[str, Any],
|
|
) -> Dict[str, Any]:
|
|
return {
|
|
'result': '0',
|
|
'values': {'0': {'functionInvocationValue': function_invocation_value}},
|
|
}
|
|
|
|
|
|
class NumberTest(apitestcase.ApiTestCase):
|
|
|
|
def testNumber(self):
|
|
"""Verifies basic behavior of ee.Number."""
|
|
num = ee.Number(1)
|
|
self.assertEqual(1, num.encode())
|
|
|
|
computed = ee.Number(1).add(2)
|
|
self.assertIsInstance(computed, ee.Number)
|
|
self.assertEqual(ee.ApiFunction.lookup('Number.add'), computed.func)
|
|
self.assertEqual({
|
|
'left': ee.Number(1),
|
|
'right': ee.Number(2)
|
|
}, computed.args)
|
|
|
|
def testInternals(self):
|
|
"""Test eq(), ne() and hash()."""
|
|
a = ee.Number(1)
|
|
b = ee.Number(2.1)
|
|
c = ee.Number(1)
|
|
|
|
self.assertEqual(a, a)
|
|
self.assertNotEqual(a, b)
|
|
self.assertEqual(a, c)
|
|
self.assertNotEqual(b, c)
|
|
self.assertNotEqual(hash(a), hash(b))
|
|
|
|
def test_abs(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.abs',
|
|
})
|
|
expression = ee.Number(1).abs()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_acos(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.acos',
|
|
})
|
|
expression = ee.Number(1).acos()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_add(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.add',
|
|
})
|
|
expression = ee.Number(1).add(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).add(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
# `and` not possible with the python parser, so it is exposed as `And`.
|
|
def test_and(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.and',
|
|
})
|
|
expression = ee.Number(1).And(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).And(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_asin(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.asin',
|
|
})
|
|
expression = ee.Number(1).asin()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_atan(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.atan',
|
|
})
|
|
expression = ee.Number(1).atan()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_atan2(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.atan2',
|
|
})
|
|
expression = ee.Number(1).atan2(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).atan2(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_bitCount(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.bitCount',
|
|
})
|
|
expression = ee.Number(1).bitCount()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_bitwiseAnd(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.bitwiseAnd',
|
|
})
|
|
expression = ee.Number(1).bitwiseAnd(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).bitwiseAnd(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_bitwiseNot(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.bitwiseNot',
|
|
})
|
|
expression = ee.Number(1).bitwiseNot()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_bitwiseOr(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.bitwiseOr',
|
|
})
|
|
expression = ee.Number(1).bitwiseOr(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).bitwiseOr(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_bitwiseXor(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.bitwiseXor',
|
|
})
|
|
expression = ee.Number(1).bitwiseXor(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).bitwiseXor(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_byte(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.byte',
|
|
})
|
|
expression = ee.Number(1).byte()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_cbrt(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.cbrt',
|
|
})
|
|
expression = ee.Number(1).cbrt()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_ceil(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.ceil',
|
|
})
|
|
expression = ee.Number(1).ceil()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_clamp(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'number': {'constantValue': 1},
|
|
'min': {'constantValue': 2},
|
|
'max': {'constantValue': 3},
|
|
},
|
|
'functionName': 'Number.clamp',
|
|
})
|
|
expression = ee.Number(1).clamp(2, 3)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).clamp(min=2, max=3)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_cos(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.cos',
|
|
})
|
|
expression = ee.Number(1).cos()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_cosh(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.cosh',
|
|
})
|
|
expression = ee.Number(1).cosh()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_digamma(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.digamma',
|
|
})
|
|
expression = ee.Number(1).digamma()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_divide(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.divide',
|
|
})
|
|
expression = ee.Number(1).divide(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).divide(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_double(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.double',
|
|
})
|
|
expression = ee.Number(1).double()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_eq(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.eq',
|
|
})
|
|
expression = ee.Number(1).eq(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).eq(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_erf(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.erf',
|
|
})
|
|
expression = ee.Number(1).erf()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_erfInv(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.erfInv',
|
|
})
|
|
expression = ee.Number(1).erfInv()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_erfc(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.erfc',
|
|
})
|
|
expression = ee.Number(1).erfc()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_erfcInv(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.erfcInv',
|
|
})
|
|
expression = ee.Number(1).erfcInv()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_exp(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.exp',
|
|
})
|
|
expression = ee.Number(1).exp()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_first(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.first',
|
|
})
|
|
expression = ee.Number(1).first(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).first(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_firstNonZero(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.firstNonZero',
|
|
})
|
|
expression = ee.Number(1).firstNonZero(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).firstNonZero(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_float(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.float',
|
|
})
|
|
expression = ee.Number(1).float()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_floor(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.floor',
|
|
})
|
|
expression = ee.Number(1).floor()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_format(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'number': {'constantValue': 1},
|
|
'pattern': {'constantValue': 'a'},
|
|
},
|
|
'functionName': 'Number.format',
|
|
})
|
|
expression = ee.Number(1).format('a')
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).format(pattern='a')
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_gamma(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.gamma',
|
|
})
|
|
expression = ee.Number(1).gamma()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_gammainc(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.gammainc',
|
|
})
|
|
expression = ee.Number(1).gammainc(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).gammainc(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_gt(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.gt',
|
|
})
|
|
expression = ee.Number(1).gt(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).gt(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_gte(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.gte',
|
|
})
|
|
expression = ee.Number(1).gte(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).gte(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_hypot(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.hypot',
|
|
})
|
|
expression = ee.Number(1).hypot(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).hypot(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_int(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.int',
|
|
})
|
|
expression = ee.Number(1).int()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_int16(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.int16',
|
|
})
|
|
expression = ee.Number(1).int16()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_int32(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.int32',
|
|
})
|
|
expression = ee.Number(1).int32()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_int64(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.int64',
|
|
})
|
|
expression = ee.Number(1).int64()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_int8(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.int8',
|
|
})
|
|
expression = ee.Number(1).int8()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_lanczos(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.lanczos',
|
|
})
|
|
expression = ee.Number(1).lanczos()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_leftShift(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.leftShift',
|
|
})
|
|
expression = ee.Number(1).leftShift(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).leftShift(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_log(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.log',
|
|
})
|
|
expression = ee.Number(1).log()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_log10(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.log10',
|
|
})
|
|
expression = ee.Number(1).log10()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_long(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.long',
|
|
})
|
|
expression = ee.Number(1).long()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_lt(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.lt',
|
|
})
|
|
expression = ee.Number(1).lt(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).lt(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_lte(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.lte',
|
|
})
|
|
expression = ee.Number(1).lte(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).lte(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_max(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.max',
|
|
})
|
|
expression = ee.Number(1).max(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).max(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_min(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.min',
|
|
})
|
|
expression = ee.Number(1).min(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).min(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_mod(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.mod',
|
|
})
|
|
expression = ee.Number(1).mod(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).mod(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_multiply(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.multiply',
|
|
})
|
|
expression = ee.Number(1).multiply(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).multiply(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_neq(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.neq',
|
|
})
|
|
expression = ee.Number(1).neq(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).neq(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_not(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.not',
|
|
})
|
|
expression = ee.Number(1).Not()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_or(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.or',
|
|
})
|
|
expression = ee.Number(1).Or(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).Or(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
# TODO: test_parse.
|
|
|
|
def test_pow(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.pow',
|
|
})
|
|
expression = ee.Number(1).pow(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).pow(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_rightShift(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.rightShift',
|
|
})
|
|
expression = ee.Number(1).rightShift(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).rightShift(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_round(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.round',
|
|
})
|
|
expression = ee.Number(1).round()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_short(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.short',
|
|
})
|
|
expression = ee.Number(1).short()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_signum(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.signum',
|
|
})
|
|
expression = ee.Number(1).signum()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_sin(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.sin',
|
|
})
|
|
expression = ee.Number(1).sin()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_sinh(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.sinh',
|
|
})
|
|
expression = ee.Number(1).sinh()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_sqrt(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.sqrt',
|
|
})
|
|
expression = ee.Number(1).sqrt()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_subtract(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'left': {'constantValue': 1},
|
|
'right': {'constantValue': 2},
|
|
},
|
|
'functionName': 'Number.subtract',
|
|
})
|
|
expression = ee.Number(1).subtract(2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).subtract(right=2)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_tan(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.tan',
|
|
})
|
|
expression = ee.Number(1).tan()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_tanh(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.tanh',
|
|
})
|
|
expression = ee.Number(1).tanh()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toByte(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toByte',
|
|
})
|
|
expression = ee.Number(1).toByte()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toDouble(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toDouble',
|
|
})
|
|
expression = ee.Number(1).toDouble()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toFloat(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toFloat',
|
|
})
|
|
expression = ee.Number(1).toFloat()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toInt(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toInt',
|
|
})
|
|
expression = ee.Number(1).toInt()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toInt16(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toInt16',
|
|
})
|
|
expression = ee.Number(1).toInt16()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toInt32(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toInt32',
|
|
})
|
|
expression = ee.Number(1).toInt32()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toInt64(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toInt64',
|
|
})
|
|
expression = ee.Number(1).toInt64()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toInt8(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toInt8',
|
|
})
|
|
expression = ee.Number(1).toInt8()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toLong(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toLong',
|
|
})
|
|
expression = ee.Number(1).toLong()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toShort(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toShort',
|
|
})
|
|
expression = ee.Number(1).toShort()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toUint16(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toUint16',
|
|
})
|
|
expression = ee.Number(1).toUint16()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toUint32(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toUint32',
|
|
})
|
|
expression = ee.Number(1).toUint32()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_toUint8(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.toUint8',
|
|
})
|
|
expression = ee.Number(1).toUint8()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_trigamma(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.trigamma',
|
|
})
|
|
expression = ee.Number(1).trigamma()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_uint16(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.uint16',
|
|
})
|
|
expression = ee.Number(1).uint16()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_uint32(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.uint32',
|
|
})
|
|
expression = ee.Number(1).uint32()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_uint8(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'input': {'constantValue': 1},
|
|
},
|
|
'functionName': 'Number.uint8',
|
|
})
|
|
expression = ee.Number(1).uint8()
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
def test_unitScale(self):
|
|
expect = make_expression_graph({
|
|
'arguments': {
|
|
'number': {'constantValue': 1},
|
|
'min': {'constantValue': 2},
|
|
'max': {'constantValue': 3},
|
|
},
|
|
'functionName': 'Number.unitScale',
|
|
})
|
|
expression = ee.Number(1).unitScale(2, 3)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
expression = ee.Number(1).unitScale(min=2, max=3)
|
|
result = json.loads(expression.serialize())
|
|
self.assertEqual(expect, result)
|
|
|
|
@unittest.mock.patch.object(ee.ComputedObject, 'encode')
|
|
def test_encode_opt_params(self, mock_encode):
|
|
number = ee.Number(ee.Dictionary({'a': 3}).get('a'))
|
|
|
|
mock_encoder = unittest.mock.Mock()
|
|
number.encode(opt_encoder=mock_encoder)
|
|
|
|
mock_encode.assert_called_once_with(mock_encoder)
|
|
|
|
@unittest.mock.patch.object(ee.ComputedObject, 'encode_cloud_value')
|
|
def test_encode_cloud_value_opt_params(self, mock_encode_cloud_value):
|
|
number = ee.Number(ee.Dictionary({'a': 3}).get('a'))
|
|
|
|
mock_encoder = unittest.mock.Mock()
|
|
number.encode_cloud_value(opt_encoder=mock_encoder)
|
|
|
|
mock_encode_cloud_value.assert_called_once_with(mock_encoder)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|