Rewrite ConfigSet and make EGLConfig synonymous with egl::Config.

src/libANGLE/AttributeMap.cpp

@@ -40,4 +40,14 @@ EGLint AttributeMap::get(EGLint key, EGLint defaultValue) const
     return (mAttributes.find(key) != mAttributes.end()) ? iter->second : defaultValue;
 }
 
+AttributeMap::const_iterator AttributeMap::begin() const
+{
+    return mAttributes.begin();
+}
+
+AttributeMap::const_iterator AttributeMap::end() const
+{
+    return mAttributes.end();
+}
+
 }

src/libANGLE/AttributeMap.h

@@ -25,6 +25,11 @@ class AttributeMap
     virtual bool contains(EGLint key) const;
     virtual EGLint get(EGLint key, EGLint defaultValue) const;
 
+    typedef std::map<EGLint, EGLint>::const_iterator const_iterator;
+
+    const_iterator begin() const;
+    const_iterator end() const;
+
   private:
     std::map<EGLint, EGLint> mAttributes;
 };

src/libANGLE/Config.h

@@ -6,7 +6,7 @@
 
 // Config.h: Defines the egl::Config class, describing the format, type
 // and size for an egl::Surface. Implements EGLConfig and related functionality.
-// [EGL 1.4] section 3.4 page 15.
+// [EGL 1.5] section 3.4 page 19.
 
 #ifndef INCLUDE_CONFIG_H_
 #define INCLUDE_CONFIG_H_
@@ -17,7 +17,8 @@
 
 #include <EGL/egl.h>
 
-#include <set>
+#include <map>
+#include <vector>
 
 namespace egl
 {
@@ -26,13 +27,12 @@ class Display;
 class Config
 {
   public:
+    Config();
     Config(rx::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
 
-    EGLConfig getHandle() const;
-
-    const GLenum mRenderTargetFormat;
-    const GLenum mDepthStencilFormat;
-    const GLint mMultiSample;
+    GLenum mRenderTargetFormat;
+    GLenum mDepthStencilFormat;
+    GLint mMultiSample;
 
     EGLint mBufferSize;              // Depth of the color buffer
     EGLint mRedSize;                 // Bits of Red in the color buffer
@@ -69,45 +69,26 @@ class Config
     EGLint mTransparentBlueValue;    // Transparent blue value
 };
 
-// Function object used by STL sorting routines for ordering Configs according to [EGL] section 3.4.1 page 24.
-class SortConfig
+class ConfigSet
 {
   public:
-    explicit SortConfig(const EGLint *attribList);
-
-    bool operator()(const Config *x, const Config *y) const;
-    bool operator()(const Config &x, const Config &y) const;
+    EGLint add(const Config &config);
+    const Config &get(EGLint id) const;
 
-  private:
-    void scanForWantedComponents(const EGLint *attribList);
-    EGLint wantedComponentsSize(const Config &config) const;
-
-    bool mWantRed;
-    bool mWantGreen;
-    bool mWantBlue;
-    bool mWantAlpha;
-    bool mWantLuminance;
-};
+    void clear();
 
-class ConfigSet
-{
-    friend Display;
+    size_t size() const;
 
-  public:
-    ConfigSet();
+    bool contains(const Config *config) const;
 
-    void add(rx::ConfigDesc desc, EGLint minSwapInterval, EGLint maxSwapInterval, EGLint texWidth, EGLint texHeight);
-    size_t size() const;
-    bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
-    const egl::Config *get(EGLConfig configHandle);
+    // Filter configurations based on the table in [EGL 1.5] section 3.4.1.2 page 29
+    std::vector<const Config*> filter(const AttributeMap &attributeMap) const;
 
   private:
-    typedef std::set<Config, SortConfig> Set;
-    typedef Set::iterator Iterator;
-    Set mSet;
-
-    static const EGLint mSortAttribs[];
+    typedef std::map<EGLint, const Config> ConfigMap;
+    ConfigMap mConfigs;
 };
+
 }
 
 #endif   // INCLUDE_CONFIG_H_

src/libANGLE/Display.cpp

@@ -147,19 +147,7 @@ Error Display::initialize()
 
     mCaps = mImplementation->getCaps();
 
-    ConfigSet configSet = mImplementation->generateConfigs();
-
-    // Give the sorted configs a unique ID and store them internally
-    EGLint index = 1;
-    for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++)
-    {
-        Config configuration = *config;
-        configuration.mConfigID = index;
-        index++;
-
-        mConfigSet.mSet.insert(configuration);
-    }
-
+    mConfigSet = mImplementation->generateConfigs();
     if (mConfigSet.size() == 0)
     {
         mImplementation->terminate();
@@ -180,21 +168,19 @@ void Display::terminate()
         destroyContext(*mContextSet.begin());
     }
 
