X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Renderer.cpp;h=240d1a0699a846e95a700f2dd4f5ab4d1d0626bc;hb=72d3e464f0fdaaf6db6206873408e8d845f02cd4;hp=8bf503551bd80a77797e8e8da62c124e180245b6;hpb=ad06250b0131a81ad28ae63c7e063f3d291d3060;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp
index 8bf5035..240d1a0 100644
--- a/automated-tests/src/dali/utc-Dali-Renderer.cpp
+++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,11 @@
  */
 
 // EXTERNAL INCLUDES
+#include <dali/devel-api/actors/actor-devel.h>
+
 #include <dali/public-api/dali-core.h>
 #include <dali/devel-api/images/texture-set-image.h>
+#include <dali/devel-api/object/handle-devel.h>
 #include <cstdio>
 #include <string>
 
@@ -36,8 +39,8 @@ const BlendFactor::Type   DEFAULT_BLEND_FACTOR_DEST_RGB(   BlendFactor::ONE_MINU
 const BlendFactor::Type   DEFAULT_BLEND_FACTOR_SRC_ALPHA(  BlendFactor::ONE );
 const BlendFactor::Type   DEFAULT_BLEND_FACTOR_DEST_ALPHA( BlendFactor::ONE_MINUS_SRC_ALPHA );
 
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(   BlendEquation::ADD );
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA( BlendEquation::ADD );
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(      BlendEquation::ADD );
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA(    BlendEquation::ADD );
 
 /**
  * @brief Get GL stencil test enumeration value as a string.
@@ -50,6 +53,17 @@ std::string GetStencilTestString(void)
   return stream.str();
 }
 
+/**
+ * @brief Get GL depth test enumeration value as a string.
+ * @return The string representation of the value of GL_DEPTH_TEST
+ */
+std::string GetDepthTestString(void)
+{
+  std::stringstream stream;
+  stream << GL_DEPTH_TEST;
+  return stream.str();
+}
+
 void ResetDebugAndFlush( TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack )
 {
   glEnableDisableStack.Reset();
@@ -737,7 +751,7 @@ int UtcDaliRendererSetBlendMode06(void)
   tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled");
 
   Geometry geometry = CreateQuadGeometry();
-  Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_TRANSPARENT );
+  Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT );
 
   Renderer renderer = Renderer::New( geometry, shader );
 
@@ -980,15 +994,15 @@ int UtcDaliRendererConstraint01(void)
   application.Render(0);
 
   // Expect no blue component in either buffer - yellow
-  DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
+  DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( renderer, colorIndex ), Color::YELLOW, TEST_LOCATION );
   application.Render(0);
-  DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
+  DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( renderer, colorIndex ), Color::YELLOW, TEST_LOCATION );
 
   renderer.RemoveConstraints();
   renderer.SetProperty(colorIndex, Color::WHITE );
   application.SendNotification();
   application.Render(0);
-  DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( renderer, colorIndex ), Color::WHITE, TEST_LOCATION );
 
   END_TEST;
 }
@@ -1047,8 +1061,6 @@ int UtcDaliRendererConstraint02(void)
   END_TEST;
 }
 
-
-
 int UtcDaliRendererAnimatedProperty01(void)
 {
   TestApplication application;
@@ -1081,11 +1093,11 @@ int UtcDaliRendererAnimatedProperty01(void)
   application.SendNotification();
   application.Render(500);
 
-  DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION );
+  DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( renderer, colorIndex ), Color::WHITE * 0.5f, TEST_LOCATION );
 
   application.Render(500);
 
-  DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION );
+  DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( renderer, colorIndex ), Color::TRANSPARENT, TEST_LOCATION );
 
   END_TEST;
 }
@@ -1392,6 +1404,32 @@ int UtcDaliRendererUniformMapMultipleUniforms02(void)
 }
 
 
