Address issues with `openglsupport` test.

The existing test fails on several systems due to GL runtime version mismatches,
the use of deprecated features, and memory errors due to improper use of GLUT.
The test was modified to:

- Run within a display function, allowing proper GLUT cleanup.
- Generate dynamic shaders with a supported GLSL version string and output variables.
- Report shader compilation errors.
- Check GL context version before launching version-specific tests.

Note that most of the existing `OpenGLSupport` module and tests rely on deprecated
features (e.g. fixed-function pipeline). The test was modified to allow it to
pass on various systems. We might want to consider removing the module or re-writing
it entirely to support modern OpenGL.  This is beyond the scope of this patch.

Testing of legacy GL (for platforms that support it) can be enabled by defining
`EIGEN_LEGACY_OPENGL`.  Otherwise, the test will try to create a modern context.

Tested on
- MacBook Air (2019), macOS Catalina 10.15.7 (OpenGL 2.1, 4.1)
- Debian 10.6, NVidia Quadro K1200 (OpenGL 3.1, 3.3)

1 files changed, 451 insertions, 184 deletions

diff --git a/unsupported/test/openglsupport.cpp b/unsupported/test/openglsupport.cpp
index eadd7f985..1c4438134 100644
--- a/unsupported/test/openglsupport.cpp
+++ b/unsupported/test/openglsupport.cpp
@@ -9,15 +9,24 @@
 
 #include <main.h>
 #include <iostream>
+#include <string>
+
+#if defined(__APPLE_CC__)
+  // Prevent deprecation warnings caused by GLEW on MacOS.
+  #define GL_SILENCE_DEPRECATION 1
+#endif
 #include <GL/glew.h>
 #include <Eigen/OpenGLSupport>
-#include <GL/glut.h>
-using namespace Eigen;
-
-
+#if defined(__APPLE_CC__)
+  #include <GLUT/glut.h>
+#else
+  #include <GL/freeglut.h>
+#endif
 
+using namespace Eigen;
 
 #define VERIFY_MATRIX(CODE,REF) { \
+    glMatrixMode(GL_MODELVIEW); \
     glLoadIdentity(); \
     CODE; \
     Matrix<float,4,4,ColMajor> m; m.setZero(); \
@@ -40,7 +49,7 @@ using namespace Eigen;
     } \
     VERIFY_IS_APPROX(value, data); \
   }
-  
+
 #define VERIFY_UNIFORMi(NAME,TYPE) { \
     TYPE value = TYPE::Random().eval().cast<float>().cast<TYPE::Scalar>(); \
     TYPE data; \
@@ -53,175 +62,324 @@ using namespace Eigen;
     } \
     VERIFY_IS_APPROX(value, data); \
   }
-  
-void printInfoLog(GLuint objectID)
+
+void printProgramInfoLog(GLuint objectID)
 {
     int infologLength, charsWritten;
     GLchar *infoLog;
-    glGetProgramiv(objectID,GL_INFO_LOG_LENGTH, &infologLength);
+    glGetProgramiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
     if(infologLength > 0)
     {
         infoLog = new GLchar[infologLength];
         glGetProgramInfoLog(objectID, infologLength, &charsWritten, infoLog);
-        if (charsWritten>0)
+        if (charsWritten > 0)
+          std::cerr << "Program info : \n" << infoLog << std::endl;
+        delete[] infoLog;
+    }
+}
+
+void printShaderInfoLog(GLuint objectID)
+{
+    int infologLength, charsWritten;
+    GLchar *infoLog;
+    glGetShaderiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
+    if(infologLength > 0)
+    {
+        infoLog = new GLchar[infologLength];
+        glGetShaderInfoLog(objectID, infologLength, &charsWritten, infoLog);
+        if (charsWritten > 0)
           std::cerr << "Shader info : \n" << infoLog << std::endl;
         delete[] infoLog;
     }
 }
 
