<%
  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.annotation.UiThreadTest;
import android.support.test.runner.AndroidJUnit4;

import com.mapbox.mapboxsdk.maps.BaseLayerTest;
import org.junit.Before;
import timber.log.Timber;

import com.mapbox.mapboxsdk.style.expressions.Expression;
import com.mapbox.mapboxsdk.style.layers.<%- camelize(type) %>Layer;
<% if (type === 'symbol') { -%>
import com.mapbox.mapboxsdk.style.types.Formatted;
import com.mapbox.mapboxsdk.style.types.FormattedSection;
<% } -%>

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

import static com.mapbox.mapboxsdk.style.expressions.Expression.*;
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;

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

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

  @Before
  @UiThreadTest
  public void beforeTest(){
    super.before();
<% if (type === 'background') { -%>
    layer = new <%- camelize(type) %>Layer("my-layer");
<% } else { -%>
    layer = new <%- camelize(type) %>Layer("my-layer", "composite");
    layer.setSourceLayer("composite");
<% } -%>
    setupLayer(layer);
  }
<% if (type !== 'background') { -%>

  @Test
  @UiThreadTest
  public void testSourceId() {
    Timber.i("SourceId");
    assertNotNull(layer);
    assertEquals(layer.getSourceId(), "composite");
  }
<% } -%>

  @Test
  @UiThreadTest
  public void testSetVisibility() {
    Timber.i("Visibility");
    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
  @UiThreadTest
  public void testSourceLayer() {
    Timber.i("SourceLayer");
    assertNotNull(layer);

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

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

  @Test
  @UiThreadTest
  public void testFilter() {
    Timber.i("Filter");
    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());

    // Set constant
    filter = literal(true);
    layer.setFilter(filter);
    assertEquals(layer.getFilter().toString(), filter.toString());
  }


<% } -%>
<% for (const property of properties) { -%>
<% if (property['property-type'] !== 'color-ramp') { -%>
<% if (property.transition) { -%>

  @Test
  @UiThreadTest
  public void test<%- camelize(property.name) %>Transition() {
    Timber.i("<%- property.name %>TransitionOptions");
    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
  @UiThreadTest
  public void test<%- camelize(property.name) %>AsConstant() {
    Timber.i("<%- property.name %>");
    assertNotNull(layer);
    assertNull(layer.get<%- camelize(property.name) %>().getValue());

    // Set and Get
    <%- propertyType(property) %> propertyValue = <%- defaultValueJava(property) %>;
<% if (property.type === 'formatted') { -%>
    layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>("default"));
    assertEquals(layer.get<%- camelize(property.name) %>().getValue(), propertyValue);
<% } -%>
    layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>(propertyValue));
    assertEquals(layer.get<%- camelize(property.name) %>().getValue(), propertyValue);
<% if (property.tokens) { -%>

    layer.setProperties(<%- camelizeWithLeadingLowercase(property.name) %>("{token}"));
<% if (property.type === 'formatted') { -%>
    assertEquals(layer.get<%- camelize(property.name) %>().getExpression(), <%- defaultExpressionJava(property) %>(Expression.formatEntry(Expression.toString(Expression.get("token")))));
<% } else {-%>
    assertEquals(layer.get<%- camelize(property.name) %>().getExpression(), Expression.toString(Expression.get("token")));
<% } -%>
<% } -%>
  }
<% if (property['property-type'] === 'data-driven' || property['property-type'] === 'cross-faded-data-driven') { -%>
<% if (!(property.name.endsWith("-font")||property.name.endsWith("-offset"))) { -%>

  @Test
  @UiThreadTest
  public void test<%- camelize(property.name) %>AsExpression() {
    Timber.i("<%- property.name %>-expression");
    assertNotNull(layer);
    assertNull(layer.get<%- camelize(property.name) %>().getExpression());

    // Set and Get
<% if (property.type === 'formatted') { -%>
    Expression expression = <%- defaultExpressionJava(property) %>(Expression.formatEntry(Expression.get("undefined"), FormatOption.formatFontScale(2.0), FormatOption.formatTextFont(new String[]{"Open Sans Regular", "Arial Unicode MS Regular"})));
<% } else { -%>
    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
  @UiThreadTest
  public void test<%- camelize(property.name) %>AsIntConstant() {
    Timber.i("<%- property.name %>");
    assertNotNull(layer);

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