+Renderer CreateRenderer( Actor actor, Geometry geometry, Shader shader, int depthIndex )
+{
+  Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 );
+  TextureSet textureSet0 = CreateTextureSet( image0 );
+  Renderer renderer0 = Renderer::New( geometry, shader );
+  renderer0.SetTextures( textureSet0 );
+  renderer0.SetProperty( Renderer::Property::DEPTH_INDEX, depthIndex );
+  actor.AddRenderer(renderer0);
+  return renderer0;
+}
+
+
+Actor CreateActor( Actor parent, int siblingOrder, const char* location )
+{
+  Actor actor0 = Actor::New();
+  actor0.SetAnchorPoint(AnchorPoint::CENTER);
+  actor0.SetParentOrigin(AnchorPoint::CENTER);
+  actor0.SetPosition(0.0f,0.0f);
+  actor0.SetSize(100, 100);
+  actor0.SetProperty( Dali::DevelActor::Property::SIBLING_ORDER, siblingOrder );
+  DALI_TEST_EQUALS( actor0.GetProperty<int>( Dali::DevelActor::Property::SIBLING_ORDER), siblingOrder, TEST_INNER_LOCATION(location) );
+  parent.Add(actor0);
+
+  return actor0;
+}
+
 int UtcDaliRendererRenderOrder2DLayer(void)
 {
   TestApplication application;
@@ -1400,59 +1438,20 @@ int UtcDaliRendererRenderOrder2DLayer(void)
   Shader shader = Shader::New("VertexSource", "FragmentSource");
   Geometry geometry = CreateQuadGeometry();
 
-  Actor actor0 = Actor::New();
-  actor0.SetAnchorPoint(AnchorPoint::CENTER);
-  actor0.SetParentOrigin(AnchorPoint::CENTER);
-  actor0.SetPosition(0.0f,0.0f);
-  Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet0 = CreateTextureSet( image0 );
-  Renderer renderer0 = Renderer::New( geometry, shader );
-  renderer0.SetTextures( textureSet0 );
-  actor0.AddRenderer(renderer0);
-  actor0.SetSize(1, 1);
-  Stage::GetCurrent().Add(actor0);
-  application.SendNotification();
-  application.Render(0);
+  Actor root = Stage::GetCurrent().GetRootLayer();
 
-  Actor actor1 = Actor::New();
-  actor1.SetAnchorPoint(AnchorPoint::CENTER);
-  actor1.SetParentOrigin(AnchorPoint::CENTER);
-  actor1.SetPosition(0.0f,0.0f);
-  Image image1= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet1 = CreateTextureSet( image1 );
-  Renderer renderer1 = Renderer::New( geometry, shader );
-  renderer1.SetTextures( textureSet1 );
-  actor1.AddRenderer(renderer1);
-  actor1.SetSize(1, 1);
-  Stage::GetCurrent().Add(actor1);
-  application.SendNotification();
-  application.Render(0);
+  Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 0 );
 
-  Actor actor2 = Actor::New();
-  actor2.SetAnchorPoint(AnchorPoint::CENTER);
-  actor2.SetParentOrigin(AnchorPoint::CENTER);
-  actor2.SetPosition(0.0f,0.0f);
-  Image image2= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet2 = CreateTextureSet( image2 );
-  Renderer renderer2 = Renderer::New( geometry, shader );
-  renderer2.SetTextures( textureSet2 );
-  actor2.AddRenderer(renderer2);
-  actor2.SetSize(1, 1);
-  Stage::GetCurrent().Add(actor2);
-  application.SendNotification();
-  application.Render(0);
+  Actor actor1 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer1 = CreateRenderer( actor1, geometry, shader, 0 );
+
+  Actor actor2 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer2 = CreateRenderer( actor2, geometry, shader, 0 );
+
+  Actor actor3 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer3 = CreateRenderer( actor3, geometry, shader, 0 );
 
-  Actor actor3 = Actor::New();
-  actor3.SetAnchorPoint(AnchorPoint::CENTER);
-  actor3.SetParentOrigin(AnchorPoint::CENTER);
-  actor3.SetPosition(0.0f,0.0f);
-  Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet3 = CreateTextureSet( image3 );
-  Renderer renderer3 = Renderer::New( geometry, shader );
-  renderer3.SetTextures( textureSet3 );
-  actor3.AddRenderer(renderer3);
-  actor3.SetSize(1, 1);
-  Stage::GetCurrent().Add(actor3);
   application.SendNotification();
   application.Render(0);
 
@@ -1531,81 +1530,20 @@ int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void)
   Shader shader = Shader::New("VertexSource", "FragmentSource");
   Geometry geometry = CreateQuadGeometry();
 
-  Actor actor0 = Actor::New();
-  actor0.SetAnchorPoint(AnchorPoint::CENTER);
-  actor0.SetParentOrigin(AnchorPoint::CENTER);
-  actor0.SetPosition(0.0f,0.0f);
-  actor0.SetSize(1, 1);
-  Stage::GetCurrent().Add(actor0);
+  Actor root = Stage::GetCurrent().GetRootLayer();
 