-GLint createShader(const char* vtx, const char* frg)
+GLint createProgram(const char* vtx, const char* frg, bool print_errors = true)
 {
   GLint prg_id = glCreateProgram();
   GLint vtx_id = glCreateShader(GL_VERTEX_SHADER);
   GLint frg_id = glCreateShader(GL_FRAGMENT_SHADER);
   GLint ok;
-  
+
   glShaderSource(vtx_id, 1, &vtx, 0);
   glCompileShader(vtx_id);
-  glGetShaderiv(vtx_id,GL_COMPILE_STATUS,&ok);
+  glGetShaderiv(vtx_id, GL_COMPILE_STATUS, &ok);
   if(!ok)
   {
-    std::cerr << "vtx compilation failed\n";
+    if (print_errors)
+    {
+      std::cerr << "vtx compilation failed\n";
+      std::cerr << "Source:\n" << vtx << "\n";
+      printShaderInfoLog(vtx_id);
+    }
+    glDeleteShader(vtx_id);
+    return GL_ZERO;
   }
-  
+
   glShaderSource(frg_id, 1, &frg, 0);
   glCompileShader(frg_id);
-  glGetShaderiv(frg_id,GL_COMPILE_STATUS,&ok);
+  glGetShaderiv(frg_id, GL_COMPILE_STATUS, &ok);
   if(!ok)
   {
-    std::cerr << "frg compilation failed\n";
+    if (print_errors)
+    {
+      std::cerr << "frg compilation failed.\n";
+      std::cerr << "Source:\n" << frg << "\n";
+      printShaderInfoLog(frg_id);
+    }
+    glDeleteShader(vtx_id);
+    glDeleteShader(frg_id);
+    return GL_ZERO;
   }
-  
+
   glAttachShader(prg_id, vtx_id);
   glAttachShader(prg_id, frg_id);
   glLinkProgram(prg_id);
-  glGetProgramiv(prg_id,GL_LINK_STATUS,&ok);
+
+  // Delete shaders once linked.
+  glDeleteShader(vtx_id);
+  glDeleteShader(frg_id);
+  glGetProgramiv(prg_id, GL_LINK_STATUS, &ok);
   if(!ok)
   {
-    std::cerr << "linking failed\n";
+    if (print_errors)
+    {
+      std::cerr << "linking failed.\n";
+      printProgramInfoLog(prg_id);
+    }
+    glDeleteProgram(prg_id);
+    return GL_ZERO;
   }
-  printInfoLog(prg_id);
-  
+
   glUseProgram(prg_id);
   return prg_id;
 }
 
-EIGEN_DECLARE_TEST(openglsupport)
+GLint createProgram(const std::string& vtx, const std::string& frg, bool print_errors = true)
 {
-  int argc = 0;
-  glutInit(&argc, 0);
-  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
-  glutInitWindowPosition (0,0);
-  glutInitWindowSize(10, 10);
+  return createProgram(vtx.c_str(), frg.c_str(), print_errors);
+}
 
