src/third_party/angle/tests/angle_implementation_unit_tests/ImageIndexIterator_unittest.cpp

   1 //
   2 // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 #include "gmock/gmock.h"
   8 #include "gtest/gtest.h"
   9 #include "libGLESv2/ImageIndex.h"
  10 #include "libGLESv2/Texture.h"
  11
  12 using namespace gl;
  13
  14 namespace
  15 {
  16
  17 static const GLint minMip = 0;
  18 static const GLint maxMip = 4;
  19 static const GLint minLayer = 1;
  20 static const GLint maxLayer = 3;
  21
  22 TEST(ImageIndexTest, Iterator2D)
  23 {
  24     ImageIndexIterator iter = ImageIndexIterator::Make2D(minMip, maxMip);
  25
  26     ASSERT_GE(0, minMip);
  27
  28     for (GLint mip = minMip; mip < maxMip; mip++)
  29     {
  30         EXPECT_TRUE(iter.hasNext());
  31         ImageIndex current = iter.current();
  32         ImageIndex nextIndex = iter.next();
  33
  34         EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), nextIndex.type);
  35         EXPECT_EQ(mip, nextIndex.mipIndex);
  36         EXPECT_FALSE(nextIndex.hasLayer());
  37
  38         // Also test current
  39         EXPECT_EQ(current.type, nextIndex.type);
  40         EXPECT_EQ(current.mipIndex, nextIndex.mipIndex);
  41         EXPECT_EQ(current.layerIndex, nextIndex.layerIndex);
  42     }
  43 }
  44
  45 TEST(ImageIndexTest, IteratorCube)
  46 {
  47     ImageIndexIterator iter = ImageIndexIterator::MakeCube(0, 4);
  48
  49     ASSERT_GE(0, minMip);
  50
  51     for (GLint mip = minMip; mip < maxMip; mip++)
  52     {
  53         for (GLint layer = 0; layer < 6; layer++)
  54         {
  55             EXPECT_TRUE(iter.hasNext());
  56             ImageIndex nextIndex = iter.next();
  57
  58             GLenum cubeTarget = TextureCubeMap::layerIndexToTarget(layer);
  59
  60             EXPECT_EQ(cubeTarget, nextIndex.type);
  61             EXPECT_EQ(mip, nextIndex.mipIndex);
  62             EXPECT_EQ(layer, nextIndex.layerIndex);
  63             EXPECT_TRUE(nextIndex.hasLayer());
  64         }
  65     }
  66 }
  67
  68 TEST(ImageIndexTest, Iterator3D)
  69 {
  70     ImageIndexIterator iter = ImageIndexIterator::Make3D(minMip, maxMip, minLayer, maxLayer);
  71
  72     ASSERT_GE(0, minMip);
  73
  74     for (GLint mip = minMip; mip < maxMip; mip++)
  75     {
  76         for (GLint layer = minLayer; layer < maxLayer; layer++)
  77         {
  78             EXPECT_TRUE(iter.hasNext());
  79             ImageIndex nextIndex = iter.next();
  80
  81             EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_3D), nextIndex.type);
  82             EXPECT_EQ(mip, nextIndex.mipIndex);
  83             EXPECT_EQ(layer, nextIndex.layerIndex);
  84             EXPECT_TRUE(nextIndex.hasLayer());
  85         }
  86     }
  87 }
  88
  89 TEST(ImageIndexTest, Iterator2DArray)
  90 {
  91     GLsizei layerCounts[] = { 1, 3, 5, 2 };
  92
  93     ImageIndexIterator iter = ImageIndexIterator::Make2DArray(minMip, maxMip, layerCounts);
  94
  95     ASSERT_GE(0, minMip);
  96     ASSERT_EQ(ArraySize(layerCounts), static_cast<size_t>(maxMip));
  97
  98     for (GLint mip = minMip; mip < maxMip; mip++)
  99     {
 100         for (GLint layer = 0; layer < layerCounts[mip]; layer++)
 101         {
 102             EXPECT_TRUE(iter.hasNext());
 103             ImageIndex nextIndex = iter.next();
 104
 105             EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D_ARRAY), nextIndex.type);
 106             EXPECT_EQ(mip, nextIndex.mipIndex);
 107             EXPECT_EQ(layer, nextIndex.layerIndex);
 108             EXPECT_TRUE(nextIndex.hasLayer());
 109         }
 110     }
 111 }
 112
 113 } // namespace