-    mConfigSet.mSet.clear();
+    mConfigSet.clear();
 
     mImplementation->terminate();
     mInitialized = false;
 }
 
-bool Display::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig)
+std::vector<const Config*> Display::getConfigs(const egl::AttributeMap &attribs) const
 {
-    return mConfigSet.getConfigs(configs, attribList, configSize, numConfig);
+    return mConfigSet.filter(attribs);
 }
 
-bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
+bool Display::getConfigAttrib(const Config *configuration, EGLint attribute, EGLint *value)
 {
-    const egl::Config *configuration = mConfigSet.get(config);
-
     switch (attribute)
     {
       case EGL_BUFFER_SIZE:               *value = configuration->mBufferSize;             break;
@@ -236,11 +222,8 @@ bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
     return true;
 }
 
-
-
-Error Display::createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList, EGLSurface *outSurface)
+Error Display::createWindowSurface(EGLNativeWindowType window, const Config *configuration, const EGLint *attribList, EGLSurface *outSurface)
 {
-    const Config *configuration = mConfigSet.get(config);
     EGLint postSubBufferSupported = EGL_FALSE;
 
     EGLint width = 0;
@@ -331,13 +314,12 @@ Error Display::createWindowSurface(EGLNativeWindowType window, EGLConfig config,
     return Error(EGL_SUCCESS);
 }
 
-Error Display::createOffscreenSurface(EGLConfig config, EGLClientBuffer shareHandle,
+Error Display::createOffscreenSurface(const Config *configuration, EGLClientBuffer shareHandle,
                                       const EGLint *attribList, EGLSurface *outSurface)
 {
     EGLint width = 0, height = 0;
     EGLenum textureFormat = EGL_NO_TEXTURE;
     EGLenum textureTarget = EGL_NO_TEXTURE;
-    const Config *configuration = mConfigSet.get(config);
 
     if (attribList)
     {
@@ -452,7 +434,7 @@ Error Display::createOffscreenSurface(EGLConfig config, EGLClientBuffer shareHan
     return Error(EGL_SUCCESS);
 }
 
-Error Display::createContext(EGLConfig configHandle, EGLContext shareContext, const egl::AttributeMap &attribs,
+Error Display::createContext(const Config *configuration, EGLContext shareContext, const egl::AttributeMap &attribs,
                              EGLContext *outContext)
 {
     ASSERT(isInitialized());
@@ -466,7 +448,6 @@ Error Display::createContext(EGLConfig configHandle, EGLContext shareContext, co
         }
     }
 
-    const Config *configuration = mConfigSet.get(configHandle);
     if (attribs.get(EGL_CONTEXT_CLIENT_VERSION, 1) == 3 && !(configuration->mConformant & EGL_OPENGL_ES3_BIT_KHR))
     {
         return Error(EGL_BAD_CONFIG);
@@ -542,22 +523,22 @@ bool Display::isInitialized() const
     return mInitialized;
 }
 
-bool Display::isValidConfig(EGLConfig config)
+bool Display::isValidConfig(const Config *config) const
 {
-    return mConfigSet.get(config) != NULL;
+    return mConfigSet.contains(config);
 }
 
-bool Display::isValidContext(gl::Context *context)
+bool Display::isValidContext(gl::Context *context) const
 {
     return mContextSet.find(context) != mContextSet.end();
 }
 
-bool Display::isValidSurface(Surface *surface)
+bool Display::isValidSurface(Surface *surface) const
 {
     return mImplementation->getSurfaceSet().find(surface) != mImplementation->getSurfaceSet().end();
 }
 
-bool Display::hasExistingWindowSurface(EGLNativeWindowType window)
+bool Display::hasExistingWindowSurface(EGLNativeWindowType window) const
 {
     for (const auto &surfaceIt : mImplementation->getSurfaceSet())
     {

src/libANGLE/Display.h

@@ -45,21 +45,21 @@ class Display final
     static const ClientExtensions &getClientExtensions();
     static const std::string &getClientExtensionString();
 
-    bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
-    bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
+    std::vector<const Config*> getConfigs(const egl::AttributeMap &attribs) const;
+    bool getConfigAttrib(const Config *configuration, EGLint attribute, EGLint *value);
 
-    Error createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList, EGLSurface *outSurface);
-    Error createOffscreenSurface(EGLConfig config, EGLClientBuffer shareHandle, const EGLint *attribList, EGLSurface *outSurface);
-    Error createContext(EGLConfig configHandle, EGLContext shareContext, const egl::AttributeMap &attribs, EGLContext *outContext);
+    Error createWindowSurface(EGLNativeWindowType window, const Config *configuration, const EGLint *attribList, EGLSurface *outSurface);
+    Error createOffscreenSurface(const Config *configuration, EGLClientBuffer shareHandle, const EGLint *attribList, EGLSurface *outSurface);
+    Error createContext(const Config *configuration, EGLContext shareContext, const egl::AttributeMap &attribs, EGLContext *outContext);
 
     void destroySurface(egl::Surface *surface);
     void destroyContext(gl::Context *context);
 
     bool isInitialized() const;
-    bool isValidConfig(EGLConfig config);
-    bool isValidContext(gl::Context *context);
-    bool isValidSurface(egl::Surface *surface);
-    bool hasExistingWindowSurface(EGLNativeWindowType window);
+    bool isValidConfig(const Config *config) const;
+    bool isValidContext(gl::Context *context) const;
+    bool isValidSurface(egl::Surface *surface) const;
+    bool hasExistingWindowSurface(EGLNativeWindowType window) const;
     bool isValidNativeWindow(EGLNativeWindowType window) const;
     bool isValidNativeDisplay(EGLNativeDisplayType display) const;
 

src/libANGLE/renderer/d3d/DisplayD3D.cpp

@@ -174,7 +174,7 @@ egl::ConfigSet DisplayD3D::generateConfigs() const
     egl::ConfigSet configSet;
     for (size_t i = 0; i < descList.size(); ++i)
     {
-        configSet.add(descList[i], minSwapInterval, maxSwapInterval, maxTextureSize, maxTextureSize);
+        configSet.add(egl::Config(descList[i], minSwapInterval, maxSwapInterval, maxTextureSize, maxTextureSize));
     }
 
     return configSet;

src/libGLESv2/entry_points_egl.cpp

@@ -26,7 +26,7 @@ namespace egl
 {
 
 // EGL object validation
-static bool ValidateDisplay(Display *display)
+static bool ValidateDisplay(const Display *display)
 {
     if (display == EGL_NO_DISPLAY)
     {
@@ -43,7 +43,7 @@ static bool ValidateDisplay(Display *display)
     return true;
 }
 
-static bool ValidateConfig(Display *display, EGLConfig config)
+static bool ValidateConfig(const Display *display, const Config *config)
 {
     if (!ValidateDisplay(display))
     {
@@ -59,7 +59,7 @@ static bool ValidateConfig(Display *display, EGLConfig config)
     return true;
 }
 
-static bool ValidateContext(Display *display, gl::Context *context)
+static bool ValidateContext(const Display *display, gl::Context *context)
 {
     if (!ValidateDisplay(display))
     {
@@ -220,13 +220,16 @@ EGLBoolean EGLAPIENTRY GetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint con
         return EGL_FALSE;
     }
 
-    const EGLint attribList[] =    {EGL_NONE};
-
-    if (!display->getConfigs(configs, attribList, config_size, num_config))
+    std::vector<const Config*> filteredConfigs = display->getConfigs(AttributeMap());
+    if (configs)
     {
-        SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
-        return EGL_FALSE;
+        filteredConfigs.resize(std::min<size_t>(filteredConfigs.size(), config_size));
+        for (size_t i = 0; i < filteredConfigs.size(); i++)
+        {
+            configs[i] = const_cast<Config*>(filteredConfigs[i]);
+        }
     }
+    *num_config = filteredConfigs.size();
 
     SetGlobalError(Error(EGL_SUCCESS));
     return EGL_TRUE;
@@ -251,14 +254,16 @@ EGLBoolean EGLAPIENTRY ChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, E
         return EGL_FALSE;
     }
 
-    const EGLint attribList[] =    {EGL_NONE};
-
-    if (!attrib_list)
+    std::vector<const Config*> filteredConfigs = display->getConfigs(AttributeMap(attrib_list));
+    if (configs)
     {
-        attrib_list = attribList;
+        filteredConfigs.resize(std::min<size_t>(filteredConfigs.size(), config_size));
+        for (size_t i = 0; i < filteredConfigs.size(); i++)
+        {
+            configs[i] = const_cast<Config*>(filteredConfigs[i]);
+        }
     }
-
-    display->getConfigs(configs, attrib_list, config_size, num_config);
+    *num_config = filteredConfigs.size();
 
     SetGlobalError(Error(EGL_SUCCESS));
     return EGL_TRUE;
@@ -270,13 +275,14 @@ EGLBoolean EGLAPIENTRY GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint
           dpy, config, attribute, value);
 
     Display *display = static_cast<Display*>(dpy);
+    Config *configuration = static_cast<Config*>(config);
 
-    if (!ValidateConfig(display, config))
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_FALSE;
     }
 
-    if (!display->getConfigAttrib(config, attribute, value))
+    if (!display->getConfigAttrib(configuration, attribute, value))
     {
         SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
         return EGL_FALSE;
@@ -292,8 +298,9 @@ EGLSurface EGLAPIENTRY CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGL
           "const EGLint *attrib_list = 0x%0.8p)", dpy, config, win, attrib_list);
 
     Display *display = static_cast<Display*>(dpy);
+    Config *configuration = static_cast<Config*>(config);
 
-    if (!ValidateConfig(display, config))
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_NO_SURFACE;
     }
@@ -305,7 +312,7 @@ EGLSurface EGLAPIENTRY CreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGL
     }
 
     EGLSurface surface = EGL_NO_SURFACE;
-    Error error = display->createWindowSurface(win, config, attrib_list, &surface);
+    Error error = display->createWindowSurface(win, configuration, attrib_list, &surface);
     if (error.isError())
     {
         SetGlobalError(error);
@@ -321,14 +328,15 @@ EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, co
           dpy, config, attrib_list);
 
     Display *display = static_cast<Display*>(dpy);
+    Config *configuration = static_cast<Config*>(config);
 
-    if (!ValidateConfig(display, config))
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_NO_SURFACE;
     }
 
     EGLSurface surface = EGL_NO_SURFACE;
-    Error error = display->createOffscreenSurface(config, NULL, attrib_list, &surface);
+    Error error = display->createOffscreenSurface(configuration, NULL, attrib_list, &surface);
     if (error.isError())
     {
         SetGlobalError(error);
@@ -344,8 +352,9 @@ EGLSurface EGLAPIENTRY CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGL
           "const EGLint *attrib_list = 0x%0.8p)", dpy, config, pixmap, attrib_list);
 
     Display *display = static_cast<Display*>(dpy);
+    Config *configuration = static_cast<Config*>(config);
 
-    if (!ValidateConfig(display, config))
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_NO_SURFACE;
     }
@@ -608,13 +617,14 @@ EGLContext EGLAPIENTRY CreateContext(EGLDisplay dpy, EGLConfig config, EGLContex
         }
     }
 
-    if (!ValidateConfig(display, config))
+    Config *configuration = static_cast<Config*>(config);
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_NO_CONTEXT;
     }
 
     EGLContext context = EGL_NO_CONTEXT;
-    Error error = display->createContext(config, share_context, egl::AttributeMap(attrib_list), &context);
+    Error error = display->createContext(configuration, share_context, egl::AttributeMap(attrib_list), &context);
     if (error.isError())
     {
         SetGlobalError(error);
@@ -1031,7 +1041,8 @@ EGLSurface EGLAPIENTRY CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buf
 
     Display *display = static_cast<Display*>(dpy);
 
-    if (!ValidateConfig(display, config))
+    Config *configuration = static_cast<Config*>(config);
+    if (!ValidateConfig(display, configuration))
     {
         return EGL_NO_SURFACE;
     }
@@ -1043,7 +1054,7 @@ EGLSurface EGLAPIENTRY CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buf
     }
 
     EGLSurface surface = EGL_NO_SURFACE;
-    Error error = display->createOffscreenSurface(config, buffer, attrib_list, &surface);
+    Error error = display->createOffscreenSurface(configuration, buffer, attrib_list, &surface);
     if (error.isError())
     {
         SetGlobalError(error);

tests/angle_implementation_unit_tests/Config_unittest.cpp

+//
+// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "libANGLE/AttributeMap.h"
+#include "libANGLE/Config.h"
+
+// Create a generic, valid EGL config that can be modified to test sorting and
+// filtering routines
+static egl::Config GenerateGenericConfig()
+{
+    egl::Config config;
+
+    config.mBufferSize = 24;
+    config.mRedSize = 8;
+    config.mGreenSize = 8;
+    config.mBlueSize = 8;
+    config.mLuminanceSize = 0;
+    config.mAlphaSize = 8;
+    config.mAlphaMaskSize = 0;
+    config.mBindToTextureRGB = EGL_TRUE;
+    config.mBindToTextureRGBA = EGL_TRUE;
+    config.mColorBufferType = EGL_RGB_BUFFER;
+    config.mConfigCaveat = EGL_NONE;
+    config.mConfigID = 0;
+    config.mConformant = EGL_OPENGL_ES2_BIT;
+    config.mDepthSize = 24;
+    config.mLevel = 0;
+    config.mMatchNativePixmap = EGL_NONE;
+    config.mMaxPBufferWidth = 1024;
+    config.mMaxPBufferHeight = 1024;
+    config.mMaxPBufferPixels = config.mMaxPBufferWidth * config.mMaxPBufferWidth;
+    config.mMaxSwapInterval = 0;
+    config.mMinSwapInterval = 4;
+    config.mNativeRenderable = EGL_OPENGL_ES2_BIT;
+    config.mNativeVisualID = 0;
+    config.mNativeVisualType = 0;
+    config.mRenderableType = EGL_FALSE;
+    config.mSampleBuffers = 0;
+    config.mSamples = 0;
+    config.mStencilSize = 8;
+    config.mSurfaceType = EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
+    config.mTransparentType = EGL_NONE;
+    config.mTransparentRedValue = 0;
+    config.mTransparentGreenValue = 0;
+    config.mTransparentBlueValue = 0;
+
+    return config;
+}
+
+static std::vector<egl::Config> GenerateUniqueConfigs(size_t count)
+{
+    std::vector<egl::Config> configs;
+
+    for (size_t i = 0; i < count; i++)
+    {
+        egl::Config config = GenerateGenericConfig();
+        config.mSamples = i;
+        configs.push_back(config);
+    }
+
+    return configs;
+}
+
+// Add unique configs to a ConfigSet and expect that the size of the
+// set is equal to the number of configs added.
+TEST(ConfigSetTest, Size)
+{
+    egl::ConfigSet set;
+
+    std::vector<egl::Config> uniqueConfigs = GenerateUniqueConfigs(16);
+    for (size_t i = 0; i < uniqueConfigs.size(); i++)
+    {
+        set.add(uniqueConfigs[i]);
+        EXPECT_EQ(set.size(), i + 1);
+    }
+}
+
+// [EGL 1.5] section 3.4:
+// EGL_CONFIG_ID is a unique integer identifying different EGLConfigs. Configuration IDs
+// must be small positive integers starting at 1 and ID assignment should be compact;
+// that is, if there are N EGLConfigs defined by the EGL implementation, their
+// configuration IDs should be in the range [1, N].
+TEST(ConfigSetTest, IDs)
+{
+    egl::ConfigSet set;
+
+    std::set<EGLint> ids;
+
+    std::vector<egl::Config> uniqueConfigs = GenerateUniqueConfigs(16);
+    for (size_t i = 0; i < uniqueConfigs.size(); i++)
+    {
+        EGLint id = set.add(uniqueConfigs[i]);
+
+        // Check that the config that was inserted has the ID that was returned
+        // by ConfigSet::add
+        EXPECT_EQ(id, set.get(id).mConfigID);
+
+        ids.insert(id);
+    }
+
+    // Verify configCount unique IDs
+    EXPECT_EQ(ids.size(), set.size());
+
+    // Check that there are no gaps and the IDs are in the range [1, N].
+    EXPECT_EQ(*std::min_element(ids.begin(), ids.end()), 1);
+    EXPECT_EQ(*std::max_element(ids.begin(), ids.end()), set.size());
+}
+
+TEST(ConfigSetTest, Filtering_BitSizes)
+{
+    egl::ConfigSet set;
+
+    struct VariableConfigBitSize
+    {
+        EGLint Name;
+        EGLint(egl::Config::*ConfigMember);
+    };
+
+    VariableConfigBitSize testMembers[] =
+    {
+        { EGL_RED_SIZE,     &egl::Config::mRedSize     },
+        { EGL_GREEN_SIZE,   &egl::Config::mGreenSize   },
+        { EGL_BLUE_SIZE,    &egl::Config::mBlueSize    },
+        { EGL_ALPHA_SIZE,   &egl::Config::mAlphaSize   },
+        { EGL_DEPTH_SIZE,   &egl::Config::mDepthSize   },
+        { EGL_STENCIL_SIZE, &egl::Config::mStencilSize },
+    };
+
+    // Generate configsPerType configs with varying bit sizes of each type
+    size_t configsPerType = 4;
+    for (size_t i = 0; i < ArraySize(testMembers); i++)
+    {
+        for (size_t j = 0; j < configsPerType; j++)
+        {
+            egl::Config config = GenerateGenericConfig();
+
+            // Set all the other tested members of this config to 0
+            for (size_t k = 0; k < ArraySize(testMembers); k++)
+            {
+                config.*(testMembers[k].ConfigMember) = 0;
+            }
+
+            // Set the tested member of this config to i so it ranges from
+            // [1, configsPerType]
+            config.*(testMembers[i].ConfigMember) = j + 1;
+
+            set.add(config);
+        }
+    }
+
+    // for each tested member, filter by it's type and verify that the correct number
+    // of results are returned
+    for (size_t i = 0; i < ArraySize(testMembers); i++)
+    {
+        // Start with a filter of 1 to not grab the other members
+        for (size_t j = 0; j < configsPerType; j++)
+        {
+            egl::AttributeMap filter;
+            filter.insert(testMembers[i].Name, j + 1);
+
+            std::vector<const egl::Config *> filteredConfigs = set.filter(filter);
+
+            EXPECT_EQ(filteredConfigs.size(), configsPerType - j);
+        }
+    }
+}
+
+// Verify the sorting, [EGL 1.5] section 3.4.1.2 pg 30:
+// [configs are sorted] by larger total number of color bits (for an RGB
+// color buffer this is the sum of EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE,
+// and EGL_ALPHA_SIZE; for a luminance color buffer, the sum of EGL_LUMINANCE_SIZE
+// and EGL_ALPHA_SIZE).If the requested number of bits in attrib list for a
+// particular color component is 0 or EGL_DONT_CARE, then the number of bits
+// for that component is not considered.
+TEST(ConfigSetTest, Sorting_BitSizes)
+{
+    egl::ConfigSet set;
+    size_t testConfigCount = 64;
+    for (size_t i = 0; i < testConfigCount; i++)
+    {
+        egl::Config config = GenerateGenericConfig();
+
+        // Give random-ish bit sizes to the config
+        config.mRedSize =   (i *  2) %  3;
+        config.mGreenSize = (i +  5) %  7;
+        config.mBlueSize =  (i +  7) % 11;
+        config.mAlphaSize = (i + 13) % 17;
+
+        set.add(config);
+    }
+
+    egl::AttributeMap greaterThan1BitFilter;
+    greaterThan1BitFilter.insert(EGL_RED_SIZE, 1);
+    greaterThan1BitFilter.insert(EGL_GREEN_SIZE, 1);
+    greaterThan1BitFilter.insert(EGL_BLUE_SIZE, 1);
+    greaterThan1BitFilter.insert(EGL_ALPHA_SIZE, 1);
+
+    std::vector<const egl::Config *> filteredConfigs = set.filter(greaterThan1BitFilter);
+    for (size_t i = 1; i < filteredConfigs.size(); i++)
+    {
+        const egl::Config &prevConfig = *filteredConfigs[i - 1];
+        size_t prevBitCount = prevConfig.mRedSize +
+                              prevConfig.mGreenSize +
+                              prevConfig.mBlueSize +
+                              prevConfig.mAlphaSize;
+
+        const egl::Config &curConfig = *filteredConfigs[i];
+        size_t curBitCount = curConfig.mRedSize +
+                             curConfig.mGreenSize +
+                             curConfig.mBlueSize +
+                             curConfig.mAlphaSize;
+
+        EXPECT_GE(prevBitCount, curBitCount);
+    }
+}

tests/angle_implementation_unit_tests/angle_implementation_unit_tests.gypi

@@ -5,6 +5,7 @@
 {
     'sources':
     [
+        'Config_unittest.cpp',
         'Fence_unittest.cpp',
         'ImageIndexIterator_unittest.cpp',
         'Surface_unittest.cpp',