-  if(glutCreateWindow("Eigen") <= 0)
+std::string getGlslVersionString(int gl_major_version, int gl_minor_version)
+{
+  switch (gl_major_version)
   {
-    std::cerr << "Error: Unable to create GLUT Window.\n";
-    exit(1);
+    case 2:
+      switch (gl_minor_version)
+      {
+        case 0:
+          return "#version 110";
+        case 1:
+          return "#version 120";
+      }
+      break;
+    case 3:
+      switch (gl_minor_version)
+      {
+        case 0:
+          return "#version 130";
+        case 1:
+          return "#version 140";
+        case 2:
+          return "#version 150";
+        case 3:
+          return "#version 330";
+      }
+      break;
+    case 4:
+      switch (gl_minor_version)
+      {
+        case 0:
+          return "#version 400";
+        case 1:
+          return "#version 410";
+        case 2:
+          return "#version 420";
+        case 3:
+          return "#version 430";
+        case 4:
+          return "#version 440";
+        case 5:
+          return "#version 450";
+        case 6:
+          return "#version 460";
+      }
+      break;
   }
-  
-  glewExperimental = GL_TRUE;
-  if(glewInit() != GLEW_OK)
-  {
-    std::cerr << "Warning: Failed to initialize GLEW\n";
+  return "";
+}
+
+void find_and_replace(
+  std::string& str,
+  const std::string& find,
+  const std::string& replace)
+{
+  size_t loc = 0;
+  size_t flen = find.length();
+  size_t rlen = replace.length();
+  while ( (loc = str.find(find, loc)) != std::string::npos) {
+    str.replace(loc, flen, replace);
+    loc += rlen;
   }
+}
 
-  Vector3f v3f;
-  Matrix3f rot;
-  glBegin(GL_POINTS);
-  
-  glVertex(v3f);
-  glVertex(2*v3f+v3f);
-  glVertex(rot*v3f);
-  
-  glEnd();
-  
-  // 4x4 matrices
-  Matrix4f mf44; mf44.setRandom();
-  VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
-  VERIFY_MATRIX(glMultMatrix(mf44), mf44);
-  Matrix4d md44; md44.setRandom();
-  VERIFY_MATRIX(glLoadMatrix(md44), md44);
-  VERIFY_MATRIX(glMultMatrix(md44), md44);
-  
-  // Quaternion
-  Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random()));
-  VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
-  
-  Quaternionf qf(AngleAxisf(internal::random<double>(), Vector3f::Random()));
-  VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
-  
-  // 3D Transform
-  Transform<float,3,AffineCompact> acf3; acf3.matrix().setRandom();
-  VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
-  VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
-  
-  Transform<float,3,Affine> af3(acf3);
-  VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
-  VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
-  
-  Transform<float,3,Projective> pf3; pf3.matrix().setRandom();
-  VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
-  VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
-  
-  Transform<double,3,AffineCompact> acd3; acd3.matrix().setRandom();
-  VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
-  VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
-  
-  Transform<double,3,Affine> ad3(acd3);
-  VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
-  VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
-  
-  Transform<double,3,Projective> pd3; pd3.matrix().setRandom();
-  VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
-  VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
-  
-  // translations (2D and 3D)
-  {
-    Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 0;
-    VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
-    Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 0;
-    VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
-    
-    Vector3f vf3; vf3.setRandom();
-    VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
-    Vector3d vd3; vd3.setRandom();
-    VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
-    
-    Translation<float,3> tf3; tf3.vector().setRandom();
-    VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
-    
-    Translation<double,3> td3;  td3.vector().setRandom();
-    VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
+// Finds and replaces a set of substrings in a string.
+std::string format(
+  const std::string& str,
+  const std::vector<std::string>& find,
+  const std::vector<std::string>& replace)
+{
+  std::string out = str;
+  for (std::size_t i=0; i<find.size(); ++i) {
+    find_and_replace(out, find[i], replace[i]);
   }
-  
-  // scaling (2D and 3D)
+  return out;
+}
+
+// GLUT display function that runs test.  Must be run within the display loop
+// in order to properly destroy resources.
+void openglsupport_test_loop()
+{
+  // Get context info.
+  const GLubyte* gl_version_string = glGetString(GL_VERSION);
+  std::cerr << "GL version: " << gl_version_string << std::endl;
+  std::cerr << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
+  // Parse version from string since GL_MAJOR_VERSION is only supported in GL 3.0+.
+  // Version string guaranteed to be <major>.<minor><vender extension>.
+  GLint gl_major_version = gl_version_string[0] - '0';
+  GLint gl_minor_version = gl_version_string[2] - '0';
+  bool legacy_gl = gl_major_version < 3 || (gl_major_version == 3 && gl_minor_version < 2);
+
+  // Fixed-function pipeline removed in OpenGL 3.2.
+  if (legacy_gl)
   {
-    Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 1;
-    VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
-    Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 1;
-    VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
-    
-    Vector3f vf3; vf3.setRandom();
-    VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
-    Vector3d vd3; vd3.setRandom();
-    VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
-    
-    UniformScaling<float> usf(internal::random<float>());
-    VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
-    
-    UniformScaling<double> usd(internal::random<double>());
-    VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
+    // Draw a basic triangle.
+    Vector3f v3f;
+    Matrix3f rot;
+    glBegin(GL_POINTS);
+    {
+      glVertex(v3f);
+      glVertex(2*v3f+v3f);
+      glVertex(rot*v3f);
+    }
+    glEnd();
+
+    // 4x4 matrices
+    Matrix4f mf44; mf44.setRandom();
+    VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
+    VERIFY_MATRIX(glMultMatrix(mf44), mf44);
+    Matrix4d md44; md44.setRandom();
+    VERIFY_MATRIX(glLoadMatrix(md44), md44);
+    VERIFY_MATRIX(glMultMatrix(md44), md44);
+
+    // Quaternion
+    Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random()));
+    VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
+
+    Quaternionf qf(AngleAxisf(internal::random<double>(), Vector3f::Random()));
+    VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
+
+    // 3D Transform
+    Transform<float,3,AffineCompact> acf3; acf3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
+    VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
+
+    Transform<float,3,Affine> af3(acf3);
+    VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
+    VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
+
+    Transform<float,3,Projective> pf3; pf3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
+    VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
+
+    Transform<double,3,AffineCompact> acd3; acd3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
+    VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
+
+    Transform<double,3,Affine> ad3(acd3);
+    VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
+    VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
+
+    Transform<double,3,Projective> pd3; pd3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
+    VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
+
+    // translations (2D and 3D)
+    {
+      Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 0;
+      VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
+      Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 0;
+      VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
+
+      Vector3f vf3; vf3.setRandom();
+      VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
+      Vector3d vd3; vd3.setRandom();
+      VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
+
+      Translation<float,3> tf3; tf3.vector().setRandom();
+      VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
+
+      Translation<double,3> td3;  td3.vector().setRandom();
+      VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
+    }
+
+    // scaling (2D and 3D)
+    {
+      Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 1;
+      VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
+      Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 1;
+      VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
+
+      Vector3f vf3; vf3.setRandom();
+      VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
+      Vector3d vd3; vd3.setRandom();
+      VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
+
+      UniformScaling<float> usf(internal::random<float>());
+      VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
+
+      UniformScaling<double> usd(internal::random<double>());
+      VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
+    }
+  } else {
+    std::cerr << "Warning: fixed-function pipeline was not tested.\n";
+  }
+
+  // Dynamic shader substitution variables.
+  // Modern shaders require a version string, and newer runtimes fail to
+  // compile old GLSL versions. Thus, we dynamically set the GLSL version
+  // string based on runtime. Also, pre OpenGL 3.0, the output gl_FragColor was
+  // built-in. This was deprecated in OpenGL 3.0, requiring us to explicitly
+  // define the output variable.
+  std::vector<std::string> glsl_vars;
+  glsl_vars.push_back("${GLSL_VERSION}");
+  glsl_vars.push_back("${FRAG_OUTPUT_DECLARATION}");
+  glsl_vars.push_back("${FRAG_OUTPUT_VARIABLE}");
+
+  std::vector<std::string> glsl_vals;
+  glsl_vals.push_back(getGlslVersionString(gl_major_version, gl_minor_version));
+  if (gl_major_version >= 3) {
+    glsl_vals.push_back("out vec4 fragColor;");
+    glsl_vals.push_back("fragColor");
+  } else {
+    glsl_vals.push_back("");
+    glsl_vals.push_back("gl_FragColor");
   }
