import { Cartesian3 } from "../../Source/Cesium.js";
import { Cartographic } from "../../Source/Cesium.js";
import { ComponentDatatype } from "../../Source/Cesium.js";
import { Ellipsoid } from "../../Source/Cesium.js";
import { EncodedCartesian3 } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Matrix4 } from "../../Source/Cesium.js";
import { Rectangle } from "../../Source/Cesium.js";
import { Transforms } from "../../Source/Cesium.js";
import { WebMercatorProjection } from "../../Source/Cesium.js";
import { Material } from "../../Source/Cesium.js";
import { MaterialAppearance } from "../../Source/Cesium.js";
import { PerInstanceColorAppearance } from "../../Source/Cesium.js";
import { ShadowVolumeAppearance } from "../../Source/Cesium.js";

describe("Scene/ShadowVolumeAppearance", function () {
  // using ShadowVolumeAppearanceVS directly fails on Travis with the --release test
  var testVs =
    "attribute vec3 position3DHigh;\n" +
    "attribute vec3 position3DLow;\n" +
    "attribute float batchId;\n" +
    "void main() {\n" +
    "    vec4 position = czm_computePosition();\n" +
    "    gl_Position = czm_depthClamp(czm_modelViewProjectionRelativeToEye * position);\n" +
    "}\n";

  var unitSphereEllipsoid = Ellipsoid.UNIT_SPHERE;
  var projection = new WebMercatorProjection(unitSphereEllipsoid);
  var largeTestRectangle = Rectangle.fromDegrees(-45.0, -45.0, 45.0, 45.0);
  var smallTestRectangle = Rectangle.fromDegrees(-0.1, -0.1, 0.1, 0.1);

  var largeRectangleAttributes = ShadowVolumeAppearance.getSphericalExtentGeometryInstanceAttributes(
    largeTestRectangle,
    [0, 0, 0, 1, 1, 0],
    unitSphereEllipsoid,
    projection
  );
  var smallRectangleAttributes = ShadowVolumeAppearance.getPlanarTextureCoordinateAttributes(
    smallTestRectangle,
    [0, 0, 0, 1, 1, 0],
    unitSphereEllipsoid,
    projection
  );

  var perInstanceColorMaterialAppearance = new PerInstanceColorAppearance();
  var flatPerInstanceColorMaterialAppearance = new PerInstanceColorAppearance({
    flat: true,
  });

  var textureMaterialAppearance = new MaterialAppearance({
    material: new Material({
      fabric: {
        type: "BumpMap",
        uniforms: {
          image: "../images/Cesium_Logo_Color.jpg",
          channel: "r",
        },
      },
    }),
  });
  var flatTextureMaterialAppearance = new MaterialAppearance({
    material: Material.fromType(Material.ImageType, {
      image: "../Data/images/Red16x16.png",
    }),
    flat: true,
  });

  // Defines for projection extents
  var eastMostCartographic = new Cartographic();
  var longitudeExtentsEncodeScratch = {
    high: 0.0,
    low: 0.0,
  };
  eastMostCartographic.longitude = CesiumMath.PI;
  eastMostCartographic.latitude = 0.0;
  eastMostCartographic.height = 0.0;
  var eastMostCartesian = projection.project(eastMostCartographic);
  var encoded = EncodedCartesian3.encode(
    eastMostCartesian.x,
    longitudeExtentsEncodeScratch
  );
  var eastMostYhighDefine =
    "EAST_MOST_X_HIGH " + encoded.high.toFixed((encoded.high + "").length + 1);
  var eastMostYlowDefine =
    "EAST_MOST_X_LOW " + encoded.low.toFixed((encoded.low + "").length + 1);

  var westMostCartographic = new Cartographic();
  westMostCartographic.longitude = -CesiumMath.PI;
  westMostCartographic.latitude = 0.0;
  westMostCartographic.height = 0.0;
  var westMostCartesian = projection.project(westMostCartographic);
  encoded = EncodedCartesian3.encode(
    westMostCartesian.x,
    longitudeExtentsEncodeScratch
  );
  var westMostYhighDefine =
    "WEST_MOST_X_HIGH " + encoded.high.toFixed((encoded.high + "").length + 1);
  var westMostYlowDefine =
    "WEST_MOST_X_LOW " + encoded.low.toFixed((encoded.low + "").length + 1);

  it("provides attributes for computing texture coordinates from Spherical extents", function () {
    var attributes = largeRectangleAttributes;

    var sphericalExtents = attributes.sphericalExtents;
    expect(sphericalExtents.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(sphericalExtents.componentsPerAttribute).toEqual(4);
    expect(sphericalExtents.normalize).toEqual(false);
    var value = sphericalExtents.value;
    expect(value[0]).toEqualEpsilon(
      -CesiumMath.PI_OVER_FOUR,
      CesiumMath.EPSILON4
    );
    expect(value[1]).toEqualEpsilon(
      -CesiumMath.PI_OVER_FOUR,
      CesiumMath.EPSILON4
    );
    expect(value[2]).toEqualEpsilon(
      1.0 / CesiumMath.PI_OVER_TWO,
      CesiumMath.EPSILON4
    );
    expect(value[3]).toEqualEpsilon(
      1.0 / CesiumMath.PI_OVER_TWO,
      CesiumMath.EPSILON4
    );

    var longitudeRotation = attributes.longitudeRotation;
    expect(longitudeRotation.componentDatatype).toEqual(
      ComponentDatatype.FLOAT
    );
    expect(longitudeRotation.componentsPerAttribute).toEqual(1);
    expect(longitudeRotation.normalize).toEqual(false);
    value = longitudeRotation.value;
    expect(value[0]).toEqualEpsilon(0.0, CesiumMath.EPSILON4);
  });

  function checkGeometryInstanceAttributeVec3(attribute) {
    expect(attribute.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(attribute.componentsPerAttribute).toEqual(3);
    expect(attribute.normalize).toEqual(false);
  }

  it("provides attributes for computing texture coordinates using planes in 3D", function () {
    var attributes = smallRectangleAttributes;

    var southWest_LOW = attributes.southWest_LOW;
    var southWest_HIGH = attributes.southWest_HIGH;
    var eastward = attributes.eastward;
    var northward = attributes.northward;

    checkGeometryInstanceAttributeVec3(southWest_LOW);
    checkGeometryInstanceAttributeVec3(southWest_HIGH);
    checkGeometryInstanceAttributeVec3(eastward);
    checkGeometryInstanceAttributeVec3(northward);

    // We're using a unit sphere, so expect all HIGH values to be basically 0
    // and LOW value to be within a small cone around UNIT_X
    expect(southWest_HIGH.value[0]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(southWest_HIGH.value[1]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(southWest_HIGH.value[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);

    expect(southWest_LOW.value[0]).toBeGreaterThan(
      Math.cos(CesiumMath.toRadians(0.2))
    );

    // Expect eastward and northward to be unit-direction vectors in the ENU coordinate system at the rectangle center
    var smallRectangleCenter = Cartographic.toCartesian(
      Rectangle.center(smallTestRectangle),
      unitSphereEllipsoid
    );
    var enuMatrix = Transforms.eastNorthUpToFixedFrame(
      smallRectangleCenter,
      unitSphereEllipsoid
    );
    var inverseEnu = Matrix4.inverse(enuMatrix, new Matrix4());

    var eastwardENU = Matrix4.multiplyByPointAsVector(
      inverseEnu,
      Cartesian3.fromArray(eastward.value),
      new Cartesian3()
    );
    eastwardENU = Cartesian3.normalize(eastwardENU, eastwardENU);
    expect(
      Cartesian3.equalsEpsilon(
        eastwardENU,
        Cartesian3.UNIT_X,
        CesiumMath.EPSILON7
      )
    ).toBe(true);

    var northwardENU = Matrix4.multiplyByPointAsVector(
      inverseEnu,
      Cartesian3.fromArray(northward.value),
      new Cartesian3()
    );
    northwardENU = Cartesian3.normalize(northwardENU, northwardENU);
    expect(
      Cartesian3.equalsEpsilon(
        northwardENU,
        Cartesian3.UNIT_Y,
        CesiumMath.EPSILON7
      )
    ).toBe(true);
  });

  it("provides attributes for computing planes in 2D and Columbus View", function () {
    var planes2D_HIGH = largeRectangleAttributes.planes2D_HIGH;
    var planes2D_LOW = largeRectangleAttributes.planes2D_LOW;

    expect(planes2D_HIGH.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(planes2D_HIGH.componentsPerAttribute).toEqual(4);
    expect(planes2D_HIGH.normalize).toEqual(false);

    // Because using a unit sphere expect all HIGH values to be basically 0
    var highValue = planes2D_HIGH.value;
    expect(highValue[0]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[1]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[3]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);

    expect(planes2D_LOW.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(planes2D_LOW.componentsPerAttribute).toEqual(4);
    expect(planes2D_LOW.normalize).toEqual(false);

    var cartographic = Cartographic.fromDegrees(-45, -45, 0.0); // southwest corner
    var southwestCartesian = projection.project(cartographic);
    var lowValue = planes2D_LOW.value;
    expect(lowValue[0]).toEqualEpsilon(
      southwestCartesian.x,
      CesiumMath.EPSILON7
    );
    expect(lowValue[1]).toEqualEpsilon(
      southwestCartesian.y,
      CesiumMath.EPSILON7
    );
    expect(lowValue[2]).toEqualEpsilon(
      -southwestCartesian.y,
      CesiumMath.EPSILON7
    );
    expect(lowValue[3]).toEqualEpsilon(
      -southwestCartesian.x,
      CesiumMath.EPSILON7
    );

    // Small case
    // Because using a unit sphere expect all HIGH values to be basically 0
    highValue = smallRectangleAttributes.planes2D_HIGH.value;
    expect(highValue[0]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[1]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);
    expect(highValue[3]).toEqualEpsilon(0.0, CesiumMath.EPSILON7);

    cartographic = Cartographic.fromDegrees(-0.1, -0.1, 0.0); // southwest corner
    southwestCartesian = projection.project(cartographic);
    lowValue = smallRectangleAttributes.planes2D_LOW.value;
    expect(lowValue[0]).toEqualEpsilon(
      southwestCartesian.x,
      CesiumMath.EPSILON7
    );
    expect(lowValue[1]).toEqualEpsilon(
      southwestCartesian.y,
      CesiumMath.EPSILON7
    );
    expect(lowValue[2]).toEqualEpsilon(
      -southwestCartesian.y,
      CesiumMath.EPSILON7
    );
    expect(lowValue[3]).toEqualEpsilon(
      -southwestCartesian.x,
      CesiumMath.EPSILON7
    );
  });

  it("provides attributes for rotating texture coordinates", function () {
    // 90 degree rotation of a square, so "max" in Y direction is (0,0), "max" in X direction is (1,1)
    var attributes = ShadowVolumeAppearance.getPlanarTextureCoordinateAttributes(
      smallTestRectangle,
      [1, 0, 0, 0, 1, 1],
      unitSphereEllipsoid,
      projection,
      0.0
    );

    var uMaxVmax = attributes.uMaxVmax;
    var uvMinAndExtents = attributes.uvMinAndExtents;
    expect(uMaxVmax.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(uMaxVmax.componentsPerAttribute).toEqual(4);
    expect(uMaxVmax.normalize).toEqual(false);

    expect(uvMinAndExtents.componentDatatype).toEqual(ComponentDatatype.FLOAT);
    expect(uvMinAndExtents.componentsPerAttribute).toEqual(4);
    expect(uvMinAndExtents.normalize).toEqual(false);

    var value = uMaxVmax.value;
    expect(value[0]).toEqual(0.0);
    expect(value[1]).toEqual(0.0);
    expect(value[2]).toEqual(1.0);
    expect(value[3]).toEqual(1.0);

    // "min" of texture coordinates is at (1,0) and extents are just 1s
    value = uvMinAndExtents.value;
    expect(value[0]).toEqual(1.0);
    expect(value[1]).toEqual(0.0);
    expect(value[2]).toEqual(1.0);
    expect(value[3]).toEqual(1.0);
  });

  it("checks for spherical extent attributes", function () {
    expect(
      ShadowVolumeAppearance.hasAttributesForSphericalExtents(
        smallRectangleAttributes
      )
    ).toBe(false);
    expect(
      ShadowVolumeAppearance.hasAttributesForSphericalExtents(
        largeRectangleAttributes
      )
    ).toBe(true);
  });

  it("checks for planar texture coordinate attributes", function () {
    expect(
      ShadowVolumeAppearance.hasAttributesForTextureCoordinatePlanes(
        smallRectangleAttributes
      )
    ).toBe(true);
    expect(
      ShadowVolumeAppearance.hasAttributesForTextureCoordinatePlanes(
        largeRectangleAttributes
      )
    ).toBe(false);
  });

  it("checks if a rectangle should use spherical texture coordinates", function () {
    expect(
      ShadowVolumeAppearance.shouldUseSphericalCoordinates(smallTestRectangle)
    ).toBe(false);
    expect(
      ShadowVolumeAppearance.shouldUseSphericalCoordinates(largeTestRectangle)
    ).toBe(true);
  });

  it("creates vertex shaders for color", function () {
    // Check defines
    var sphericalTexturedAppearance = new ShadowVolumeAppearance(
      true,
      false,
      textureMaterialAppearance
    );
    var shaderSource = sphericalTexturedAppearance.createVertexShader(
      [],
      testVs,
      false,
      projection
    );
    var defines = shaderSource.defines;
    expect(defines.length).toEqual(2);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("SPHERICAL")).not.toEqual(-1);

    // 2D variant
    shaderSource = sphericalTexturedAppearance.createVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(6);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("COLUMBUS_VIEW_2D")).not.toEqual(-1);

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    // Unculled color appearance - no texcoords at all
    var sphericalUnculledColorAppearance = new ShadowVolumeAppearance(
      false,
      false,
      perInstanceColorMaterialAppearance
    );
    shaderSource = sphericalUnculledColorAppearance.createVertexShader(
      [],
      testVs,
      false,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(1);
    expect(defines.indexOf("PER_INSTANCE_COLOR")).not.toEqual(-1);

    // 2D variant
    shaderSource = sphericalUnculledColorAppearance.createVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(5);

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    expect(defines.indexOf("PER_INSTANCE_COLOR")).not.toEqual(-1);

    // Planar textured, without culling
    var planarTexturedAppearance = new ShadowVolumeAppearance(
      false,
      true,
      textureMaterialAppearance
    );
    shaderSource = planarTexturedAppearance.createVertexShader(
      [],
      testVs,
      false,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.length).toEqual(1);

    shaderSource = planarTexturedAppearance.createVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("COLUMBUS_VIEW_2D")).not.toEqual(-1);

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    expect(defines.length).toEqual(6);
  });

  it("creates vertex shaders for pick", function () {
    // Check defines
    var sphericalTexturedAppearance = new ShadowVolumeAppearance(
      true,
      false,
      textureMaterialAppearance
    );
    var shaderSource = sphericalTexturedAppearance.createPickVertexShader(
      [],
      testVs,
      false,
      projection
    );
    var defines = shaderSource.defines;
    expect(defines.length).toEqual(2);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("SPHERICAL")).not.toEqual(-1);

    // 2D variant
    shaderSource = sphericalTexturedAppearance.createPickVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(6);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("COLUMBUS_VIEW_2D")).not.toEqual(-1);

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    // Unculled color appearance - no texcoords at all
    var sphericalUnculledColorAppearance = new ShadowVolumeAppearance(
      false,
      false,
      perInstanceColorMaterialAppearance
    );
    shaderSource = sphericalUnculledColorAppearance.createPickVertexShader(
      [],
      testVs,
      false,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(0);

    // 2D variant
    shaderSource = sphericalUnculledColorAppearance.createPickVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    expect(defines.length).toEqual(4);

    // Planar textured, without culling
    var planarTexturedAppearance = new ShadowVolumeAppearance(
      false,
      true,
      textureMaterialAppearance
    );
    shaderSource = planarTexturedAppearance.createPickVertexShader(
      [],
      testVs,
      false,
      projection
    );
    defines = shaderSource.defines;
    expect(defines.length).toEqual(0);

    shaderSource = planarTexturedAppearance.createPickVertexShader(
      [],
      testVs,
      true,
      projection
    );
    defines = shaderSource.defines;

    expect(defines.indexOf(eastMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(eastMostYlowDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYhighDefine)).not.toEqual(-1);
    expect(defines.indexOf(westMostYlowDefine)).not.toEqual(-1);

    expect(defines.length).toEqual(4);
  });

  it("creates fragment shaders for color and pick", function () {
    // Check defines
    var sphericalTexturedAppearance = new ShadowVolumeAppearance(
      true,
      false,
      textureMaterialAppearance
    );
    var shaderSource = sphericalTexturedAppearance.createFragmentShader(false);
    var defines = shaderSource.defines;

    // Check material hookups, discard for culling, and phong shading
    expect(defines.indexOf("SPHERICAL")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_EC")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_WC")).not.toEqual(-1);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("CULL_FRAGMENTS")).not.toEqual(-1);
    expect(defines.indexOf("NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_POSITION_TO_EYE_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_TANGENT_TO_EYE")).not.toEqual(-1);
    expect(defines.indexOf("USES_ST")).not.toEqual(-1);
    expect(defines.length).toEqual(10);

    // 2D case
    shaderSource = sphericalTexturedAppearance.createFragmentShader(true);
    defines = shaderSource.defines;

    expect(defines.indexOf("REQUIRES_EC")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_WC")).not.toEqual(-1);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("CULL_FRAGMENTS")).not.toEqual(-1);
    expect(defines.indexOf("NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_POSITION_TO_EYE_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_TANGENT_TO_EYE")).not.toEqual(-1);
    expect(defines.indexOf("USES_ST")).not.toEqual(-1);
    expect(defines.length).toEqual(9);

    // Culling with planar texture coordinates on a per-color material
    var planarColorAppearance = new ShadowVolumeAppearance(
      true,
      true,
      perInstanceColorMaterialAppearance
    );
    shaderSource = planarColorAppearance.createFragmentShader(false);
    defines = shaderSource.defines;

    expect(defines.indexOf("PER_INSTANCE_COLOR")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_EC")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_WC")).not.toEqual(-1);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("CULL_FRAGMENTS")).not.toEqual(-1);
    expect(defines.indexOf("NORMAL_EC")).not.toEqual(-1);
    expect(defines.length).toEqual(6);

    // Pick
    shaderSource = planarColorAppearance.createPickFragmentShader(true);
    defines = shaderSource.defines;

    expect(defines.indexOf("REQUIRES_EC")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_WC")).not.toEqual(-1);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("CULL_FRAGMENTS")).not.toEqual(-1);
    expect(defines.indexOf("PICK")).not.toEqual(-1);
    expect(defines.length).toEqual(5);

    // Flat
    var flatSphericalTexturedAppearance = new ShadowVolumeAppearance(
      true,
      false,
      flatTextureMaterialAppearance
    );
    shaderSource = flatSphericalTexturedAppearance.createFragmentShader(false);
    defines = shaderSource.defines;
    expect(defines.indexOf("SPHERICAL")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_EC")).not.toEqual(-1);
    expect(defines.indexOf("REQUIRES_WC")).not.toEqual(-1);
    expect(defines.indexOf("TEXTURE_COORDINATES")).not.toEqual(-1);
    expect(defines.indexOf("CULL_FRAGMENTS")).not.toEqual(-1);
    expect(defines.indexOf("NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_NORMAL_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_POSITION_TO_EYE_EC")).not.toEqual(-1);
    expect(defines.indexOf("USES_ST")).not.toEqual(-1);
    expect(defines.indexOf("FLAT")).not.toEqual(-1);
    expect(defines.length).toEqual(10);

    var flatSphericalColorAppearance = new ShadowVolumeAppearance(
      false,
      false,
      flatPerInstanceColorMaterialAppearance
    );
    shaderSource = flatSphericalColorAppearance.createFragmentShader(false);
    defines = shaderSource.defines;
    expect(defines.indexOf("SPHERICAL")).not.toEqual(-1);
    expect(defines.indexOf("PER_INSTANCE_COLOR")).not.toEqual(-1);
    expect(defines.indexOf("FLAT")).not.toEqual(-1);
    expect(defines.length).toEqual(3);
  });
});