-  Actor actor1 = Actor::New();
-  actor1.SetAnchorPoint(AnchorPoint::CENTER);
-  actor1.SetParentOrigin(AnchorPoint::CENTER);
-  actor1.SetPosition(0.0f,0.0f);
-  actor1.SetSize(1, 1);
-  actor0.Add(actor1);
+  Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
+  Actor actor1 = CreateActor( actor0, 0, TEST_LOCATION );
+  Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 );
+  Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 );
+  Renderer renderer2 = CreateRenderer( actor0, geometry, shader, 1 );
+  Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 );
+  Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 0 );
+  Renderer renderer5 = CreateRenderer( actor1, geometry, shader, -1 );
 
-  //Renderer0
-  Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet0 = CreateTextureSet( image0 );
-  Renderer renderer0 = Renderer::New( geometry, shader );
-  renderer0.SetTextures( textureSet0 );
-  renderer0.SetProperty( Renderer::Property::DEPTH_INDEX, 2 );
-  actor0.AddRenderer(renderer0);
   application.SendNotification();
   application.Render(0);
 
-  //Renderer1
-  Image image1= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet1 = CreateTextureSet( image1 );
-  Renderer renderer1 = Renderer::New( geometry, shader );
-  renderer1.SetTextures( textureSet1 );
-  renderer1.SetProperty( Renderer::Property::DEPTH_INDEX, 0 );
-  actor0.AddRenderer(renderer1);
-  application.SendNotification();
-  application.Render(0);
-
-  //Renderer2
-  Image image2= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet2 = CreateTextureSet( image2 );
-  Renderer renderer2 = Renderer::New( geometry, shader );
-  renderer2.SetTextures( textureSet2 );
-  renderer2.SetProperty( Renderer::Property::DEPTH_INDEX, 1 );
-  actor0.AddRenderer(renderer2);
-  application.SendNotification();
-  application.Render(0);
-
-  //Renderer3
-  Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet3 = CreateTextureSet( image3 );
-  Renderer renderer3 = Renderer::New( geometry, shader );
-  renderer3.SetTextures( textureSet3 );
-  renderer3.SetProperty( Renderer::Property::DEPTH_INDEX, 1 );
-  actor1.AddRenderer(renderer3);
-  application.SendNotification();
-  application.Render(0);
-
-  //Renderer4
-  Image image4= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet4 = CreateTextureSet( image4 );
-  Renderer renderer4 = Renderer::New( geometry, shader );
-  renderer4.SetTextures( textureSet4 );
-  renderer4.SetProperty( Renderer::Property::DEPTH_INDEX, 0 );
-  actor1.AddRenderer(renderer4);
-  application.SendNotification();
-  application.Render(0);
-
-  //Renderer5
-  Image image5= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet5 = CreateTextureSet( image5 );
-  Renderer renderer5 = Renderer::New( geometry, shader );
-  renderer5.SetTextures( textureSet5 );
-  renderer5.SetProperty( Renderer::Property::DEPTH_INDEX, -1 );
-  actor1.AddRenderer(renderer5);
-  application.SendNotification();
-  application.Render(0);
-
-
   TestGlAbstraction& gl = application.GetGlAbstraction();
   gl.EnableTextureCallTrace(true);
   application.SendNotification();
@@ -1637,87 +1575,118 @@ int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void)
   END_TEST;
 }
 
-int UtcDaliRendererRenderOrder2DLayerOverlay(void)
+
+int UtcDaliRendererRenderOrder2DLayerSiblingOrder(void)
 {
   TestApplication application;
-  tet_infoline("Test the rendering order in a 2D layer is correct for overlays");
+  tet_infoline("Test the rendering order in a 2D layer is correct using sibling order");
+
+  /*
+   * Creates the following hierarchy:
+   *
+   *                            Layer
+   *                           /    \
+   *                         /        \
+   *                       /            \
+   *                     /                \
+   *                   /                    \
+   *             actor0 (SIBLING_ORDER:1)     actor1 (SIBLING_ORDER:0)
+   *            /   |   \                    /   |   \
+   *          /     |     \                /     |     \
+   *        /       |       \            /       |       \
+   * renderer0 renderer1  actor2     renderer2 renderer3 renderer4
+   *    DI:2      DI:0      |           DI:0      DI:1      DI:2
+   *                        |
+   *                   renderer5
+   *                      DI:-1
+   *
+   *  actor0 has sibling order 1
+   *  actor1 has sibling order 0
+   *  actor2 has sibling order 0
+   *
+   *  renderer0 has depth index 2
+   *  renderer1 has depth index 0
+   *
+   *  renderer2 has depth index 0
+   *  renderer3 has depth index 1
+   *  renderer4 has depth index 2
+   *
+   *  renderer5 has depth index -1
+   *
+   *  Expected rendering order: renderer2 - renderer3 - renderer4 - renderer1 - renderer0 - renderer5
+   */
 
   Shader shader = Shader::New("VertexSource", "FragmentSource");
   Geometry geometry = CreateQuadGeometry();
+  Actor root = Stage::GetCurrent().GetRootLayer();
+  Actor actor0 = CreateActor( root,   1, TEST_LOCATION );
+  Actor actor1 = CreateActor( root,   0, TEST_LOCATION );
+  Actor actor2 = CreateActor( actor0, 0, TEST_LOCATION );
 
-  Actor actor0 = Actor::New();
-  actor0.SetAnchorPoint(AnchorPoint::CENTER);
-  actor0.SetParentOrigin(AnchorPoint::CENTER);
-  Image image0 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet0 = CreateTextureSet( image0 );
-  Renderer renderer0 = Renderer::New( geometry, shader );
-  renderer0.SetTextures( textureSet0 );
-  actor0.AddRenderer(renderer0);
-  actor0.SetPosition(0.0f,0.0f);
-  actor0.SetSize(100, 100);
-  Stage::GetCurrent().Add(actor0);
-  actor0.SetDrawMode( DrawMode::OVERLAY_2D );
-  application.SendNotification();
-  application.Render(0);
+  Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 );
+  Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 );
+  Renderer renderer2 = CreateRenderer( actor1, geometry, shader, 0 );
+  Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 );
+  Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 2 );
+  Renderer renderer5 = CreateRenderer( actor2, geometry, shader, -1 );
 