-  
+
   // uniform
   {
-    const char* vtx = "void main(void) { gl_Position = gl_Vertex; }\n";
-    
-    if(GLEW_VERSION_2_0)
+    // vertex shader.
+    std::string vtx = format(
+      "${GLSL_VERSION}\n"
+      "void main(void) {\n"
+      "  gl_Position = vec4(0,0,0,1);\n"
+      "}\n",
+      glsl_vars, glsl_vals);
+
+#ifdef GL_VERSION_2_0
+    if(GLEW_VERSION_2_0 && GL_VERSION_2_0)
     {
-      #ifdef GL_VERSION_2_0
-      const char* frg = ""
+      std::string frg = format(
+        "${GLSL_VERSION}\n"
         "uniform vec2 v2f;\n"
         "uniform vec3 v3f;\n"
         "uniform vec4 v4f;\n"
@@ -231,103 +389,212 @@ EIGEN_DECLARE_TEST(openglsupport)
         "uniform mat2 m2f;\n"
         "uniform mat3 m3f;\n"
         "uniform mat4 m4f;\n"
-        "void main(void) { gl_FragColor = vec4(v2f[0]+v3f[0]+v4f[0])+vec4(v2i[0]+v3i[0]+v4i[0])+vec4(m2f[0][0]+m3f[0][0]+m4f[0][0]); }\n";
-        
-      GLint prg_id = createShader(vtx,frg);
-      
-      VERIFY_UNIFORM(fv,v2f, Vector2f);
-      VERIFY_UNIFORM(fv,v3f, Vector3f);
-      VERIFY_UNIFORM(fv,v4f, Vector4f);
+        "${FRAG_OUTPUT_DECLARATION}\n"
+        "void main(void) { \n"
+        "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2f[0]+v3f[0]+v4f[0])+vec4(v2i[0]+v3i[0]+v4i[0])+vec4(m2f[0][0]+m3f[0][0]+m4f[0][0]);\n"
+        "}\n",
+        glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      VERIFY_UNIFORM(fv, v2f, Vector2f);
+      VERIFY_UNIFORM(fv, v3f, Vector3f);
+      VERIFY_UNIFORM(fv, v4f, Vector4f);
       VERIFY_UNIFORMi(v2i, Vector2i);
       VERIFY_UNIFORMi(v3i, Vector3i);
       VERIFY_UNIFORMi(v4i, Vector4i);
-      VERIFY_UNIFORM(fv,m2f, Matrix2f);
-      VERIFY_UNIFORM(fv,m3f, Matrix3f);
-      VERIFY_UNIFORM(fv,m4f, Matrix4f);
-      #endif
+      VERIFY_UNIFORM(fv, m2f, Matrix2f);
+      VERIFY_UNIFORM(fv, m3f, Matrix3f);
+      VERIFY_UNIFORM(fv, m4f, Matrix4f);
+      glDeleteProgram(prg_id);
     }
     else
-      std::cerr << "Warning: opengl 2.0 was not tested\n";
-    
-    if(GLEW_VERSION_2_1)
+#endif
+      std::cerr << "Warning: opengl 2.0 was not tested.\n";
+
+#ifdef GL_VERSION_2_1
+    if(GLEW_VERSION_2_1 && GL_VERSION_2_1 &&
+        (gl_major_version > 2 || (gl_major_version == 2 && gl_minor_version >= 1)))
     {
-      #ifdef GL_VERSION_2_1
-      const char* frg = "#version 120\n"
+      std::string frg = format(
+        "${GLSL_VERSION}\n"
         "uniform mat2x3 m23f;\n"
         "uniform mat3x2 m32f;\n"
         "uniform mat2x4 m24f;\n"
         "uniform mat4x2 m42f;\n"
         "uniform mat3x4 m34f;\n"
         "uniform mat4x3 m43f;\n"
-        "void main(void) { gl_FragColor = vec4(m23f[0][0]+m32f[0][0]+m24f[0][0]+m42f[0][0]+m34f[0][0]+m43f[0][0]); }\n";
-        
-      GLint prg_id = createShader(vtx,frg);
-      
+        "${FRAG_OUTPUT_DECLARATION}\n"
+        "void main(void) {\n"
+        "  ${FRAG_OUTPUT_VARIABLE} = vec4(m23f[0][0]+m32f[0][0]+m24f[0][0]+m42f[0][0]+m34f[0][0]+m43f[0][0]);\n"
+        "}\n",
+        glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
       typedef Matrix<float,2,3> Matrix23f;
       typedef Matrix<float,3,2> Matrix32f;
       typedef Matrix<float,2,4> Matrix24f;
       typedef Matrix<float,4,2> Matrix42f;
       typedef Matrix<float,3,4> Matrix34f;
       typedef Matrix<float,4,3> Matrix43f;
-      
-      VERIFY_UNIFORM(fv,m23f, Matrix23f);
-      VERIFY_UNIFORM(fv,m32f, Matrix32f);
-      VERIFY_UNIFORM(fv,m24f, Matrix24f);
-      VERIFY_UNIFORM(fv,m42f, Matrix42f);
-      VERIFY_UNIFORM(fv,m34f, Matrix34f);
-      VERIFY_UNIFORM(fv,m43f, Matrix43f);
-      #endif
+
+      VERIFY_UNIFORM(fv, m23f, Matrix23f);
+      VERIFY_UNIFORM(fv, m32f, Matrix32f);
+      VERIFY_UNIFORM(fv, m24f, Matrix24f);
+      VERIFY_UNIFORM(fv, m42f, Matrix42f);
+      VERIFY_UNIFORM(fv, m34f, Matrix34f);
+      VERIFY_UNIFORM(fv, m43f, Matrix43f);
+      glDeleteProgram(prg_id);
     }
     else
-      std::cerr << "Warning: opengl 2.1 was not tested\n";
-    
-    if(GLEW_VERSION_3_0)
+#endif
+      std::cerr << "Warning: opengl 2.1 was not tested.\n";
+
+#ifdef GL_VERSION_3_0
+    if(GLEW_VERSION_3_0 && GL_VERSION_3_0 && gl_major_version >= 3)
     {
-      #ifdef GL_VERSION_3_0
-      const char* frg = "#version 150\n"
+      std::string frg = format(
+        "${GLSL_VERSION}\n"
         "uniform uvec2 v2ui;\n"
         "uniform uvec3 v3ui;\n"
         "uniform uvec4 v4ui;\n"
-        "out vec4 data;\n"
-        "void main(void) { data = vec4(v2ui[0]+v3ui[0]+v4ui[0]); }\n";
-        
-      GLint prg_id = createShader(vtx,frg);
-      
+        "${FRAG_OUTPUT_DECLARATION}\n"
+        "void main(void) {\n"
+        "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2ui[0]+v3ui[0]+v4ui[0]);\n"
+        "}\n",
+        glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
       typedef Matrix<unsigned int,2,1> Vector2ui;
       typedef Matrix<unsigned int,3,1> Vector3ui;
       typedef Matrix<unsigned int,4,1> Vector4ui;
-      
+
       VERIFY_UNIFORMi(v2ui, Vector2ui);
       VERIFY_UNIFORMi(v3ui, Vector3ui);
       VERIFY_UNIFORMi(v4ui, Vector4ui);
-      #endif
+      glDeleteProgram(prg_id);
     }
     else
-      std::cerr << "Warning: opengl 3.0 was not tested\n";
-    
-    #ifdef GLEW_ARB_gpu_shader_fp64
+#endif
+      std::cerr << "Warning: opengl 3.0 was not tested.\n";
+
+    // dvecn supported if >= 4.1 or ARB_vertex_attrib_64bit
+    bool has_fp64_native = (gl_major_version == 4 && gl_minor_version >= 1);
+    bool has_fp64_extension = false;
+#ifdef GLEW_ARB_gpu_shader_fp64
     if(GLEW_ARB_gpu_shader_fp64)
     {
-      #ifdef GL_ARB_gpu_shader_fp64
-      const char* frg = "#version 150\n"
+      // Check that extension can actually be compiled.
+      if (has_fp64_extension)
+      {
+        std::string frg = format(
+          "${GLSL_VERSION}\n"
+          "#extension GL_ARB_gpu_shader_fp64 : enable\n"
+          "uniform dvec2 dv2;\n"
+          "${FRAG_OUTPUT_DECLARATION}\n"
+          "void main(void) {\n"
+          "  ${FRAG_OUTPUT_VARIABLE} = vec4(dv2.x, dv2.y, dv2.x, dv2.y);\n"
+          "}\n",
+          glsl_vars, glsl_vals);
+        GLint prg_id = createProgram(vtx, frg, /*print_errors=*/false);
+        if (prg_id)
+        {
+          has_fp64_extension = true;
+          glDeleteProgram(prg_id);
+        }
+      }
+    }
+#endif
+
+    if( has_fp64_native || has_fp64_extension )
+    {
+      std::vector<std::string> glsl_vars_with_extension = glsl_vars;
+      glsl_vars_with_extension.push_back("${GLSL_EXTENSIONS}");
+      std::vector<std::string> glsl_vals_with_extension = glsl_vals;
+      if (has_fp64_extension)
+      {
+        glsl_vals_with_extension.push_back("#extension GL_ARB_gpu_shader_fp64 : enable");
+      }
+      else
+      {
+        glsl_vals_with_extension.push_back("");
+      }
+
+      std::string frg = format(
+        "${GLSL_VERSION}\n"
+        "${GLSL_EXTENSIONS}\n"
         "uniform dvec2 v2d;\n"
         "uniform dvec3 v3d;\n"
         "uniform dvec4 v4d;\n"
-        "out vec4 data;\n"
-        "void main(void) { data = vec4(v2d[0]+v3d[0]+v4d[0]); }\n";
-        
-      GLint prg_id = createShader(vtx,frg);
-      
-      VERIFY_UNIFORM(dv,v2d, Vector2d);
-      VERIFY_UNIFORM(dv,v3d, Vector3d);
-      VERIFY_UNIFORM(dv,v4d, Vector4d);
-      #endif
+        "${FRAG_OUTPUT_DECLARATION}\n"
+        "void main(void) {\n"
+        "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2d[0]+v3d[0]+v4d[0]);\n"
+        "}\n",
+        glsl_vars_with_extension, glsl_vals_with_extension);
+
+      GLint prg_id = createProgram(vtx,frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      VERIFY_UNIFORM(dv, v2d, Vector2d);
+      VERIFY_UNIFORM(dv, v3d, Vector3d);
+      VERIFY_UNIFORM(dv, v4d, Vector4d);
+      glDeleteProgram(prg_id);
     }
     else
-      std::cerr << "Warning: GLEW_ARB_gpu_shader_fp64 was not tested\n";
-    #else
-      std::cerr << "Warning: GLEW_ARB_gpu_shader_fp64 was not tested\n";
-    #endif
+      std::cerr << "Warning: dvec (fp64) was not tested.\n";
+  }
+
+  // Exit loop - Leaving main loop is supported by freeglut, otherwise we
+  // are forced to exit.
+#ifdef FREEGLUT
+  glutLeaveMainLoop();
+  // Trigger another display loop iteration. Otherwise, it just hangs.
+  glutPostRedisplay();
+#else
+  exit(0);
+#endif
+}
+
+EIGEN_DECLARE_TEST(openglsupport)
+{
+  int argc = 0;
+  glutInit(&argc, 0);
+
+  GLint glut_display_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
+
+#ifndef EIGEN_LEGACY_OPENGL
+  // Initialize 3.2+ OpenGL context.
+#if defined(__APPLE_CC__)
+  glut_display_mode |= GLUT_3_2_CORE_PROFILE;
+#elif defined(FREEGLUT)
+  glutInitContextVersion(3, 2);
+  glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
+  glutInitContextProfile(GLUT_CORE_PROFILE);
+#endif
+#endif
+
+  glutInitDisplayMode(glut_display_mode);
+  glutInitWindowPosition(0, 0);
+  glutInitWindowSize(10, 10);
+
+  int window = glutCreateWindow("Eigen");
+  if(window <= 0)
+  {
+    std::cerr << "Error: Unable to create GLUT Window.\n";
+    exit(1);
   }
-  
+
+  glewExperimental = GL_TRUE;
+  if(glewInit() != GLEW_OK)
+  {
+    std::cerr << "Warning: Failed to initialize GLEW.\n";
+    exit(1);
+  }
+
+  // Run test in display, otherwise GLUT fails to clean up and leads to memory
+  // access errors on exit.
+  glutDisplayFunc(openglsupport_test_loop);
+  glutMainLoop();
+  glutDestroyWindow(window);
 }