earthengine-api/python/ee/tests/image_test.py

#!/usr/bin/env python3
"""Test for the ee.image module."""

import json
from typing import Any, Dict
from unittest import mock

import unittest
import ee
from ee import _cloud_api_utils
from ee import apitestcase
from ee import ee_exception
from ee import serializer

EPSG_3857 = 'EPSG:3857'
EPSG_4326 = 'EPSG:4326'

# ee.Image('a').serialize()
IMAGE = {
    'functionInvocationValue': {
        'functionName': 'Image.load',
        'arguments': {'id': {'constantValue': 'a'}},
    }
}
IMAGE_B = {
    'functionInvocationValue': {
        'functionName': 'Image.load',
        'arguments': {'id': {'constantValue': 'b'}},
    }
}
IMAGE_C = {
    'functionInvocationValue': {
        'functionName': 'Image.load',
        'arguments': {'id': {'constantValue': 'c'}},
    }
}


def make_expression_graph(
    function_invocation_value: Dict[str, Any],
) -> Dict[str, Any]:
  return {
      'result': '0',
      'values': {'0': {'functionInvocationValue': function_invocation_value}},
  }


class ImageTest(apitestcase.ApiTestCase):

  def test_constructors(self):
    """Verifies that constructors understand valid parameters."""
    from_constant = ee.Image(1)
    self.assertEqual(
        ee.ApiFunction.lookup('Image.constant'), from_constant.func)
    self.assertEqual({'value': 1}, from_constant.args)

    array_constant = ee.Array([1, 2])
    from_array_constant = ee.Image(array_constant)
    self.assertEqual(
        ee.ApiFunction.lookup('Image.constant'), from_array_constant.func)
    self.assertEqual({'value': array_constant}, from_array_constant.args)

    from_id = ee.Image('abcd')
    self.assertEqual(ee.ApiFunction.lookup('Image.load'), from_id.func)
    self.assertEqual({'id': 'abcd'}, from_id.args)

    from_array = ee.Image([1, 2])
    self.assertEqual(ee.ApiFunction.lookup('Image.addBands'), from_array.func)
    self.assertEqual({
        'dstImg': ee.Image(1),
        'srcImg': ee.Image(2)
    }, from_array.args)

    from_computed_object = ee.Image(ee.ComputedObject(None, {'x': 'y'}))
    self.assertEqual({'x': 'y'}, from_computed_object.args)

    original = ee.Image(1)
    from_other_image = ee.Image(original)
    self.assertEqual(from_other_image, original)

    from_nothing = ee.Image()
    self.assertEqual(ee.ApiFunction.lookup('Image.mask'), from_nothing.func)
    self.assertEqual({
        'image': ee.Image(0),
        'mask': ee.Image(0)
    }, from_nothing.args)

    from_id_and_version = ee.Image('abcd', 123)
    self.assertEqual(
        ee.ApiFunction.lookup('Image.load'), from_id_and_version.func)
    self.assertEqual({'id': 'abcd', 'version': 123}, from_id_and_version.args)

    from_variable = ee.Image(ee.CustomFunction.variable(None, 'foo'))
    self.assertIsInstance(from_variable, ee.Image)
    self.assertEqual({
        'type': 'ArgumentRef',
        'value': 'foo'
    }, from_variable.encode(None))

  def test_image_signatures(self):
    """Verifies that the API functions are added to ee.Image."""
    self.assertTrue(hasattr(ee.Image(1), 'addBands'))

  def test_imperative_functions(self):
    """Verifies that imperative functions return ready values."""
    image = ee.Image(1)
    self.assertEqual({'value': 'fakeValue'}, image.getInfo())
    map_id = image.getMapId()
    self.assertEqual('fakeMapId', map_id['mapid'])
    self.assertEqual(image, map_id['image'])

  def test_get_map_id_visualization(self):
    """Verifies that imperative functions return ready values."""
    image = ee.Image(1)
    image.getMapId({'min': 0})

    self.assertEqual(
        ee.Image(1).visualize(min=0).serialize(),
        self.last_mapid_call['data']['image'].serialize())

  def test_combine(self):
    """Verifies the behavior of ee.Image.combine_()."""
    image1 = ee.Image([1, 2])
    image2 = ee.Image([3, 4])
    combined = ee.Image.combine_([image1, image2], ['a', 'b', 'c', 'd'])

    self.assertEqual(ee.ApiFunction.lookup('Image.select'), combined.func)
    self.assertEqual(ee.List(['.*']), combined.args['bandSelectors'])
    self.assertEqual(ee.List(['a', 'b', 'c', 'd']), combined.args['newNames'])
    self.assertEqual(
        ee.ApiFunction.lookup('Image.addBands'), combined.args['input'].func)
    self.assertEqual({
        'dstImg': image1,
        'srcImg': image2
    }, combined.args['input'].args)

  def test_select(self):
    """Verifies regression in the behavior of empty ee.Image.select()."""
    image = ee.Image([1, 2]).select()
    self.assertEqual(ee.ApiFunction.lookup('Image.select'), image.func)
    self.assertEqual(ee.List([]), image.args['bandSelectors'])

  def test_rename(self):
    """Verifies image.rename varargs handling."""
    image = ee.Image([1, 2]).rename('a', 'b')
    self.assertEqual(ee.ApiFunction.lookup('Image.rename'), image.func)
    self.assertEqual(ee.List(['a', 'b']), image.args['names'])

    image = ee.Image([1, 2]).rename(['a', 'b'])
    self.assertEqual(ee.ApiFunction.lookup('Image.rename'), image.func)
    self.assertEqual(ee.List(['a', 'b']), image.args['names'])

    image = ee.Image([1]).rename('a')
    self.assertEqual(ee.ApiFunction.lookup('Image.rename'), image.func)
    self.assertEqual(ee.List(['a']), image.args['names'])

  def test_expression(self):
    """Verifies the behavior of ee.Image.expression()."""
    image = ee.Image([1, 2]).expression('a', {'b': 'c'})
    expression_func = image.func

    # The call is buried in a one-time override of .encode so we have to call
    # it rather than comparing the object structure.
    def dummy_encoder(x):
      if isinstance(x, ee.encodable.Encodable):
        return x.encode(dummy_encoder)
      elif isinstance(x, ee.encodable.EncodableFunction):
        return x.encode_invocation(dummy_encoder)
      else:
        return x

    self.assertEqual({
        'type': 'Invocation',
        'functionName': 'Image.parseExpression',
        'arguments': {
            'expression': 'a',
            'argName': 'DEFAULT_EXPRESSION_IMAGE',
            'vars': ['DEFAULT_EXPRESSION_IMAGE', 'b']
        }
    }, dummy_encoder(expression_func))

  def test_expression_in_cloud_api(self):
    """Verifies the behavior of ee.Image.expression() in the Cloud API."""
    image = ee.Image(1).expression('a', {'b': 'c'})

    self.assertEqual({
        'result': '0',
        'values': {
            '0': {
                'functionInvocationValue': {
                    'arguments': {
                        'b': {
                            'functionInvocationValue': {
                                'arguments': {
                                    'id': {
                                        'constantValue': 'c'
                                    }
                                },
                                'functionName': 'Image.load'
                            }
                        },
                        'DEFAULT_EXPRESSION_IMAGE': {
                            'functionInvocationValue': {
                                'arguments': {
                                    'value': {
                                        'constantValue': 1
                                    }
                                },
                                'functionName': 'Image.constant'
                            }
                        }
                    },
                    'functionReference': '1'
                }
            },
            '1': {
                'functionInvocationValue': {
                    'arguments': {
                        'expression': {
                            'constantValue': 'a'
                        },
                        'argName': {
                            'valueReference': '2'
                        },
                        'vars': {
                            'arrayValue': {
                                'values': [{
                                    'valueReference': '2'
                                }, {
                                    'constantValue': 'b'
                                }]
                            }
                        }
                    },
                    'functionName': 'Image.parseExpression'
                }
            },
            '2': {
                'constantValue': 'DEFAULT_EXPRESSION_IMAGE'
            }
        }
    }, serializer.encode(image, for_cloud_api=True))

  def test_download(self):
    """Verifies Download ID and URL generation."""
    ee.Image(1).getDownloadURL()

    self.assertEqual('/download', self.last_download_call['url'])
    self.assertEqual(
        ee.Image(1).serialize(),
        self.last_download_call['data']['image'].serialize())