-  Actor actor1 = Actor::New();
-  actor1.SetAnchorPoint(AnchorPoint::CENTER);
-  actor1.SetParentOrigin(AnchorPoint::CENTER);
-  Image image1= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet1 = CreateTextureSet( image1 );
-  Renderer renderer1 = Renderer::New( geometry, shader );
-  renderer1.SetTextures( textureSet1 );
-  actor1.SetPosition(0.0f,0.0f);
-  actor1.AddRenderer(renderer1);
-  actor1.SetSize(100, 100);
-  Stage::GetCurrent().Add(actor1);
-  actor1.SetDrawMode( DrawMode::OVERLAY_2D );
   application.SendNotification();
-  application.Render(0);
+  application.Render();
 
-  Actor actor2 = Actor::New();
-  actor2.SetAnchorPoint(AnchorPoint::CENTER);
-  actor2.SetParentOrigin(AnchorPoint::CENTER);
-  Image image2= BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet2 = CreateTextureSet( image2 );
-  Renderer renderer2 = Renderer::New( geometry, shader );
-  renderer2.SetTextures( textureSet2 );
-  actor2.AddRenderer(renderer2);
-  actor2.SetPosition(0.0f,0.0f);
-  actor2.SetSize(100, 100);
-  Stage::GetCurrent().Add(actor2);
+  TestGlAbstraction& gl = application.GetGlAbstraction();
+  gl.EnableTextureCallTrace(true);
   application.SendNotification();
   application.Render(0);
 
-  Actor actor3 = Actor::New();
-  actor3.SetAnchorPoint(AnchorPoint::CENTER);
-  actor3.SetParentOrigin(AnchorPoint::CENTER);
-  Image image3 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet3 = CreateTextureSet( image3 );
-  Renderer renderer3 = Renderer::New( geometry, shader );
-  renderer3.SetTextures( textureSet3 );
-  actor3.SetPosition(0.0f,0.0f);
-  actor3.AddRenderer(renderer3);
-  actor3.SetSize(100, 100);
-  Stage::GetCurrent().Add(actor3);
-  actor3.SetDrawMode( DrawMode::OVERLAY_2D );
-  application.SendNotification();
-  application.Render(0);
+  int textureBindIndex[6];
+  for( unsigned int i(0); i<6; ++i )
+  {
+    std::stringstream params;
+    params << GL_TEXTURE_2D<<", "<<i+1;
+    textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+  }
+
+  DALI_TEST_EQUALS( textureBindIndex[2], 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[3], 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[4], 2, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[1], 3, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[0], 4, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[5], 5, TEST_LOCATION );
+
+  // Change sibling order of actor1
+  // New Expected rendering order: renderer1 - renderer0 - renderer 5 - renderer2 - renderer3 - renderer4
+  actor1.SetProperty( Dali::DevelActor::Property::SIBLING_ORDER, 2 );
 
-  Actor actor4 = Actor::New();
-  actor4.SetAnchorPoint(AnchorPoint::CENTER);
-  actor4.SetParentOrigin(AnchorPoint::CENTER);
-  Image image4 = BufferImage::New( 64, 64, Pixel::RGB888 );
-  TextureSet textureSet4 = CreateTextureSet( image4 );
-  Renderer renderer4 = Renderer::New( geometry, shader );
-  renderer4.SetTextures( textureSet4 );
-  actor4.AddRenderer(renderer4);
-  actor4.SetPosition(0.0f,0.0f);
-  actor4.SetSize(100, 100);
-  Stage::GetCurrent().Add(actor4);
+  gl.GetTextureTrace().Reset();
   application.SendNotification();
   application.Render(0);
 
