<%
  const type = locals.type;
  const properties = locals.properties;
-%>
// This file is generated. Edit android/platform/scripts/generate-style-code.js, then run `make android-style-code`.

package com.mapbox.mapboxsdk.testapp.style;

import android.graphics.Color;
import android.support.test.runner.AndroidJUnit4;

import timber.log.Timber;

import com.mapbox.mapboxsdk.style.expressions.Expression;
import com.mapbox.mapboxsdk.style.layers.<%- camelize(type) %>Layer;
import com.mapbox.mapboxsdk.testapp.activity.BaseActivityTest;

import org.junit.Test;
import org.junit.runner.RunWith;

import static com.mapbox.mapboxsdk.style.expressions.Expression.*;
import static com.mapbox.mapboxsdk.testapp.action.MapboxMapAction.invoke;
import static org.junit.Assert.*;
import static com.mapbox.mapboxsdk.style.layers.Property.*;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.*;

import com.mapbox.mapboxsdk.style.layers.TransitionOptions;
import com.mapbox.mapboxsdk.testapp.activity.espresso.EspressoTestActivity;

/**
 * Basic smoke tests for <%- camelize(type) %>Layer
 */
@RunWith(AndroidJUnit4.class)
public class <%- camelize(type) %>LayerTest extends BaseActivityTest {

  private <%- camelize(type) %>Layer layer;

  @Override
  protected Class getActivityClass() {
    return EspressoTestActivity.class;
  }

  private void setupLayer() {
<% if (type === 'background') { -%>
    Timber.i("Retrieving layer");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      layer = mapboxMap.getLayerAs("background");
    });
<% } else { -%>
    Timber.i("Retrieving layer");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      if ((layer = mapboxMap.getLayerAs("my-layer")) == null) {
        Timber.i("Adding layer");
        layer = new <%- camelize(type) %>Layer("my-layer", "composite");
        layer.setSourceLayer("composite");
        mapboxMap.addLayer(layer);
        // Layer reference is now stale, get new reference
        layer = mapboxMap.getLayerAs("my-layer");
      }
    });
<% } -%>
  }

  @Test
  public void testSetVisibility() {
    validateTestSetup();
    setupLayer();
    Timber.i("Visibility");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Get initial
      assertEquals(layer.getVisibility().getValue(), VISIBLE);

      // Set
      layer.setProperties(visibility(NONE));
      assertEquals(layer.getVisibility().getValue(), NONE);
    });
  }
<% if (!(type === 'background' || type === 'raster' || type === 'hillshade')) { -%>

  @Test
  public void testSourceLayer() {
    validateTestSetup();
    setupLayer();
    Timber.i("SourceLayer");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Get initial
      assertEquals(layer.getSourceLayer(), "composite");

      // Set
      final String sourceLayer = "test";
      layer.setSourceLayer(sourceLayer);
      assertEquals(layer.getSourceLayer(), sourceLayer);
    });
  }

  @Test
  public void testFilter() {
    validateTestSetup();
    setupLayer();
    Timber.i("Filter");
    invoke(mapboxMap, (uiController, mapboxMap1) -> {
      assertNotNull(layer);

      // Get initial
      assertEquals(layer.getFilter(), null);

      // Set
      Expression filter = eq(get("undefined"), literal(1.0));
      layer.setFilter(filter);
      assertEquals(layer.getFilter().toString(), filter.toString());
    });
  }


<% } -%>
<% for (const property of properties) { -%>
<% if (property.name != 'heatmap-color') { -%>
<% if (property.transition) { -%>

  @Test
  public void test<%- camelize(property.name) %>Transition() {
    validateTestSetup();
    setupLayer();
    Timber.i("<%- property.name %>TransitionOptions");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Set and Get
      TransitionOptions options = new TransitionOptions(300, 100);
      layer.set<%- camelize(property.name) %>Transition(options);
      assertEquals(layer.get<%- camelize(property.name) %>Transition(), options);
    });
  }
<% } -%>

  @Test
  public void test<%- camelize(property.name) %>AsConstant() {
    validateTestSetup();
    setupLayer();
    Timber.i("<%- property.name %>");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Set and Get
      layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>(<%- defaultValueJava(property) %>));
      assertEquals((<%- propertyType(property) %>) layer.get<%- camelize(property.name) %>().getValue(), (<%- propertyType(property) %>) <%- defaultValueJava(property) %>);
    });
  }
<% if (isDataDriven(property)) { -%>
<% if (!(property.name.endsWith("-font")||property.name.endsWith("-offset"))) { -%>

  @Test
  public void test<%- camelize(property.name) %>AsExpression() {
    validateTestSetup();
    setupLayer();
    Timber.i("<%- property.name %>-expression");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Set and Get
      Expression expression = <%- defaultExpressionJava(property) %>(Expression.get("undefined"));
      layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>(expression));
      assertEquals(layer.get<%- camelize(property.name) %>().getExpression(), expression);
    });
  }

<% } -%>
<% } -%>
<% if (property.type == 'color') { -%>

  @Test
  public void test<%- camelize(property.name) %>AsIntConstant() {
    validateTestSetup();
    setupLayer();
    Timber.i("<%- property.name %>");
    invoke(mapboxMap, (uiController, mapboxMap) -> {
      assertNotNull(layer);

      // Set and Get
      layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>(Color.RED));
      assertEquals(layer.get<%- camelize(property.name) %>AsInt(), Color.RED);
    });
  }
<% } -%>
<% } -%>
<% } -%>
}