class CloudThumbnailAndExportImageTest(apitestcase.ApiTestCase):

  def setUp(self):  # pylint: disable=g-missing-super-call
    self.InitializeApi(should_mock=False)
    self.cloud_api_resource = mock.MagicMock()
    self.cloud_api_resource.projects().thumbnails().create(
    ).execute.return_value = {
        'name': 'thumbName'
    }

    self.base_image = ee.Image(1)
    self.geo_json = {
        'type':
            'Polygon',
        'coordinates': [[
            [-112.587890625, 44.94924926661151],
            [-114.873046875, 39.48708498168749],
            [-103.623046875, 41.82045509614031],
        ]],
    }
    self.expected_geometry = ee.Geometry(self.geo_json, geodesic=False)

  def assertImageEqual(self, expected, actual):
    self.assertDictEqual(
        serializer.encode(expected),
        serializer.encode(actual))

  @unittest.skip('Does not work on github')
  def test_thumb_with_dimensions_region_crs(self):
    """Verifies Thumbnail ID and URL generation in the Cloud API."""

    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      url = self.base_image.getThumbURL({
          'dimensions': [13, 42],
          'region': self.geo_json,
          'crs': EPSG_4326,
      })

      self.assertEqual('None/%s/thumbName:getPixels' % _cloud_api_utils.VERSION,
                       url)
      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args
      self.assertEqual(
          kwargs['body']['expression'],
          serializer.encode(
              self.base_image.setDefaultProjection(
                  crs=EPSG_4326, crsTransform=[1, 0, 0, 0, -1, 0]
              ).clipToBoundsAndScale(
                  geometry=ee.Geometry(self.geo_json, geodesic=False),
                  width=13,
                  height=42,
              )
          ),
      )
      self.assertEqual(kwargs['parent'], 'projects/earthengine-legacy')

  @unittest.skip('Does not work on github')
  def test_thumb_with_dimensions_region_json(self):
    # Try it with the region as a GeoJSON string.
    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      self.base_image.getThumbURL({
          'dimensions': [13, 42],
          'region': json.dumps(self.geo_json),
      })

      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args
      self.assertEqual(
          kwargs['body']['expression'],
          serializer.encode(
              self.base_image.clipToBoundsAndScale(
                  geometry=self.expected_geometry, width=13, height=42)))
      self.assertEqual(kwargs['parent'], 'projects/earthengine-legacy')

  @unittest.skip('Does not work on github')
  def test_thumb_with_dimensions_list_coords(self):
    # Try it with the region as a list of coordinates.
    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      self.base_image.getThumbURL({
          'dimensions': [13, 42],
          'region': [[-180, -90], [-180, 90], [180, 90]],
      })

      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args
      expected_geometry = ee.Geometry.Polygon(
          [[-180, -90], [-180, 90], [180, 90]], proj=None, geodesic=False)
      self.assertEqual(
          kwargs['body']['expression'],
          serializer.encode(
              self.base_image.clipToBoundsAndScale(
                  geometry=expected_geometry, width=13, height=42)))
      self.assertEqual(kwargs['parent'], 'projects/earthengine-legacy')

  @unittest.skip('Does not work on github')
  def test_thumb_with_dimensions_list_min_max(self):
    # Try it with the region as a list of coordinates.
    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      self.base_image.getThumbURL({
          'dimensions': [13, 42],
          'region': [-180, -90, 180, 90],
      })

      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args
      expected_geometry = ee.Geometry.Rectangle(
          [-180, -90, 180, 90], proj=None, geodesic=False)
      self.assertEqual(
          kwargs['body']['expression'],
          serializer.encode(
              self.base_image.clipToBoundsAndScale(
                  geometry=expected_geometry, width=13, height=42)))
      self.assertEqual(kwargs['parent'], 'projects/earthengine-legacy')

  @unittest.skip('Does not work on github')
  def test_thumb_with_visualization_params(self):
    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      self.base_image.getThumbURL({
          'dimensions': [13, 42],
          'region': self.geo_json,
          'min': 0
      })
      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args

      self.assertEqual(
          kwargs['body']['expression'],
          serializer.encode(
              self.base_image.clipToBoundsAndScale(
                  geometry=self.expected_geometry, width=13,
                  height=42).visualize(min=0)))

  def test_build_download_id_image_builds_image_per_band(self):
    test_image = ee.Image('foo')

    # Format is file per band and bands specified: build image out of individual
    # band images.
    params = {
        'format':
            'ZIPPED_GEO_TIFF_PER_BAND',
        'bands': [{
            'id': 'B1',
            'dimensions': 123,
        }, {
            'id': 'B2',
            'dimensions': 456,
        }, {
            'id': 'B3',
            'dimensions': 789,
        }],
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(2, image_str.count('addBands'))
    self.assertEqual(3, image_str.count('maxDimension'))
    self.assertEqual(1, image_str.count('123'))
    self.assertEqual(1, image_str.count('456'))
    self.assertEqual(1, image_str.count('789'))

    # Override the parameters supplied in the top level with the bands
    # parameters
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'bands': [{
            'id': 'B1',
            'dimensions': 123,
        }, {
            'id': 'B2',
            'dimensions': 456,
        }, {
            'id': 'B3',
        }],
        'dimensions': 999,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(2, image_str.count('addBands'))
    self.assertEqual(3, image_str.count('maxDimension'))
    self.assertEqual(1, image_str.count('123'))
    self.assertEqual(1, image_str.count('456'))
    self.assertEqual(0, image_str.count('789'))
    self.assertEqual(1, image_str.count('999'))

  def test_build_download_id_image_transforms_given_image(self):
    test_image = ee.Image('foo')

    # Format is file per band and bands specified: build image out of individual
    # band images.
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'bands': [],
        'dimensions': 123,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(0, image_str.count('addBands'))
    self.assertEqual(1, image_str.count('maxDimension'))
    self.assertEqual(1, image_str.count('123'))

    # Format is file per band and no bands specified: apply transforms directly
    # to image.
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'dimensions': 123,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(0, image_str.count('addBands'))
    self.assertEqual(1, image_str.count('maxDimension'))
    self.assertEqual(1, image_str.count('123'))

    # Format is a single tiff: apply transforms directly to image and ignore
    # band transformation properties.
    params = {
        'format': 'ZIPPED_GEO_TIFF',
        'bands': [{
            'id': 'B1',
            'dimensions': 123,
        }, {
            'id': 'B2',
            'dimensions': 456,
        }, {
            'id': 'B3',
            'dimensions': 789,
        }],
        'dimensions': 999,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(0, image_str.count('addBands'))
    self.assertEqual(1, image_str.count('maxDimension'))
    self.assertEqual(0, image_str.count('123'))
    self.assertEqual(0, image_str.count('456'))
    self.assertEqual(0, image_str.count('789'))
    self.assertEqual(1, image_str.count('999'))

  def test_build_download_id_image_handles_invalid_parameters(self):
    # No band ID in band dictionary.
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'bands': [{
            'id': 'B1',
            'dimensions': 123,
        }, {
            'id': 'B2',
            'dimensions': 456,
        }, {
            'dimensions': 789,
        }],
        'dimensions': 999,
    }
    with self.assertRaisesRegex(
        ee_exception.EEException, 'Each band dictionary must have an id.'
    ):
      ee.Image('foo')._build_download_id_image(params)

  def test_build_download_id_image_handles_dimensions_and_scale(self):
    test_image = ee.Image('foo')
    dimensions = 123
    scale = 456

    # File per band: ignores scale parameter if dimensions specified.
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'dimensions': dimensions,
        'scale': scale,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(1, image_str.count(str(dimensions)))
    self.assertEqual(0, image_str.count(str(scale)))

    # File per band: ignores scale parameter if dimensions specified in band.
    params = {
        'format': 'ZIPPED_GEO_TIFF_PER_BAND',
        'bands': [{
            'id': 'B1',
            'dimensions': dimensions
        }],
        'scale': scale,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(1, image_str.count(str(dimensions)))
    self.assertEqual(0, image_str.count(str(scale)))

    # Single tiff: ignores scale parameter if dimensions specified.
    params = {
        'format': 'ZIPPED_GEO_TIFF',
        'dimensions': dimensions,
        'scale': scale,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(1, image_str.count(str(dimensions)))
    self.assertEqual(0, image_str.count(str(scale)))

    # Single tiff: ignores all parameters in bands.
    params = {
        'format': 'ZIPPED_GEO_TIFF',
        'bands': [{
            'id': 'B1',
            'dimensions': dimensions
        }],
        'scale': scale,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(0, image_str.count(str(dimensions)))
    self.assertEqual(1, image_str.count(str(scale)))

    # Single tiff: ignores all parameters in bands.
    params = {
        'format': 'ZIPPED_GEO_TIFF',
        'bands': [{
            'id': 'B1',
            'scale': scale
        }],
        'dimensions': dimensions,
    }
    image_str = test_image._build_download_id_image(params).serialize()
    self.assertEqual(1, image_str.count(str(dimensions)))
    self.assertEqual(0, image_str.count(str(scale)))

  @unittest.skip('Does not work on github')
  def test_download_url(self):
    """Verifies that the getDownloadURL request is constructed correctly."""

    with apitestcase.UsingCloudApi(cloud_api_resource=self.cloud_api_resource):
      url = self.base_image.getDownloadURL()
      _, kwargs = self.cloud_api_resource.projects().thumbnails(
      ).create.call_args
      self.assertEqual(
          serializer.encode(self.base_image, for_cloud_api=True),
          kwargs['body']['expression'])
      self.assertEqual('ZIPPED_GEO_TIFF_PER_BAND', kwargs['body']['fileFormat'])
      self.assertEqual('projects/earthengine-legacy', kwargs['parent'])
      self.assertEqual('None/%s/thumbName:getPixels' % _cloud_api_utils.VERSION,
                       url)

  def test_prepare_for_export_simple(self):
    """Verifies proper handling of export-related parameters."""

    with apitestcase.UsingCloudApi():
      image, params = self.base_image.prepare_for_export({'something': 'else'})
      self.assertImageEqual(self.base_image, image)
      self.assertEqual({'something': 'else'}, params)

  def test_prepare_for_export_with_crs_and_transform(self):
    with apitestcase.UsingCloudApi():
      image, params = self.base_image.prepare_for_export({
          'crs': 'ABCD',
          'crs_transform': '1,2,3,4,5,6'
      })
      self.assertImageEqual(
          self.base_image.reproject(
              crs='ABCD', crsTransform=[1, 2, 3, 4, 5, 6]), image)
      self.assertEqual({}, params)

  def test_prepare_for_export_invalid_crs_and_transform(self):
    with apitestcase.UsingCloudApi():
      with self.assertRaises(ee_exception.EEException):
        self.base_image.prepare_for_export({'crs_transform': '1,2,3,4,5,6'})
      with self.assertRaises(ValueError):
        self.base_image.prepare_for_export({
            'crs': 'ABCD',
            'crs_transform': 'x'
        })

  def test_prepare_for_export_with_polygon(self):
    with apitestcase.UsingCloudApi():
      polygon = ee.Geometry.Polygon(9, 8, 7, 6, 3, 2)
      image, params = self.base_image.prepare_for_export({
          'dimensions': '3x2',
          'region': polygon
      })
      expected = self.base_image.clipToBoundsAndScale(
          width=3, height=2, geometry=polygon)
      self.assertImageEqual(expected, image)
      self.assertEqual({}, params)

  def test_prepare_for_export_with_scale_and_region(self):
    with apitestcase.UsingCloudApi():
      polygon = ee.Geometry.Polygon(9, 8, 7, 6, 3, 2)
      image, params = self.base_image.prepare_for_export({
          'scale': 8,
          'region': polygon.toGeoJSONString(),
          'something': 'else'
      })
      expected_polygon = ee.Geometry(polygon.toGeoJSON(), geodesic=False)
      self.assertImageEqual(
          self.base_image.clipToBoundsAndScale(
              scale=8, geometry=expected_polygon), image)
      self.assertEqual({'something': 'else'}, params)

  def test_prepare_for_export_with_region_dimensions_crs_and_transform(self):
    with apitestcase.UsingCloudApi():
      polygon = ee.Geometry.Polygon(9, 8, 7, 6, 3, 2)
      image, params = self.base_image.prepare_for_export({
          'crs': 'ABCD',
          'crs_transform': '[1,2,3,4,5,6]',
          'dimensions': [3, 2],
          'region': polygon.toGeoJSONString(),
          'something': 'else'
      })
      expected_polygon = ee.Geometry(polygon.toGeoJSON(), geodesic=False)
      projected = self.base_image.reproject(
          crs='ABCD', crsTransform=[1, 2, 3, 4, 5, 6])

      self.assertImageEqual(
          projected.clipToBoundsAndScale(
              width=3, height=2, geometry=expected_polygon), image)
      self.assertEqual({'something': 'else'}, params)

  def test_prepare_for_export_with_dimensions_crs_and_transform(self):
    with apitestcase.UsingCloudApi():
      # Special case of crs+transform+two dimensions
      image, params = self.base_image.prepare_for_export({
          'crs': 'ABCD',
          'crs_transform': [1, 2, 3, 4, 5, 6],
          'dimensions': [3, 2],
          'something': 'else'
      })
      reprojected_image = self.base_image.reproject(
          crs='ABCD', crsTransform=[1, 2, 3, 4, 5, 6])

      self.assertEqual(
          reprojected_image.clipToBoundsAndScale(
              geometry=ee.Geometry.Rectangle(
                  coords=[0, 0, 3, 2],
                  proj=reprojected_image.projection(),
                  geodesic=False,
                  evenOdd=True)), image)
      self.assertEqual({'something': 'else'}, params)

  def test_prepare_for_export_with_only_region(self):
    with apitestcase.UsingCloudApi():
      polygon = ee.Geometry.Polygon(9, 8, 7, 6, 3, 2)
      image, params = self.base_image.prepare_for_export({
          'region': polygon,
          'something': 'else'
      })

      self.assertEqual(
          self.base_image.clip(polygon), image)
      self.assertEqual({'something': 'else'}, params)

  def test_prepare_for_export_with_crs_no_transform(self):
    with apitestcase.UsingCloudApi():
      # CRS with no crs_transform causes a "soft" reprojection. Make sure that
      # the (crs, crsTransform, dimensions) special case doesn't trigger.
      image, params = self.base_image.prepare_for_export({
          'crs': 'ABCD',
          'dimensions': [3, 2],
          'something': 'else'
      })
      projected = self.base_image.setDefaultProjection(
          crs='ABCD', crsTransform=[1, 0, 0, 0, -1, 0])

      self.assertEqual(projected.clipToBoundsAndScale(width=3, height=2), image)
      self.assertEqual({'something': 'else'}, params)

  def test_morphological_operators(self):
    """Verifies the focal operators are installed with aliases."""
    ee.Image(0).focal_min().focalMin()

  def test_select_opt_params(self):
    result = (
        ee.Image(1)
        .select(opt_selectors=['selector_a', 4], opt_names=['name_a', 'name_b'])
        .serialize()
    )
    self.assertIn(
        '"bandSelectors": {"constantValue": ["selector_a", 4]}', result
    )
    self.assertIn('"newNames": {"constantValue": ["name_a", "name_b"]}', result)

  def test_expression_opt_params(self):
    result = (
        ee.Image(1)
        .expression(expression='abc(0)', opt_map={'bcd': 'cef'})
        .serialize()
    )
    # The values are nested too deep to compare the entire node.
    self.assertIn('bcd', result)
    self.assertIn('cef', result)


class SerializeTest(apitestcase.ApiTestCase):

  def test_abs(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.abs',
    })
    expression = ee.Image('a').abs()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_acos(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.acos',
    })
    expression = ee.Image('a').acos()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_add(self):
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.add',
    })
    expression = ee.Image('a').add('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').add(image2='b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_add_bands(self):
    names = ['one', 'two']
    overwrite = True
    expect = make_expression_graph({
        'arguments': {
            'dstImg': IMAGE,
            'srcImg': IMAGE_B,
            'names': {'constantValue': names},
            'overwrite': {'constantValue': overwrite},
        },
        'functionName': 'Image.addBands',
    })
    expression = ee.Image('a').addBands('b', names, overwrite)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').addBands(
        srcImg='b', names=names, overwrite=overwrite
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_and(self):
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.and',
    })
    expression = ee.Image('a').And('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').And(image2='b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_accum(self):
    axis = 1
    reducer = ee.Reducer.sum()
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis': {'constantValue': axis},
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
        },
        'functionName': 'Image.arrayAccum',
    })
    expression = ee.Image('a').arrayAccum(axis, reducer)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayAccum(axis=axis, reducer=reducer)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_argmax(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.arrayArgmax',
    })
    expression = ee.Image('a').arrayArgmax()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_cat(self):
    axis = 1
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
            'axis': {'constantValue': axis},
        },
        'functionName': 'Image.arrayCat',
    })
    expression = ee.Image('a').arrayCat('b', axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayCat(image2='b', axis=axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_dimensions(self):
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
        },
        'functionName': 'Image.arrayDimensions',
    })
    expression = ee.Image('a').arrayDimensions()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_dot_product(self):
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.arrayDotProduct',
    })
    expression = ee.Image('a').arrayDotProduct('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayDotProduct(image2='b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_flatten(self):
    coordinate_labels = ['b', 'c']
    separator = 'a separator'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'coordinateLabels': {'constantValue': coordinate_labels},
            'separator': {'constantValue': separator},
        },
        'functionName': 'Image.arrayFlatten',
    })
    expression = ee.Image('a').arrayFlatten(coordinate_labels, separator)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayFlatten(
        coordinateLabels=coordinate_labels, separator=separator
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_get(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'position': IMAGE_B,
        },
        'functionName': 'Image.arrayGet',
    })
    expression = ee.Image('a').arrayGet('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayGet(position='b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_length(self):
    axis = 1
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis': {'constantValue': axis},
        },
        'functionName': 'Image.arrayLength',
    })
    expression = ee.Image('a').arrayLength(axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayLength(axis=axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_lengths(self):
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
        },
        'functionName': 'Image.arrayLengths',
    })
    expression = ee.Image('a').arrayLengths()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_mask(self):
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'mask': IMAGE_B,
        },
        'functionName': 'Image.arrayMask',
    })
    expression = ee.Image('a').arrayMask('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayMask(mask='b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_pad(self):
    lengths = [1, 2]
    pad = 3
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'lengths': {'constantValue': lengths},
            'pad': {'constantValue': pad},
        },
        'functionName': 'Image.arrayPad',
    })
    expression = ee.Image('a').arrayPad(lengths, pad)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayPad(lengths=lengths, pad=pad)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_project(self):
    axes = [1, 2]
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axes': {'constantValue': axes},
        },
        'functionName': 'Image.arrayProject',
    })
    expression = ee.Image('a').arrayProject(axes)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayProject(axes=axes)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_reduce(self):
    reducer = ee.Reducer.sum()
    axes = [1, 2]
    field_axes = 3
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'axes': {'constantValue': axes},
            'fieldAxis': {'constantValue': field_axes},
        },
        'functionName': 'Image.arrayReduce',
    })
    expression = ee.Image('a').arrayReduce(reducer, axes, field_axes)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayReduce(
        reducer=reducer, axes=axes, fieldAxis=field_axes
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_repeat(self):
    axis = 1
    copies = 'b'
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis': {'constantValue': axis},
            'copies': IMAGE_B,
        },
        'functionName': 'Image.arrayRepeat',
    })
    expression = ee.Image('a').arrayRepeat(axis, copies)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayRepeat(axis=axis, copies=copies)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_reshape(self):
    lengths = 'b'
    dimensions = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'lengths': IMAGE_B,
            'dimensions': {'constantValue': dimensions},
        },
        'functionName': 'Image.arrayReshape',
    })
    expression = ee.Image('a').arrayReshape(lengths, dimensions)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayReshape(
        lengths=lengths, dimensions=dimensions
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_slice(self):
    axis = 1
    start = 'b'
    end = 'c'
    step = 2
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis': {'constantValue': axis},
            'start': IMAGE_B,
            'end': IMAGE_C,
            'step': {'constantValue': step},
        },
        'functionName': 'Image.arraySlice',
    })
    expression = ee.Image('a').arraySlice(axis, start, end, step)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arraySlice(
        axis=axis, start=start, end=end, step=step
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_sort(self):
    keys = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'keys': IMAGE_B,
        },
        'functionName': 'Image.arraySort',
    })
    expression = ee.Image('a').arraySort(keys)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arraySort(keys)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_array_transpose(self):
    axis1 = 1
    axis2 = 2
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis1': {'constantValue': axis1},
            'axis2': {'constantValue': axis2},
        },
        'functionName': 'Image.arrayTranspose',
    })
    expression = ee.Image('a').arrayTranspose(axis1, axis2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').arrayTranspose(axis1=axis1, axis2=axis2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_asin(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.asin',
    })
    expression = ee.Image('a').asin()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_atan(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.atan',
    })
    expression = ee.Image('a').atan()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_atan2(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.atan2',
    })
    expression = ee.Image('a').atan2(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').atan2(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_band_names(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.bandNames',
    })
    expression = ee.Image('a').bandNames()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_band_types(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.bandTypes',
    })
    expression = ee.Image('a').bandTypes()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bit_count(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.bitCount',
    })
    expression = ee.Image('a').bitCount()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bits_to_array_image(self):
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
        },
        'functionName': 'Image.bitsToArrayImage',
    })
    expression = ee.Image('a').bitsToArrayImage()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bitwise_and(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.bitwiseAnd',
    })
    expression = ee.Image('a').bitwiseAnd(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').bitwiseAnd(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bitwise_not(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.bitwiseNot',
    })
    expression = ee.Image('a').bitwiseNot()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bitwise_or(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.bitwiseOr',
    })
    expression = ee.Image('a').bitwiseOr(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').bitwiseOr(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_bitwise_xor(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.bitwiseXor',
    })
    expression = ee.Image('a').bitwiseXor(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').bitwiseXor(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_blend(self):
    expect = make_expression_graph({
        'arguments': {
            'bottom': IMAGE,
            'top': IMAGE_B,
        },
        'functionName': 'Image.blend',
    })
    expression = ee.Image('a').blend('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').blend('b')
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_byte(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.byte',
    })
    expression = ee.Image('a').byte()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cast(self):
    band_types = {'a': 'int16'}
    band_order = ['b', 'c']
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'bandTypes': {'constantValue': band_types},
            'bandOrder': {'constantValue': band_order},
        },
        'functionName': 'Image.cast',
    })
    expression = ee.Image('a').cast(band_types, band_order)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').cast(bandTypes=band_types, bandOrder=band_order)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cat(self):
    images = ['a', 'b']
    expect = make_expression_graph({
        'arguments': {
            'dstImg': {
                'functionInvocationValue': {
                    'functionName': 'Image.load',
                    'arguments': {'id': {'constantValue': 'a'}},
                }
            },
            'srcImg': {
                'functionInvocationValue': {
                    'functionName': 'Image.load',
                    'arguments': {'id': {'constantValue': 'b'}},
                }
            },
        },
        # Note that this is not "cat".
        'functionName': 'Image.addBands',
    })
    expression = ee.Image.cat(images)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    # cat uses varargs, so no kwargs.

  def test_cbrt(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.cbrt',
    })
    expression = ee.Image('a').cbrt()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_ceil(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.ceil',
    })
    expression = ee.Image('a').ceil()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_change_proj(self):
    src_proj = EPSG_3857
    dst_proj = EPSG_4326
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'srcProj': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': EPSG_3857}},
                }
            },
            'dstProj': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': EPSG_4326}},
                }
            },
        },
        'functionName': 'Image.changeProj',
    })
    expression = ee.Image('a').changeProj(src_proj, dst_proj)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').changeProj(srcProj=src_proj, dstProj=dst_proj)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_clamp(self):
    low = 1
    high = 2
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'low': {'constantValue': low},
            'high': {'constantValue': high},
        },
        'functionName': 'Image.clamp',
    })
    expression = ee.Image('a').clamp(low, high)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').clamp(low=low, high=high)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_classify(self):
    classifier = ee.Classifier.decisionTree('')
    output_name = 'output name'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'classifier': {
                'functionInvocationValue': {
                    'functionName': 'Classifier.decisionTree',
                    'arguments': {'treeString': {'constantValue': ''}},
                }
            },
            'outputName': {'constantValue': output_name},
        },
        'functionName': 'Image.classify',
    })
    expression = ee.Image('a').classify(classifier, output_name)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').classify(
        classifier=classifier, outputName=output_name
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_clip(self):
    point = ee.Geometry.Point([1, 2])
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'geometry': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': [1, 2]}},
                }
            },
        },
        'functionName': 'Image.clip',
    })
    expression = ee.Image('a').clip(point)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').clip(clip_geometry=point)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_clip_to_bounds_and_scale(self):
    point = ee.Geometry.Point([1, 2])
    width = 3
    height = 4
    max_dimension = 5
    scale = 6
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'geometry': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': [1, 2]}},
                }
            },
            'width': {'constantValue': width},
            'height': {'constantValue': height},
            'maxDimension': {'constantValue': max_dimension},
            'scale': {'constantValue': scale},
        },
        'functionName': 'Image.clipToBoundsAndScale',
    })
    expression = ee.Image('a').clipToBoundsAndScale(
        point, width, height, max_dimension, scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').clipToBoundsAndScale(
        geometry=point,
        width=width,
        height=height,
        maxDimension=max_dimension,
        scale=scale,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_clip_to_collection(self):
    featurecollection = ee.FeatureCollection(ee.Feature(None))
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'collection': {
                'functionInvocationValue': {
                    'functionName': 'Collection',
                    'arguments': {
                        'features': {
                            'arrayValue': {
                                'values': [{
                                    'functionInvocationValue': {
                                        'functionName': 'Feature',
                                        'arguments': {},
                                    }
                                }]
                            }
                        }
                    },
                }
            },
        },
        'functionName': 'Image.clipToCollection',
    })
    expression = ee.Image('a').clipToCollection(featurecollection)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').clipToCollection(collection=featurecollection)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cluster(self):
    clusterer = ee.Clusterer.wekaCobweb()
    output_name = 'output name'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'clusterer': {
                'functionInvocationValue': {
                    'functionName': 'Clusterer.wekaCobweb',
                    'arguments': {},
                }
            },
            'outputName': {'constantValue': output_name},
        },
        'functionName': 'Image.cluster',
    })
    expression = ee.Image('a').cluster(clusterer, output_name)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').cluster(
        clusterer=clusterer, outputName=output_name
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_connected_components(self):
    connectedness = ee.Kernel.square(1)
    max_size = 2
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'connectedness': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'maxSize': {'constantValue': max_size},
        },
        'functionName': 'Image.connectedComponents',
    })
    expression = ee.Image('a').connectedComponents(connectedness, max_size)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').connectedComponents(
        connectedness=connectedness, maxSize=max_size
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_connected_pixel_count(self):
    max_size = 1
    eight_connected = True
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'maxSize': {'constantValue': max_size},
            'eightConnected': {'constantValue': eight_connected},
        },
        'functionName': 'Image.connectedPixelCount',
    })
    expression = ee.Image('a').connectedPixelCount(max_size, eight_connected)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').connectedPixelCount(
        maxSize=max_size, eightConnected=eight_connected
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_constant(self):
    value = 1
    expect = make_expression_graph({
        'arguments': {
            'value': {'constantValue': value},
        },
        'functionName': 'Image.constant',
    })
    expression = ee.Image('a').constant(value)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image.constant(value=value)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_convolve(self):
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.convolve',
    })
    expression = ee.Image('a').convolve(kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').convolve(kernel=kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_copy_properties(self):
    source = ee.Image('b')
    properties = ['c', 'd']
    exclude = ['e', 'f']
    expect = make_expression_graph({
        'arguments': {
            'destination': IMAGE,
            'source': IMAGE_B,
            'properties': {'constantValue': properties},
            'exclude': {'constantValue': exclude},
        },
        'functionName': 'Image.copyProperties',
    })
    expression = ee.Image('a').copyProperties(source, properties, exclude)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').copyProperties(
        source=source, properties=properties, exclude=exclude
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cos(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.cos',
    })
    expression = ee.Image('a').cos()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cosh(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.cosh',
    })
    expression = ee.Image('a').cosh()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_cumulative_cost(self):
    source = 'b'
    max_distance = 2
    geodetic_distance = 3
    expect = make_expression_graph({
        'arguments': {
            'cost': IMAGE,
            'source': IMAGE_B,
            'maxDistance': {'constantValue': max_distance},
            'geodeticDistance': {'constantValue': geodetic_distance},
        },
        'functionName': 'Image.cumulativeCost',
    })
    expression = ee.Image('a').cumulativeCost(
        source, max_distance, geodetic_distance
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').cumulativeCost(
        source=source,
        maxDistance=max_distance,
        geodeticDistance=geodetic_distance,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_date(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.date',
    })
    expression = ee.Image('a').date()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_derivative(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.derivative',
    })
    expression = ee.Image('a').derivative()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_digamma(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.digamma',
    })
    expression = ee.Image('a').digamma()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_directional_distance_transform(self):
    angle = 1
    max_distance = 2
    label_band = 'label band'
    expect = make_expression_graph({
        'arguments': {
            'source': IMAGE,
            'angle': {'constantValue': angle},
            'maxDistance': {'constantValue': max_distance},
            'labelBand': {'constantValue': label_band},
        },
        'functionName': 'Image.directionalDistanceTransform',
    })
    expression = ee.Image('a').directionalDistanceTransform(
        angle, max_distance, label_band
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').directionalDistanceTransform(
        angle=angle, maxDistance=max_distance, labelBand=label_band
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_displace(self):
    displacement = 'b'
    mode = 'bilinear'
    max_offset = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'displacement': IMAGE_B,
            'mode': {'constantValue': mode},
            'maxOffset': {'constantValue': max_offset},
        },
        'functionName': 'Image.displace',
    })
    expression = ee.Image('a').displace(displacement, mode, max_offset)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').displace(
        displacement=displacement, mode=mode, maxOffset=max_offset
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_displacement(self):
    reference_image = 'b'
    max_offset = 1
    projection = EPSG_4326
    patch_width = 2
    stiffness = 3
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'referenceImage': IMAGE_B,
            'maxOffset': {'constantValue': max_offset},
            'projection': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': projection}},
                }
            },
            'patchWidth': {'constantValue': patch_width},
            'stiffness': {'constantValue': stiffness},
        },
        'functionName': 'Image.displacement',
    })
    expression = ee.Image('a').displacement(
        reference_image, max_offset, projection, patch_width, stiffness
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').displacement(
        referenceImage=reference_image,
        maxOffset=max_offset,
        projection=projection,
        patchWidth=patch_width,
        stiffness=stiffness,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_distance(self):
    kernel = ee.Kernel.square(1)
    skip_masked = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'skipMasked': {'constantValue': skip_masked},
        },
        'functionName': 'Image.distance',
    })
    expression = ee.Image('a').distance(kernel, skip_masked)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').distance(kernel=kernel, skipMasked=skip_masked)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_divide(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.divide',
    })
    expression = ee.Image('a').divide(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').divide(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_double(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.double',
    })
    expression = ee.Image('a').double()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_entropy(self):
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.entropy',
    })
    expression = ee.Image('a').entropy(kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').entropy(kernel=kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_eq(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.eq',
    })
    expression = ee.Image('a').eq(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').eq(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_erf(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.erf',
    })
    expression = ee.Image('a').erf()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_erf_inv(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.erfInv',
    })
    expression = ee.Image('a').erfInv()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_erfc(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.erfc',
    })
    expression = ee.Image('a').erfc()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_erfc_inv(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.erfcInv',
    })
    expression = ee.Image('a').erfcInv()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_exp(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.exp',
    })
    expression = ee.Image('a').exp()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_fast_distance_transform(self):
    neighborhood = 1
    units = 'pixels'
    metric = 'manhattan'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'neighborhood': {'constantValue': neighborhood},
            'units': {'constantValue': units},
            'metric': {'constantValue': metric},
        },
        'functionName': 'Image.fastDistanceTransform',
    })
    expression = ee.Image('a').fastDistanceTransform(
        neighborhood, units, metric
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').fastDistanceTransform(
        neighborhood=neighborhood, units=units, metric=metric
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_first(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.first',
    })
    expression = ee.Image('a').first(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').first(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_first_non_zero(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.firstNonZero',
    })
    expression = ee.Image('a').firstNonZero(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').firstNonZero(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_float(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.float',
    })
    expression = ee.Image('a').float()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_floor(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.floor',
    })
    expression = ee.Image('a').floor()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_focal_max(self):
    radius = 1
    kernel_type = 'plus'
    units = 'meters'
    iterations = 2
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'radius': {'constantValue': radius},
            'kernelType': {'constantValue': kernel_type},
            'units': {'constantValue': units},
            'iterations': {'constantValue': iterations},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.focalMax',
    })
    expression = ee.Image('a').focalMax(
        radius, kernel_type, units, iterations, kernel
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').focalMax(
        radius=radius,
        kernelType=kernel_type,
        units=units,
        iterations=iterations,
        kernel=kernel,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_focal_mean(self):
    radius = 1
    kernel_type = 'plus'
    units = 'meters'
    iterations = 2
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'radius': {'constantValue': radius},
            'kernelType': {'constantValue': kernel_type},
            'units': {'constantValue': units},
            'iterations': {'constantValue': iterations},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.focalMean',
    })
    expression = ee.Image('a').focalMean(
        radius, kernel_type, units, iterations, kernel
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').focalMean(
        radius=radius,
        kernelType=kernel_type,
        units=units,
        iterations=iterations,
        kernel=kernel,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_focal_median(self):
    radius = 1
    kernel_type = 'plus'
    units = 'meters'
    iterations = 2
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'radius': {'constantValue': radius},
            'kernelType': {'constantValue': kernel_type},
            'units': {'constantValue': units},
            'iterations': {'constantValue': iterations},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.focalMedian',
    })
    expression = ee.Image('a').focalMedian(
        radius, kernel_type, units, iterations, kernel
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').focalMedian(
        radius=radius,
        kernelType=kernel_type,
        units=units,
        iterations=iterations,
        kernel=kernel,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_focal_min(self):
    radius = 1
    kernel_type = 'plus'
    units = 'meters'
    iterations = 2
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'radius': {'constantValue': radius},
            'kernelType': {'constantValue': kernel_type},
            'units': {'constantValue': units},
            'iterations': {'constantValue': iterations},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.focalMin',
    })
    expression = ee.Image('a').focalMin(
        radius, kernel_type, units, iterations, kernel
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').focalMin(
        radius=radius,
        kernelType=kernel_type,
        units=units,
        iterations=iterations,
        kernel=kernel,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_focal_mode(self):
    radius = 1
    kernel_type = 'plus'
    units = 'meters'
    iterations = 2
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'radius': {'constantValue': radius},
            'kernelType': {'constantValue': kernel_type},
            'units': {'constantValue': units},
            'iterations': {'constantValue': iterations},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.focalMode',
    })
    expression = ee.Image('a').focalMode(
        radius, kernel_type, units, iterations, kernel
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').focalMode(
        radius=radius,
        kernelType=kernel_type,
        units=units,
        iterations=iterations,
        kernel=kernel,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_gamma(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.gamma',
    })
    expression = ee.Image('a').gamma()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_gammainc(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.gammainc',
    })
    expression = ee.Image('a').gammainc(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').gammainc(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_geometry(self):
    max_error = 1
    proj = EPSG_4326
    geodesics = True
    expect = make_expression_graph({
        'arguments': {
            'feature': IMAGE,
            'maxError': {
                'functionInvocationValue': {
                    'functionName': 'ErrorMargin',
                    'arguments': {'value': {'constantValue': 1}},
                }
            },
            'proj': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': proj}},
                }
            },
            'geodesics': {'constantValue': geodesics},
        },
        'functionName': 'Image.geometry',
    })
    expression = ee.Image('a').geometry(max_error, proj, geodesics)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').geometry(
        maxError=max_error, proj=proj, geodesics=geodesics
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_glcm_texture(self):
    size = 1
    kernel = ee.Kernel.square(1)
    average = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'size': {'constantValue': size},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'average': {'constantValue': average},
        },
        'functionName': 'Image.glcmTexture',
    })
    expression = ee.Image('a').glcmTexture(size, kernel, average)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').glcmTexture(
        size=size, kernel=kernel, average=average
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_gradient(self):
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
        },
        'functionName': 'Image.gradient',
    })
    expression = ee.Image('a').gradient()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_gt(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.gt',
    })
    expression = ee.Image('a').gt(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').gt(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_gte(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.gte',
    })
    expression = ee.Image('a').gte(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').gte(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_hers_descriptor(self):
    selectors = ['b', 'c']
    buckets = 1
    peak_width_scale = 2
    expect = make_expression_graph({
        'arguments': {
            'element': IMAGE,
            'selectors': {'constantValue': selectors},
            'buckets': {'constantValue': buckets},
            'peakWidthScale': {'constantValue': peak_width_scale},
        },
        'functionName': 'Image.hersDescriptor',
    })
    expression = ee.Image('a').hersDescriptor(
        selectors, buckets, peak_width_scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').hersDescriptor(
        selectors=selectors, buckets=buckets, peakWidthScale=peak_width_scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_hers_feature(self):
    reference = {'b': 'c'}
    peak_width_scale = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reference': {'constantValue': reference},
            'peakWidthScale': {'constantValue': peak_width_scale},
        },
        'functionName': 'Image.hersFeature',
    })
    expression = ee.Image('a').hersFeature(reference, peak_width_scale)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').hersFeature(
        reference=reference, peakWidthScale=peak_width_scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_hers_image(self):
    image2 = 'b'
    radius = 1
    buckets = 2
    peak_width_scale = 3
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'image2': IMAGE_B,
            'radius': {'constantValue': radius},
            'buckets': {'constantValue': buckets},
            'peakWidthScale': {'constantValue': peak_width_scale},
        },
        'functionName': 'Image.hersImage',
    })
    expression = ee.Image('a').hersImage(
        image2, radius, buckets, peak_width_scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').hersImage(
        image2=image2,
        radius=radius,
        buckets=buckets,
        peakWidthScale=peak_width_scale,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_hsv_to_rgb(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.hsvToRgb',
    })
    expression = ee.Image('a').hsvToRgb()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_hypot(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.hypot',
    })
    expression = ee.Image('a').hypot(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').hypot(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_id(self):
    expect = make_expression_graph({
        'arguments': {
            'element': IMAGE,
        },
        'functionName': 'Image.id',
    })
    expression = ee.Image('a').id()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_int(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.int',
    })
    expression = ee.Image('a').int()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_int16(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.int16',
    })
    expression = ee.Image('a').int16()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_int32(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.int32',
    })
    expression = ee.Image('a').int32()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_int64(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.int64',
    })
    expression = ee.Image('a').int64()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_int8(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.int8',
    })
    expression = ee.Image('a').int8()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_interpolate(self):
    x = [1, 2]
    y = [3, 4]
    behavior = 'clamp'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'x': {'constantValue': x},
            'y': {'constantValue': y},
            'behavior': {'constantValue': behavior},
        },
        'functionName': 'Image.interpolate',
    })
    expression = ee.Image('a').interpolate(x, y, behavior)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').interpolate(x=x, y=y, behavior=behavior)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_lanczos(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.lanczos',
    })
    expression = ee.Image('a').lanczos()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_left_shift(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.leftShift',
    })
    expression = ee.Image('a').leftShift(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').leftShift(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_link_collection(self):
    image_collection = ee.ImageCollection('b')
    linked_bands = 'a band'
    linked_properties = 'a property'
    match_property_name = 'a match property name'
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'imageCollection': {
                'functionInvocationValue': {
                    'functionName': 'ImageCollection.load',
                    'arguments': {'id': {'constantValue': 'b'}},
                }
            },
            'linkedBands': {'constantValue': linked_bands},
            'linkedProperties': {'constantValue': linked_properties},
            'matchPropertyName': {'constantValue': match_property_name},
        },
        'functionName': 'Image.linkCollection',
    })
    expression = ee.Image('a').linkCollection(
        image_collection, linked_bands, linked_properties, match_property_name
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').linkCollection(
        imageCollection=image_collection,
        linkedBands=linked_bands,
        linkedProperties=linked_properties,
        matchPropertyName=match_property_name,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_load(self):
    asset_id = 'a'
    version = 1
    expect = make_expression_graph({
        'arguments': {
            'id': {'constantValue': asset_id},
            'version': {'constantValue': version},
        },
        'functionName': 'Image.load',
    })
    expression = ee.Image.load(asset_id, version)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image.load(id=asset_id, version=version)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_load_geotiff(self):
    uri = 'a'
    expect = make_expression_graph({
        'arguments': {
            'uri': {'constantValue': uri},
        },
        'functionName': 'Image.loadGeoTIFF',
    })
    expression = ee.Image.loadGeoTIFF(uri)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').loadGeoTIFF(uri=uri)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_log(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.log',
    })
    expression = ee.Image('a').log()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_log10(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.log10',
    })
    expression = ee.Image('a').log10()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_long(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.long',
    })
    expression = ee.Image('a').long()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_lt(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.lt',
    })
    expression = ee.Image('a').lt(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').lt(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_lte(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.lte',
    })
    expression = ee.Image('a').lte(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').lte(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_mask(self):
    mask = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'mask': IMAGE_B,
        },
        'functionName': 'Image.mask',
    })
    expression = ee.Image('a').mask(mask)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').mask(mask=mask)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_cholesky_decomposition(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.matrixCholeskyDecomposition',
    })
    expression = ee.Image('a').matrixCholeskyDecomposition()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_determinant(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixDeterminant',
    })
    expression = ee.Image('a').matrixDeterminant()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_diagonal(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixDiagonal',
    })
    expression = ee.Image('a').matrixDiagonal()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_fnorm(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixFnorm',
    })
    expression = ee.Image('a').matrixFnorm()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_identity(self):
    size = 1
    expect = make_expression_graph({
        'arguments': {
            'size': {'constantValue': size},
        },
        'functionName': 'Image.matrixIdentity',
    })
    expression = ee.Image.matrixIdentity(size)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_inverse(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixInverse',
    })
    expression = ee.Image('a').matrixInverse()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_lu_decomposition(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.matrixLUDecomposition',
    })
    expression = ee.Image('a').matrixLUDecomposition()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_multiply(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.matrixMultiply',
    })
    expression = ee.Image('a').matrixMultiply(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').matrixMultiply(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_pseudo_inverse(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixPseudoInverse',
    })
    expression = ee.Image('a').matrixPseudoInverse()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_qr_decomposition(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.matrixQRDecomposition',
    })
    expression = ee.Image('a').matrixQRDecomposition()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_singular_value_decomposition(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.matrixSingularValueDecomposition',
    })
    expression = ee.Image('a').matrixSingularValueDecomposition()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_solve(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.matrixSolve',
    })
    expression = ee.Image('a').matrixSolve(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').matrixSolve(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_to_diag(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixToDiag',
    })
    expression = ee.Image('a').matrixToDiag()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_trace(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.matrixTrace',
    })
    expression = ee.Image('a').matrixTrace()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_matrix_transpose(self):
    axis1 = 1
    axis2 = 2
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'axis1': {'constantValue': axis1},
            'axis2': {'constantValue': axis2},
        },
        'functionName': 'Image.matrixTranspose',
    })
    expression = ee.Image('a').matrixTranspose(axis1, axis2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').matrixTranspose(axis1=axis1, axis2=axis2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_max(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.max',
    })
    expression = ee.Image('a').max(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').max(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_medial_axis(self):
    neighborhood = 1
    units = 'pixels'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'neighborhood': {'constantValue': neighborhood},
            'units': {'constantValue': units},
        },
        'functionName': 'Image.medialAxis',
    })
    expression = ee.Image('a').medialAxis(neighborhood, units)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').medialAxis(
        neighborhood=neighborhood, units=units
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_metadata(self):
    property = 'a property'
    name = 'a name'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'property': {'constantValue': property},
            'name': {'constantValue': name},
        },
        'functionName': 'Image.metadata',
    })
    expression = ee.Image('a').metadata(property, name)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').metadata(property=property, name=name)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_min(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.min',
    })
    expression = ee.Image('a').min(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').min(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_mod(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.mod',
    })
    expression = ee.Image('a').mod(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').mod(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_multiply(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.multiply',
    })
    expression = ee.Image('a').multiply(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').multiply(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_neighborhood_to_array(self):
    kernel = ee.Kernel.square(1)
    default_value = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'defaultValue': {'constantValue': default_value},
        },
        'functionName': 'Image.neighborhoodToArray',
    })
    expression = ee.Image('a').neighborhoodToArray(kernel, default_value)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').neighborhoodToArray(
        kernel=kernel, defaultValue=default_value
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_neighborhood_to_bands(self):
    kernel = ee.Kernel.square(1)
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
        },
        'functionName': 'Image.neighborhoodToBands',
    })
    expression = ee.Image('a').neighborhoodToBands(kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').neighborhoodToBands(kernel=kernel)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_neq(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.neq',
    })
    expression = ee.Image('a').neq(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').neq(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_normalized_difference(self):
    band_names = ['b', 'c']
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'bandNames': {'constantValue': band_names},
        },
        'functionName': 'Image.normalizedDifference',
    })
    expression = ee.Image('a').normalizedDifference(band_names)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').normalizedDifference(bandNames=band_names)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_not(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.not',
    })
    expression = ee.Image('a').Not()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_or(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.or',
    })
    expression = ee.Image('a').Or(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').Or(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_paint(self):
    featurecollection = ee.FeatureCollection('b')
    color = 'cadetblue'
    width = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'featureCollection': {
                'functionInvocationValue': {
                    'functionName': 'Collection.loadTable',
                    'arguments': {'tableId': {'constantValue': 'b'}},
                }
            },
            'color': {'constantValue': color},
            'width': {'constantValue': width},
        },
        'functionName': 'Image.paint',
    })
    expression = ee.Image('a').paint(featurecollection, color, width)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').paint(
        featureCollection=featurecollection, color=color, width=width
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_pixel_coordinates(self):
    projection = EPSG_4326
    expect = make_expression_graph({
        'arguments': {
            'projection': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': projection}},
                }
            }
        },
        'functionName': 'Image.pixelCoordinates',
    })
    expression = ee.Image('a').pixelCoordinates(projection)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').pixelCoordinates(projection=projection)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_polynomial(self):
    coefficients = [1, 2]
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'coefficients': {'constantValue': coefficients},
        },
        'functionName': 'Image.polynomial',
    })
    expression = ee.Image('a').polynomial(coefficients)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').polynomial(coefficients=coefficients)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_pow(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.pow',
    })
    expression = ee.Image('a').pow(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').pow(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_projection(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.projection',
    })
    expression = ee.Image('a').projection()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_random(self):
    seed = 1
    distribution = 'normal'
    expect = make_expression_graph({
        'arguments': {
            'seed': {'constantValue': seed},
            'distribution': {'constantValue': distribution},
        },
        'functionName': 'Image.random',
    })
    expression = ee.Image.random(seed, distribution)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image().random(seed=seed, distribution=distribution)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_random_visualizer(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.randomVisualizer',
    })
    expression = ee.Image('a').randomVisualizer()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce(self):
    reducer = ee.Reducer.sum()
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
        },
        'functionName': 'Image.reduce',
    })
    expression = ee.Image('a').reduce(reducer)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduce(reducer=reducer)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_connected_components(self):
    reducer = ee.Reducer.sum()
    label_band = 'b'
    max_size = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'labelBand': {'constantValue': label_band},
            'maxSize': {'constantValue': max_size},
        },
        'functionName': 'Image.reduceConnectedComponents',
    })
    expression = ee.Image('a').reduceConnectedComponents(
        reducer, label_band, max_size
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceConnectedComponents(
        reducer=reducer, labelBand=label_band, maxSize=max_size
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_neighborhood(self):
    reducer = ee.Reducer.sum()
    kernel = ee.Kernel.square(1)
    input_weight = 'mask'
    skip_masked = True
    optimization = 'boxcar'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'inputWeight': {'constantValue': input_weight},
            'skipMasked': {'constantValue': skip_masked},
            'optimization': {'constantValue': optimization},
        },
        'functionName': 'Image.reduceNeighborhood',
    })
    expression = ee.Image('a').reduceNeighborhood(
        reducer, kernel, input_weight, skip_masked, optimization
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceNeighborhood(
        reducer=reducer,
        kernel=kernel,
        inputWeight=input_weight,
        skipMasked=skip_masked,
        optimization=optimization,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_region(self):
    reducer = ee.Reducer.sum()
    geometry = ee.Geometry.Point([1, 2])
    scale = 1
    crs = EPSG_4326
    crs_transform = [3, 4, 5, 6, 7, 8]
    best_effort = True
    max_pixels = 9
    tile_scale = 10
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'geometry': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': [1, 2]}},
                }
            },
            'scale': {'constantValue': scale},
            'crs': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': crs}},
                }
            },
            'crsTransform': {'constantValue': crs_transform},
            'bestEffort': {'constantValue': best_effort},
            'maxPixels': {'constantValue': max_pixels},
            'tileScale': {'constantValue': tile_scale},
        },
        'functionName': 'Image.reduceRegion',
    })
    expression = ee.Image('a').reduceRegion(
        reducer,
        geometry,
        scale,
        crs,
        crs_transform,
        best_effort,
        max_pixels,
        tile_scale,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceRegion(
        reducer=reducer,
        geometry=geometry,
        scale=scale,
        crs=crs,
        crsTransform=crs_transform,
        bestEffort=best_effort,
        maxPixels=max_pixels,
        tileScale=tile_scale,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_regions(self):
    reducer = ee.Reducer.sum()
    featurecollection = ee.FeatureCollection(ee.Feature(None))
    scale = 1
    crs = EPSG_4326
    crs_transform = [3, 4, 5, 6, 7, 8]
    tile_scale = 10
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'collection': {
                'functionInvocationValue': {
                    'functionName': 'Collection',
                    'arguments': {
                        'features': {
                            'arrayValue': {
                                'values': [{
                                    'functionInvocationValue': {
                                        'functionName': 'Feature',
                                        'arguments': {},
                                    }
                                }]
                            }
                        }
                    },
                }
            },
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'scale': {'constantValue': scale},
            'crs': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': crs}},
                }
            },
            'crsTransform': {'constantValue': crs_transform},
            'tileScale': {'constantValue': tile_scale},
        },
        'functionName': 'Image.reduceRegions',
    })
    expression = ee.Image('a').reduceRegions(
        featurecollection, reducer, scale, crs, crs_transform, tile_scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceRegions(
        collection=featurecollection,
        reducer=reducer,
        scale=scale,
        crs=crs,
        crsTransform=crs_transform,
        tileScale=tile_scale,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_resolution(self):
    reducer = ee.Reducer.sum()
    best_effort = True
    max_pixels = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'bestEffort': {'constantValue': best_effort},
            'maxPixels': {'constantValue': max_pixels},
        },
        'functionName': 'Image.reduceResolution',
    })
    expression = ee.Image('a').reduceResolution(
        reducer, best_effort, max_pixels
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceResolution(
        reducer=reducer, bestEffort=best_effort, maxPixels=max_pixels
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_reduce_to_vectors(self):
    reducer = ee.Reducer.sum()
    geometry = ee.Geometry.Point([1, 2])
    scale = 3
    geometry_type = 'bb'
    eight_connected = True
    label_property = 'a label property'
    crs = EPSG_4326
    crs_transform = [4, 5, 6, 7, 8, 9]
    best_effort = True
    max_pixels = 10
    tile_scale = 11
    geometry_in_native_projection = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'reducer': {
                'functionInvocationValue': {
                    'functionName': 'Reducer.sum',
                    'arguments': {},
                }
            },
            'geometry': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': [1, 2]}},
                }
            },
            'scale': {'constantValue': scale},
            'geometryType': {'constantValue': geometry_type},
            'eightConnected': {'constantValue': eight_connected},
            'labelProperty': {'constantValue': label_property},
            'crs': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': crs}},
                }
            },
            'crsTransform': {'constantValue': crs_transform},
            'bestEffort': {'constantValue': best_effort},
            'maxPixels': {'constantValue': max_pixels},
            'tileScale': {'constantValue': tile_scale},
            'geometryInNativeProjection': {
                'constantValue': geometry_in_native_projection
            },
        },
        'functionName': 'Image.reduceToVectors',
    })
    expression = ee.Image('a').reduceToVectors(
        reducer,
        geometry,
        scale,
        geometry_type,
        eight_connected,
        label_property,
        crs,
        crs_transform,
        best_effort,
        max_pixels,
        tile_scale,
        geometry_in_native_projection,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reduceToVectors(
        reducer=reducer,
        geometry=geometry,
        scale=scale,
        geometryType=geometry_type,
        eightConnected=eight_connected,
        labelProperty=label_property,
        crs=crs,
        crsTransform=crs_transform,
        bestEffort=best_effort,
        maxPixels=max_pixels,
        tileScale=tile_scale,
        geometryInNativeProjection=geometry_in_native_projection,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_regexp_rename(self):
    regex = 'a regex'
    replacement = 'a replacement'
    all = True
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'regex': {'constantValue': regex},
            'replacement': {'constantValue': replacement},
            'all': {'constantValue': all},
        },
        'functionName': 'Image.regexpRename',
    })
    expression = ee.Image('a').regexpRename(regex, replacement, all)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').regexpRename(
        regex=regex, replacement=replacement, all=all
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_register(self):
    reference_image = 'b'
    max_offset = 1
    patch_width = 2
    stiffness = 3
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'referenceImage': IMAGE_B,
            'maxOffset': {'constantValue': max_offset},
            'patchWidth': {'constantValue': patch_width},
            'stiffness': {'constantValue': stiffness},
        },
        'functionName': 'Image.register',
    })
    expression = ee.Image('a').register(
        reference_image, max_offset, patch_width, stiffness
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').register(
        referenceImage=reference_image,
        maxOffset=max_offset,
        patchWidth=patch_width,
        stiffness=stiffness,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_remap(self):
    # `from` is a reserved word.
    from_list = [1, 2]
    to = [3, 4]
    default_value = 5
    band_name = 'a band name'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'from': {'constantValue': from_list},
            'to': {'constantValue': to},
            'defaultValue': {'constantValue': default_value},
            'bandName': {'constantValue': band_name},
        },
        'functionName': 'Image.remap',
    })
    expression = ee.Image('a').remap(from_list, to, default_value, band_name)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').remap(
        to=to,
        defaultValue=default_value,
        bandName=band_name,
        **{'from': from_list}
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_rename(self):
    names = ['b', 'c']
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'names': {'constantValue': names},
        },
        'functionName': 'Image.rename',
    })
    expression = ee.Image('a').rename(names)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    # var_args, so no kwargs

  def test_reproject(self):
    crs = EPSG_4326
    crs_transform = [1, 2, 3, 4, 5, 6]
    scale = 7
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'crs': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': crs}},
                }
            },
            'crsTransform': {'constantValue': crs_transform},
            'scale': {'constantValue': scale},
        },
        'functionName': 'Image.reproject',
    })
    expression = ee.Image('a').reproject(crs, crs_transform, scale)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').reproject(
        crs=crs, crsTransform=crs_transform, scale=scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_resample(self):
    mode = 'bicubic'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'mode': {'constantValue': mode},
        },
        'functionName': 'Image.resample',
    })
    expression = ee.Image('a').resample(mode)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').resample(mode=mode)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_rgb_to_hsv(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.rgbToHsv',
    })
    expression = ee.Image('a').rgbToHsv()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_right_shift(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.rightShift',
    })
    expression = ee.Image('a').rightShift(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').rightShift(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_round(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.round',
    })
    expression = ee.Image('a').round()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_rsed_transform(self):
    neighborhood = 1
    units = 'pixels'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'neighborhood': {'constantValue': neighborhood},
            'units': {'constantValue': units},
        },
        'functionName': 'Image.rsedTransform',
    })
    expression = ee.Image('a').rsedTransform(neighborhood, units)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').rsedTransform(
        neighborhood=neighborhood, units=units
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sample(self):
    region = ee.Geometry.Point([1, 2])
    scale = 3
    projection = EPSG_4326
    factor = 4
    num_pixels = 5
    seed = 6
    drop_nulls = True
    tile_scale = 7
    geometries = False
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'region': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': [1, 2]}},
                }
            },
            'scale': {'constantValue': scale},
            'projection': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': projection}},
                }
            },
            'factor': {'constantValue': factor},
            'numPixels': {'constantValue': num_pixels},
            'seed': {'constantValue': seed},
            'dropNulls': {'constantValue': drop_nulls},
            'tileScale': {'constantValue': tile_scale},
            'geometries': {'constantValue': geometries},
        },
        'functionName': 'Image.sample',
    })
    expression = ee.Image('a').sample(
        region,
        scale,
        projection,
        factor,
        num_pixels,
        seed,
        drop_nulls,
        tile_scale,
        geometries,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').sample(
        region=region,
        scale=scale,
        projection=projection,
        factor=factor,
        numPixels=num_pixels,
        seed=seed,
        dropNulls=drop_nulls,
        tileScale=tile_scale,
        geometries=geometries,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sample_rectangle(self):
    point = [1, 2]
    region = ee.Geometry.Point(point)
    properties = ['b', 'c']
    default_value = 3
    default_array_value = [4, 5]
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'region': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': point}},
                }
            },
            'properties': {'constantValue': properties},
            'defaultValue': {'constantValue': default_value},
            'defaultArrayValue': {
                'functionInvocationValue': {
                    'functionName': 'Array',
                    'arguments': {
                        'values': {'constantValue': default_array_value}
                    },
                }
            },
        },
        'functionName': 'Image.sampleRectangle',
    })
    expression = ee.Image('a').sampleRectangle(
        region, properties, default_value, default_array_value
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').sampleRectangle(
        region=region,
        properties=properties,
        defaultValue=default_value,
        defaultArrayValue=default_array_value,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sample_regions(self):
    featurecollection = ee.FeatureCollection(ee.Feature(None))
    properties = ['b', 'c']
    scale = 3
    projection = EPSG_4326
    tile_scale = 4
    geometries = False

    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'collection': {
                'functionInvocationValue': {
                    'functionName': 'Collection',
                    'arguments': {
                        'features': {
                            'arrayValue': {
                                'values': [{
                                    'functionInvocationValue': {
                                        'functionName': 'Feature',
                                        'arguments': {},
                                    }
                                }]
                            }
                        }
                    },
                }
            },
            'geometries': {'constantValue': geometries},
            'projection': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': projection}},
                }
            },
            'properties': {'constantValue': properties},
            'scale': {'constantValue': scale},
            'tileScale': {'constantValue': tile_scale},
        },
        'functionName': 'Image.sampleRegions',
    })
    expression = ee.Image('a').sampleRegions(
        featurecollection, properties, scale, projection, tile_scale, geometries
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').sampleRegions(
        collection=featurecollection,
        properties=properties,
        scale=scale,
        projection=projection,
        tileScale=tile_scale,
        geometries=geometries,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_select(self):
    band_selectors = ['b', 'c']
    new_names = ['d', 'e']
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'bandSelectors': {'constantValue': band_selectors},
            'newNames': {'constantValue': new_names},
        },
        'functionName': 'Image.select',
    })
    expression = ee.Image('a').select(band_selectors, new_names)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  # var_args, so now kwargs.

  def test_self_mask(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.selfMask',
    })
    expression = ee.Image('a').selfMask()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_set_default_projection(self):
    crs = EPSG_4326
    crs_transform = [1, 2, 3, 4, 5, 6]
    scale = 7
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'crs': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': crs}},
                }
            },
            'crsTransform': {'constantValue': crs_transform},
            'scale': {'constantValue': scale},
        },
        'functionName': 'Image.setDefaultProjection',
    })
    expression = ee.Image('a').setDefaultProjection(crs, crs_transform, scale)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').setDefaultProjection(
        crs=crs, crsTransform=crs_transform, scale=scale
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_short(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.short',
    })
    expression = ee.Image('a').short()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_signum(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.signum',
    })
    expression = ee.Image('a').signum()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sin(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.sin',
    })
    expression = ee.Image('a').sin()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sinh(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.sinh',
    })
    expression = ee.Image('a').sinh()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sld_style(self):
    sld_xml = 'some xml'
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'sldXml': {'constantValue': sld_xml},
        },
        'functionName': 'Image.sldStyle',
    })
    expression = ee.Image('a').sldStyle(sld_xml)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').sldStyle(sldXml=sld_xml)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_slice(self):
    start = 1
    end = 2
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'start': {'constantValue': start},
            'end': {'constantValue': end},
        },
        'functionName': 'Image.slice',
    })
    expression = ee.Image('a').slice(start, end)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').slice(start=start, end=end)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_spectral_dilation(self):
    metric = 'sid'
    kernel = ee.Kernel.square(1)
    use_centroid = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'metric': {'constantValue': metric},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'useCentroid': {'constantValue': use_centroid},
        },
        'functionName': 'Image.spectralDilation',
    })
    expression = ee.Image('a').spectralDilation(metric, kernel, use_centroid)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').spectralDilation(
        metric=metric, kernel=kernel, useCentroid=use_centroid
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_spectral_distance(self):
    image2 = 'b'
    metric = 'emd'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
            'metric': {'constantValue': metric},
        },
        'functionName': 'Image.spectralDistance',
    })
    expression = ee.Image('a').spectralDistance(image2, metric)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').spectralDistance(image2=image2, metric=metric)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_spectral_erosion(self):
    metric = 'sid'
    kernel = ee.Kernel.square(1)
    use_centroid = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'metric': {'constantValue': metric},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'useCentroid': {'constantValue': use_centroid},
        },
        'functionName': 'Image.spectralErosion',
    })
    expression = ee.Image('a').spectralErosion(metric, kernel, use_centroid)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').spectralErosion(
        metric=metric, kernel=kernel, useCentroid=use_centroid
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_spectral_gradient(self):
    metric = 'sid'
    kernel = ee.Kernel.square(1)
    use_centroid = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'metric': {'constantValue': metric},
            'kernel': {
                'functionInvocationValue': {
                    'functionName': 'Kernel.square',
                    'arguments': {'radius': {'constantValue': 1}},
                }
            },
            'useCentroid': {'constantValue': use_centroid},
        },
        'functionName': 'Image.spectralGradient',
    })
    expression = ee.Image('a').spectralGradient(metric, kernel, use_centroid)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').spectralGradient(
        metric=metric, kernel=kernel, useCentroid=use_centroid
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_sqrt(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.sqrt',
    })
    expression = ee.Image('a').sqrt()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_stratified_sample(self):
    num_points = 1
    class_band = 'band'
    point = [7, 8]
    region = ee.Geometry.Point(point)
    scale = 2
    projection = EPSG_4326
    seed = 3
    class_values = ['b', 'c']
    class_points = [4, 5]
    drop_nulls = False
    tile_scale = 6
    geometries = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'numPoints': {'constantValue': num_points},
            'classBand': {'constantValue': class_band},
            'region': {
                'functionInvocationValue': {
                    'functionName': 'GeometryConstructors.Point',
                    'arguments': {'coordinates': {'constantValue': point}},
                }
            },
            'scale': {'constantValue': scale},
            'projection': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': projection}},
                }
            },
            'seed': {'constantValue': seed},
            'classValues': {'constantValue': class_values},
            'classPoints': {'constantValue': class_points},
            'dropNulls': {'constantValue': drop_nulls},
            'tileScale': {'constantValue': tile_scale},
            'geometries': {'constantValue': geometries},
        },
        'functionName': 'Image.stratifiedSample',
    })
    expression = ee.Image('a').stratifiedSample(
        num_points,
        class_band,
        region,
        scale,
        projection,
        seed,
        class_values,
        class_points,
        drop_nulls,
        tile_scale,
        geometries,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').stratifiedSample(
        numPoints=num_points,
        classBand=class_band,
        region=region,
        scale=scale,
        projection=projection,
        seed=seed,
        classValues=class_values,
        classPoints=class_points,
        dropNulls=drop_nulls,
        tileScale=tile_scale,
        geometries=geometries,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_subtract(self):
    image2 = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image1': IMAGE,
            'image2': IMAGE_B,
        },
        'functionName': 'Image.subtract',
    })
    expression = ee.Image('a').subtract(image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').subtract(image2=image2)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_tan(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.tan',
    })
    expression = ee.Image('a').tan()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_tanh(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.tanh',
    })
    expression = ee.Image('a').tanh()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_array(self):
    axis = 1
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'axis': {'constantValue': axis},
        },
        'functionName': 'Image.toArray',
    })
    expression = ee.Image('a').toArray(axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').toArray(axis=axis)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_byte(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toByte',
    })
    expression = ee.Image('a').toByte()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_double(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toDouble',
    })
    expression = ee.Image('a').toDouble()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_float(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toFloat',
    })
    expression = ee.Image('a').toFloat()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_int(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toInt',
    })
    expression = ee.Image('a').toInt()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_int16(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toInt16',
    })
    expression = ee.Image('a').toInt16()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_int32(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toInt32',
    })
    expression = ee.Image('a').toInt32()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_int64(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toInt64',
    })
    expression = ee.Image('a').toInt64()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_int8(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toInt8',
    })
    expression = ee.Image('a').toInt8()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_long(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toLong',
    })
    expression = ee.Image('a').toLong()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_short(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toShort',
    })
    expression = ee.Image('a').toShort()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_uint16(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toUint16',
    })
    expression = ee.Image('a').toUint16()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_uint32(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toUint32',
    })
    expression = ee.Image('a').toUint32()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_to_uint8(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.toUint8',
    })
    expression = ee.Image('a').toUint8()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_translate(self):
    x = 1
    y = 2
    units = 'pixels'
    proj = EPSG_4326
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'x': {'constantValue': x},
            'y': {'constantValue': y},
            'units': {'constantValue': units},
            'proj': {
                'functionInvocationValue': {
                    'functionName': 'Projection',
                    'arguments': {'crs': {'constantValue': proj}},
                }
            },
        },
        'functionName': 'Image.translate',
    })
    expression = ee.Image('a').translate(x, y, units, proj)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').translate(x=x, y=y, units=units, proj=proj)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_trigamma(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.trigamma',
    })
    expression = ee.Image('a').trigamma()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_uint16(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.uint16',
    })
    expression = ee.Image('a').uint16()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_uint32(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.uint32',
    })
    expression = ee.Image('a').uint32()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_uint8(self):
    expect = make_expression_graph({
        'arguments': {
            'value': IMAGE,
        },
        'functionName': 'Image.uint8',
    })
    expression = ee.Image('a').uint8()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_unit_scale(self):
    low = 1
    high = 2
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'low': {'constantValue': low},
            'high': {'constantValue': high},
        },
        'functionName': 'Image.unitScale',
    })
    expression = ee.Image('a').unitScale(low, high)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').unitScale(low=low, high=high)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_unmask(self):
    value = 'b'
    same_footprint = True
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'value': IMAGE_B,
            'sameFootprint': {'constantValue': same_footprint},
        },
        'functionName': 'Image.unmask',
    })
    expression = ee.Image('a').unmask(value, same_footprint)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').unmask(value=value, sameFootprint=same_footprint)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_unmix(self):
    endmembers = ['b', 'c']
    sum_to_one = False
    non_negative = True
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'endmembers': {'constantValue': endmembers},
            'nonNegative': {'constantValue': non_negative},
            'sumToOne': {'constantValue': sum_to_one},
        },
        'functionName': 'Image.unmix',
    })
    expression = ee.Image('a').unmix(endmembers, sum_to_one, non_negative)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').unmix(
        endmembers=endmembers, sumToOne=sum_to_one, nonNegative=non_negative
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_update_mask(self):
    mask = 'b'
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'mask': IMAGE_B,
        },
        'functionName': 'Image.updateMask',
    })
    expression = ee.Image('a').updateMask(mask)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').updateMask(mask=mask)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_visualize(self):
    bands = ['b', 'c']
    gain = [1, 2]
    bias = [3, 4]
    min_values = [5, 6]
    max_values = [7, 8]
    gamma = [9, 10]
    opacity = 11
    palette = ['red', 'blue']
    force_rgb_output = True

    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
            'bands': {'constantValue': bands},
            'gain': {'constantValue': gain},
            'bias': {'constantValue': bias},
            'min': {'constantValue': min_values},
            'max': {'constantValue': max_values},
            'gamma': {'constantValue': gamma},
            'opacity': {'constantValue': opacity},
            'palette': {'constantValue': palette},
            'forceRgbOutput': {'constantValue': force_rgb_output},
        },
        'functionName': 'Image.visualize',
    })

    expression = ee.Image('a').visualize(
        bands,
        gain,
        bias,
        min_values,
        max_values,
        gamma,
        opacity,
        palette,
        force_rgb_output,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').visualize(
        bands=bands,
        gain=gain,
        bias=bias,
        min=min_values,
        max=max_values,
        gamma=gamma,
        opacity=opacity,
        palette=palette,
        forceRgbOutput=force_rgb_output,
    )
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_where(self):
    test = 'b'
    value = 'c'
    expect = make_expression_graph({
        'arguments': {
            'input': IMAGE,
            'test': IMAGE_B,
            'value': IMAGE_C,
        },
        'functionName': 'Image.where',
    })
    expression = ee.Image('a').where(test, value)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

    expression = ee.Image('a').where(test=test, value=value)
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)

  def test_zero_crossing(self):
    expect = make_expression_graph({
        'arguments': {
            'image': IMAGE,
        },
        'functionName': 'Image.zeroCrossing',
    })
    expression = ee.Image('a').zeroCrossing()
    result = json.loads(expression.serialize())
    self.assertEqual(expect, result)


if __name__ == '__main__':
  unittest.main()