+  for( unsigned int i(0); i<6; ++i )
+  {
+    std::stringstream params;
+    params << GL_TEXTURE_2D<<", "<<i+1;
+    textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+  }
+
+  DALI_TEST_EQUALS( textureBindIndex[1], 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[0], 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[5], 2, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[2], 3, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[3], 4, TEST_LOCATION );
+  DALI_TEST_EQUALS( textureBindIndex[4], 5, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliRendererRenderOrder2DLayerOverlay(void)
+{
+  TestApplication application;
+  tet_infoline("Test the rendering order in a 2D layer is correct for overlays");
+
+  Shader shader = Shader::New("VertexSource", "FragmentSource");
+  Geometry geometry = CreateQuadGeometry();
+  Actor root = Stage::GetCurrent().GetRootLayer();
+
   /*
    * Create the following hierarchy:
    *
@@ -1738,13 +1707,32 @@ int UtcDaliRendererRenderOrder2DLayerOverlay(void)
    *
    *  Expected rendering order : actor2 - actor4 - actor1 - actor0 - actor3
    */
-  Stage::GetCurrent().Add( actor2 );
+
+  Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
+  actor0.SetDrawMode( DrawMode::OVERLAY_2D );
+  Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 0 );
+
+  Actor actor1 = CreateActor( root, 0, TEST_LOCATION );
+  actor1.SetDrawMode( DrawMode::OVERLAY_2D );
+  Renderer renderer1 = CreateRenderer( actor1, geometry, shader, 0 );
+
+  Actor actor2 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer2 = CreateRenderer( actor2, geometry, shader, 0 );
+
+  Actor actor3 = CreateActor( root, 0, TEST_LOCATION );
+  actor3.SetDrawMode( DrawMode::OVERLAY_2D );
+  Renderer renderer3 = CreateRenderer( actor3, geometry, shader, 0 );
+
+  Actor actor4 = CreateActor( root, 0, TEST_LOCATION );
+  Renderer renderer4 = CreateRenderer( actor4, geometry, shader, 0 );
+
+  application.SendNotification();
+  application.Render(0);
+
   actor2.Add(actor1);
   actor2.Add(actor4);
   actor1.Add(actor0);
   actor0.Add(actor3);
-  application.SendNotification();
-  application.Render(0);
 
   TestGlAbstraction& gl = application.GetGlAbstraction();
   gl.EnableTextureCallTrace(true);
@@ -1802,7 +1790,7 @@ int UtcDaliRendererSetIndexRange(void)
 
   // create geometry
   Geometry geometry = Geometry::New();
-  geometry.SetGeometryType( Geometry::LINE_LOOP );
+  geometry.SetType( Geometry::LINE_LOOP );
 
   // --------------------------------------------------------------------------
   // index buffer
@@ -1867,7 +1855,7 @@ int UtcDaliRendererSetIndexRange(void)
   // LINE_STRIP, first 15, count 6
   {
     renderer.SetIndexRange( 15, 6 );
-    geometry.SetGeometryType( Geometry::LINE_STRIP );
+    geometry.SetType( Geometry::LINE_STRIP );
     sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
     application.SendNotification();
     application.Render();
@@ -1878,7 +1866,7 @@ int UtcDaliRendererSetIndexRange(void)
   // Index out of bounds
   {
     renderer.SetIndexRange( 15, 30 );
-    geometry.SetGeometryType( Geometry::LINE_STRIP );
+    geometry.SetType( Geometry::LINE_STRIP );
     sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
     application.SendNotification();
     application.Render();
@@ -1889,7 +1877,7 @@ int UtcDaliRendererSetIndexRange(void)
   // drawing whole buffer starting from 15 ( last valid primitive )
   {
     renderer.SetIndexRange( 15, 0 );
-    geometry.SetGeometryType( Geometry::LINE_STRIP );
+    geometry.SetType( Geometry::LINE_STRIP );
     sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
     application.SendNotification();
     application.Render();
@@ -2037,7 +2025,63 @@ int UtcDaliRendererSetDepthFunction(void)
   END_TEST;
 }
 
-Renderer StencilTestFixture( TestApplication& application )
+/**
+ * @brief This templatized function checks an enumeration property is setting and getting correctly.
+ * The checks performed are as follows:
+ *  - Check the initial/default value.
+ *  - Set a different value via enum.
+ *  - Check it was set.
+ *  - Set a different value via string.
+ *  - Check it was set.
+ */
+template< typename T >
+void CheckEnumerationProperty( Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString )
+{
+  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( initialValue ) );
+  DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< int >( renderer, propertyIndex ) == static_cast<int>( initialValue ) );
+  renderer.SetProperty( propertyIndex, firstCheckEnumeration );
+  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
+  DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< int >( renderer, propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
+  renderer.SetProperty( propertyIndex, secondCheckString );
+  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
+  DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< int >( renderer, propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
+}
+
+int UtcDaliRendererEnumProperties(void)
+{
+  TestApplication application;
+  tet_infoline( "Test Renderer enumeration properties can be set with both integer and string values" );
+
+  Geometry geometry = CreateQuadGeometry();
+  Shader shader = CreateShader();
+  Renderer renderer = Renderer::New( geometry, shader );
+
+  /*
+   * Here we use a templatized function to perform several checks on each enumeration property.
+   * @see CheckEnumerationProperty for details of the checks performed.
+   */
+
+  CheckEnumerationProperty< FaceCullingMode::Type >( renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK" );
+  CheckEnumerationProperty< BlendMode::Type >( renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON" );
+  CheckEnumerationProperty< BlendEquation::Type >( renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
+  CheckEnumerationProperty< BlendEquation::Type >( renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
+  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
+  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
+  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR" );
+  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
+  CheckEnumerationProperty< DepthWriteMode::Type >( renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON" );
+  CheckEnumerationProperty< DepthFunction::Type >( renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER" );
+  CheckEnumerationProperty< DepthTestMode::Type >( renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON" );
+  CheckEnumerationProperty< StencilFunction::Type >( renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL" );
+  CheckEnumerationProperty< RenderMode::Type >( renderer, Renderer::Property::RENDER_MODE, RenderMode::AUTO, RenderMode::NONE, RenderMode::STENCIL, "STENCIL" );
+  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
+  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
+  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
+
+  END_TEST;
+}
+
+Renderer RendererTestFixture( TestApplication& application )
 {
   Geometry geometry = CreateQuadGeometry();
   Shader shader = CreateShader();
@@ -2053,12 +2097,123 @@ Renderer StencilTestFixture( TestApplication& application )
   return renderer;
 }
 
+int UtcDaliRendererSetDepthTestMode(void)
+{
+  TestApplication application;
+  tet_infoline("Test setting the DepthTestMode");
+
+  Renderer renderer = RendererTestFixture( application );
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  glAbstraction.EnableEnableDisableCallTrace( true );
+  TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+
+  glEnableDisableStack.Reset();
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-test is enabled by default.
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
+  DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+
+  // Turn off depth-testing. We want to check if the depth buffer has been disabled, so we need to turn off depth-write as well for this case.
+  renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF );
+  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
+
+  glEnableDisableStack.Reset();
+  application.SendNotification();
+  application.Render();
+
+  // Check the depth buffer was disabled.
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+
+  // Turn on automatic mode depth-testing.
+  // Layer behavior is currently set to LAYER_3D so AUTO should enable depth-testing.
+  renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO );
+
+  glEnableDisableStack.Reset();
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-test is now enabled.
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
+  DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+
+  // Change the layer behavior to LAYER_2D.
+  // Note this will also disable depth testing for the layer by default, we test this first.
+  Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_2D );
+
+  glEnableDisableStack.Reset();
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-test is disabled.
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+
+  // Turn the layer depth-test flag back on, and confirm that depth testing is now on.
+  Stage::GetCurrent().GetRootLayer().SetDepthTestDisabled( false );
+
+  glEnableDisableStack.Reset();
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-test is *still* disabled.
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
+
+  END_TEST;
+}
+
+int UtcDaliRendererSetDepthWriteMode(void)
+{
+  TestApplication application;
+  tet_infoline("Test setting the DepthWriteMode");
+
+  Renderer renderer = RendererTestFixture( application );
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+
+  application.SendNotification();
+  application.Render();
+
+  // Check the default depth-write status first.
+  DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
+
+  // Turn off depth-writing.
+  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
+
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-write is now disabled.
+  DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
+
+  // Test the AUTO mode for depth-writing.
+  // As our renderer is opaque, depth-testing should be enabled.
+  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO );
+
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-write is now enabled.
+  DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
+
+  // Now make the renderer be treated as translucent by enabling blending.
+  // The AUTO depth-write mode should turn depth-write off in this scenario.
+  renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+
+  application.SendNotification();
+  application.Render();
+
+  // Check depth-write is now disabled.
+  DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
+
+  END_TEST;
+}
+
 int UtcDaliRendererCheckStencilDefaults(void)
 {
   TestApplication application;
   tet_infoline("Test the stencil defaults");
 
-  Renderer renderer = StencilTestFixture( application );
+  Renderer renderer = RendererTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2079,31 +2234,51 @@ int UtcDaliRendererCheckStencilDefaults(void)
   END_TEST;
 }
 
-int UtcDaliRendererSetStencilMode(void)
+int UtcDaliRendererSetRenderModeToUseStencilBuffer(void)
 {
   TestApplication application;
-  tet_infoline("Test setting the StencilMode");
+  tet_infoline("Test setting the RenderMode to use the stencil buffer");
 
-  Renderer renderer = StencilTestFixture( application );
+  Renderer renderer = RendererTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
   TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
   TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
 
+  // Set the StencilFunction to something other than the default, to confirm it is set as a property,
+  // but NO GL call has been made while the RenderMode is set to not use the stencil buffer.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::NONE );
   ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
 
-  // Set the StencilFunction to something other than the default, to confirm it is set as a property,
-  // but NO GL call has been made while the StencilMode is set to OFF.
   renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::NEVER );
   DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get<int>() ), static_cast<int>( StencilFunction::NEVER ), TEST_LOCATION );
-  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
 
+  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
   std::string methodString( "StencilFunc" );
   DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
 
-  // Now set the StencilMode to ON and check the StencilFunction has changed.
-  renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
+  // Test the other RenderModes that will not enable the stencil buffer.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::AUTO );
+  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+  DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
+
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+  DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
+
+  // Now set the RenderMode to modes that will use the stencil buffer, and check the StencilFunction has changed.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
+  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+
+  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) );
+  DALI_TEST_CHECK( glStencilFunctionStack.FindMethod( methodString ) );
+
+  // Test the COLOR_STENCIL RenderMode as it also enables the stencil buffer.
+  // First set a mode to turn off the stencil buffer, so the enable is required.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+  ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL );
   ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
 
   DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) );
@@ -2112,20 +2287,56 @@ int UtcDaliRendererSetStencilMode(void)
   END_TEST;
 }
 
