Recognize WEBGL extensions on Firefox (copy with regenerated files)

tests/html/webgl_extensions_test.dart

+// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library web_gl_test;
+
+import 'package:unittest/unittest.dart';
+import 'package:unittest/html_individual_config.dart';
+import 'dart:html';
+import 'dart:typed_data';
+import 'dart:web_gl';
+import 'dart:web_gl' as gl;
+
+// Test that various webgl extensions are available. Only test advertised
+// supported extensions. If the extension has methods, we just test the presence
+// of some methods - we don't test if functionality works.
+
+main() {
+  useHtmlIndividualConfiguration();
+
+  if (!RenderingContext.supported) return;
+
+
+  const allExtensions = const [
+    'ANGLE_instanced_arrays',
+    'EXT_blend_minmax',
+    'EXT_color_buffer_float',
+    'EXT_color_buffer_half_float',
+    'EXT_disjoint_timer_query',
+    'EXT_frag_depth',
+    'EXT_sRGB',
+    'EXT_shader_texture_lod',
+    'EXT_texture_filter_anisotropic',
+    'OES_element_index_uint',
+    'OES_standard_derivatives',
+    'OES_texture_float',
+    'OES_texture_float_linear',
+    'OES_texture_half_float',
+    'OES_texture_half_float_linear',
+    'OES_vertex_array_object',
+    'WEBGL_color_buffer_float',
+    'WEBGL_compressed_texture_atc',
+    'WEBGL_compressed_texture_es3',
+    'WEBGL_compressed_texture_etc1',
+    'WEBGL_compressed_texture_pvrtc',
+    'WEBGL_compressed_texture_s3tc',
+    'WEBGL_debug_renderer_info',
+    'WEBGL_debug_shaders',
+    'WEBGL_depth_texture',
+    'WEBGL_draw_buffers',
+    'WEBGL_lose_context',
+  ];
+
+  getExtension(String name) {
+    expect(name, isIn(allExtensions), reason: 'unknown extension');
+    var canvas = new CanvasElement();
+    var context = canvas.getContext3d();
+    var supportedExtensions = context.getSupportedExtensions();
+    if (supportedExtensions.contains(name)) {
+      var extension = context.getExtension(name);
+      expect(extension, isNotNull);
+      return extension;
+    }
+    return null;
+  }
+
+  testType(name, typeMatcher) {
+    test('type', () {
+      var extension = getExtension(name);
+      if (extension == null) return;
+      expect(extension, typeMatcher);
+      // Ensure that isInstanceOf<X> is not instantiated for an erroneous type
+      // X.  If X is erroneous, there is only a warning at compile time and X is
+      // treated as dynamic, which would make the above line pass.
+      expect(1, isNot(typeMatcher), reason: 'invalid typeMatcher');
+    });
+  }
+
+  group('ANGLE_instanced_arrays', () {
+    const name = 'ANGLE_instanced_arrays';
+    testType(name, const isInstanceOf<AngleInstancedArrays>());
+    test('vertexAttribDivisorAngle', () {
+      var extension = getExtension(name);
+      if (extension == null) return;
+      expect(extension.vertexAttribDivisorAngle, isFunction);
+    });
+  });
+
+  group('EXT_blend_minmax', () {
+    testType('EXT_blend_minmax', const isInstanceOf<ExtBlendMinMax>());
+  });
+
+  group('EXT_frag_depth', () {
+    testType('EXT_frag_depth', const isInstanceOf<ExtFragDepth>());
+  });
+
+  group('EXT_sRGB', () {
+    testType('EXT_sRGB', const isInstanceOf<EXTsRgb>());
+  });
+
+  group('EXT_shader_texture_lod', () {
+    testType(
+        'EXT_shader_texture_lod', const isInstanceOf<ExtShaderTextureLod>());
+  });
+
+  group('EXT_texture_filter_anisotropic', () {
+    testType('EXT_texture_filter_anisotropic',
+        const isInstanceOf<ExtTextureFilterAnisotropic>());
+  });
+
+  group('OES_element_index_uint', () {
+    testType(
+        'OES_element_index_uint', const isInstanceOf<OesElementIndexUint>());
+  });
+
+  group('OES_standard_derivatives', () {
+    testType('OES_standard_derivatives',
+        const isInstanceOf<OesStandardDerivatives>());
+  });
+
+  group('OES_texture_float', () {
+    testType('OES_texture_float', const isInstanceOf<OesTextureFloat>());
+  });
+
+  group('OES_texture_float_linear', () {
+    testType('OES_texture_float_linear',
+        const isInstanceOf<OesTextureFloatLinear>());
+  });
+
+  group('OES_texture_half_float', () {
+    testType(
+        'OES_texture_half_float', const isInstanceOf<OesTextureHalfFloat>());
+  });
+
+  group('OES_texture_half_float_linear', () {
+    testType('OES_texture_half_float_linear',
+        const isInstanceOf<OesTextureHalfFloatLinear>());
+  });
+
+  group('OES_vertex_array_object', () {
+    testType(
+        'OES_vertex_array_object', const isInstanceOf<OesVertexArrayObject>());
+  });
+
+  group('WEBGL_compressed_texture_atc', () {
+    testType('WEBGL_compressed_texture_atc',
+        const isInstanceOf<CompressedTextureAtc>());
+  });
+
+  group('WEBGL_compressed_texture_etc1', () {
+    testType('WEBGL_compressed_texture_etc1',
+        const isInstanceOf<CompressedTextureETC1>());
+  });
+
+  group('WEBGL_compressed_texture_pvrtc', () {
+    testType('WEBGL_compressed_texture_pvrtc',
+        const isInstanceOf<CompressedTexturePvrtc>());
+  });
+
+  group('WEBGL_compressed_texture_s3tc', () {
+    testType('WEBGL_compressed_texture_s3tc',
+        const isInstanceOf<CompressedTextureS3TC>());
+  });
+
+  group('WEBGL_debug_renderer_info', () {
+    testType(
+        'WEBGL_debug_renderer_info', const isInstanceOf<DebugRendererInfo>());
+  });
+
+  group('WEBGL_debug_shaders', () {
+    testType('WEBGL_debug_shaders', const isInstanceOf<DebugShaders>());
+  });
+
+  group('WEBGL_depth_texture', () {
+    testType('WEBGL_depth_texture', const isInstanceOf<DepthTexture>());
+  });
+
+  group('WEBGL_draw_buffers', () {
+    const name = 'WEBGL_draw_buffers';
+    testType(name, const isInstanceOf<DrawBuffers>());
+    test('drawBuffersWebgl', () {
+      var extension = getExtension(name);
+      if (extension == null) return;
+      expect(extension.drawBuffersWebgl, isFunction);
+    });
+  });
+
+  group('WEBGL_lose_context', () {
+    const name = 'WEBGL_lose_context';
+    testType(name, const isInstanceOf<LoseContext>());
+    test('loseContext', () {
+      var extension = getExtension(name);
+      if (extension == null) return;
+      expect(extension.loseContext, isFunction);
+    });
+  });
+}
+
+Matcher isFunction = const isInstanceOf<Function>();