+// Helper function for the SetRenderModeToUseColorBuffer test.
+void CheckRenderModeColorMask( TestApplication& application, Renderer& renderer, RenderMode::Type renderMode, bool expectedValue )
+{
+  // Set the RenderMode property to a value that should not allow color buffer writes.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, renderMode );
+  application.SendNotification();
+  application.Render();
+
+  // Check if ColorMask has been called, and that the values are correct.
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  const TestGlAbstraction::ColorMaskParams& colorMaskParams( glAbstraction.GetColorMaskParams() );
+
+  DALI_TEST_EQUALS<bool>( colorMaskParams.red,   expectedValue, TEST_LOCATION );
+  DALI_TEST_EQUALS<bool>( colorMaskParams.green, expectedValue, TEST_LOCATION );
+  DALI_TEST_EQUALS<bool>( colorMaskParams.blue,  expectedValue, TEST_LOCATION );
+  DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, expectedValue, TEST_LOCATION );
+}
+
+int UtcDaliRendererSetRenderModeToUseColorBuffer(void)
+{
+  TestApplication application;
+  tet_infoline("Test setting the RenderMode to use the color buffer");
+
+  Renderer renderer = RendererTestFixture( application );
+
+  // Set the RenderMode property to a value that should not allow color buffer writes.
+  // Then check if ColorMask has been called, and that the values are correct.
+  CheckRenderModeColorMask( application, renderer, RenderMode::AUTO, true );
+  CheckRenderModeColorMask( application, renderer, RenderMode::NONE, false );
+  CheckRenderModeColorMask( application, renderer, RenderMode::COLOR, true );
+  CheckRenderModeColorMask( application, renderer, RenderMode::STENCIL, false );
+  CheckRenderModeColorMask( application, renderer, RenderMode::COLOR_STENCIL, true );
+
+  END_TEST;
+}
+
 int UtcDaliRendererSetStencilFunction(void)
 {
   TestApplication application;
   tet_infoline("Test setting the StencilFunction");
 
-  Renderer renderer = StencilTestFixture( application );
+  Renderer renderer = RendererTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
   TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
   TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
 
-  // StencilMode must be ON for StencilFunction to operate.
-  renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
+  // RenderMode must use the stencil for StencilFunction to operate.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
   ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
 
   /*
@@ -2207,15 +2418,15 @@ int UtcDaliRendererSetStencilOperation(void)
   TestApplication application;
   tet_infoline("Test setting the StencilOperation");
 
-  Renderer renderer = StencilTestFixture( application );
+  Renderer renderer = RendererTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
   TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
   TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
 
-  // StencilMode must be ON for StencilOperation to operate.
-  renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
+  // RenderMode must use the stencil for StencilOperation to operate.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
 
   /*
    * Lookup table for testing StencilOperation.
@@ -2294,15 +2505,15 @@ int UtcDaliRendererSetStencilMask(void)
   TestApplication application;
   tet_infoline("Test setting the StencilMask");
 
-  Renderer renderer = StencilTestFixture( application );
+  Renderer renderer = RendererTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
   TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
   TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
 
-  // StencilMode must be ON for StencilMask to operate.
-  renderer.SetProperty( Renderer::Property::STENCIL_MODE, StencilMode::ON );
+  // RenderMode must use the stencil for StencilMask to operate.
+  renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
 
   // Set the StencilMask property to a value.
   renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0x00 );
@@ -2334,47 +2545,52 @@ int UtcDaliRendererSetStencilMask(void)
   END_TEST;
 }
 
-int UtcDaliRendererSetWriteToColorBuffer(void)
+int UtcDaliRendererWrongNumberOfTextures(void)
 {
   TestApplication application;
-  tet_infoline("Test setting the WriteToColorBuffer flag");
-
-  Renderer renderer = StencilTestFixture( application );
-  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  tet_infoline("Test renderer does render even if number of textures is different than active samplers in the shader");
+
+  //Create a TextureSet with 4 textures (One more texture in the texture set than active samplers)
+  //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
+  Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64u, 64u );
+  TextureSet textureSet = CreateTextureSet();
+  textureSet.SetTexture(0, texture );
+  textureSet.SetTexture(1, texture );
+  textureSet.SetTexture(2, texture );
+  textureSet.SetTexture(3, texture );
+  Shader shader = Shader::New("VertexSource", "FragmentSource");
+  Geometry geometry = CreateQuadGeometry();
+  Renderer renderer = Renderer::New( geometry, shader );
+  renderer.SetTextures( textureSet );
 
-  // Set the StencilMask property to a value.
-  renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, false );
+  Actor actor= Actor::New();
+  actor.AddRenderer(renderer);
+  actor.SetPosition(0.0f,0.0f);
+  actor.SetSize(100, 100);
+  Stage::GetCurrent().Add(actor);
 
-  // Check GetProperty returns the same value.
-  DALI_TEST_CHECK( !renderer.GetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER ).Get<bool>() );
+  TestGlAbstraction& gl = application.GetGlAbstraction();
+  TraceCallStack& drawTrace = gl.GetDrawTrace();
+  drawTrace.Reset();
+  drawTrace.Enable(true);
 
   application.SendNotification();
-  application.Render();
-
-  // Check if ColorMask has been called, and that the values are correct.
-  const TestGlAbstraction::ColorMaskParams& colorMaskParams( glAbstraction.GetColorMaskParams() );
-
-  DALI_TEST_EQUALS<bool>( colorMaskParams.red,   false, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParams.green, false, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParams.blue,  false, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, false, TEST_LOCATION );
+  application.Render(0);
 
-  // Set the StencilMask property to true.
-  renderer.SetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER, true );
-
-  // Check GetProperty returns the same value.
-  DALI_TEST_CHECK( renderer.GetProperty( Renderer::Property::WRITE_TO_COLOR_BUFFER ).Get<bool>() );
+  //Test we do the drawcall when TextureSet has more textures than there are active samplers in the shader
+  DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 
+  //Create a TextureSet with 1 texture (two more active samplers than texture in the texture set)
+  //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
+  textureSet = CreateTextureSet();
+  renderer.SetTextures( textureSet );
+  textureSet.SetTexture(0, texture );
+  drawTrace.Reset();
   application.SendNotification();
-  application.Render();
-
-  // Check if ColorMask has been called, and that the values are correct.
-  const TestGlAbstraction::ColorMaskParams& colorMaskParamsChanged( glAbstraction.GetColorMaskParams() );
+  application.Render(0);
 
-  DALI_TEST_EQUALS<bool>( colorMaskParamsChanged.red,   true, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParamsChanged.green, true, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParamsChanged.blue,  true, TEST_LOCATION );
-  DALI_TEST_EQUALS<bool>( colorMaskParamsChanged.alpha, true, TEST_LOCATION );
+  //Test we do the drawcall when TextureSet has less textures than there are active samplers in the shader.
+  DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 
   END_TEST;
 }