DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Reverts "Enabled some disabled impeller fragment shader dart tests (#180759)" (#180785)

Browse Source 
<!-- start_original_pr_link -->
Reverts: flutter/flutter#180759
<!-- end_original_pr_link -->
<!-- start_initiating_author -->
Initiated by: jason-simmons
<!-- end_initiating_author -->
<!-- start_revert_reason -->
Reason for reverting: Flakes in `fragment_shader_test.dart` are
happening on LUCI after this PR.

I can reproduce these flakes in my local Linux cloud VM environment.
<!-- end_revert_reason -->
<!-- start_original_pr_author -->
Original PR Author: gaaclarke
<!-- end_original_pr_author -->

<!-- start_reviewers -->
Reviewed By: {walley892}
<!-- end_reviewers -->

<!-- start_revert_body -->
This change reverts the following previous change:
Instead of having a short circuit in a long function we instead sort
skia only tests into their own function. I've also enabled all the tests
that pass.

issue: https://github.com/flutter/flutter/issues/122823
test exempt:  is test

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [x] I signed the [CLA].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [x] I followed the [breaking change policy] and added [Data Driven
Fixes] where supported.
- [x] All existing and new tests are passing.

If you need help, consider asking for advice on the #hackers-new channel
on [Discord].

**Note**: The Flutter team is currently trialing the use of [Gemini Code
Assist for
GitHub](https://developers.google.com/gemini-code-assist/docs/review-github-code).
Comments from the `gemini-code-assist` bot should not be taken as
authoritative feedback from the Flutter team. If you find its comments
useful you can update your code accordingly, but if you are unsure or
disagree with the feedback, please feel free to wait for a Flutter team
member's review for guidance on which automated comments should be
addressed.

<!-- Links -->
[Contributor Guide]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#overview
[Tree Hygiene]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md
[test-exempt]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#tests
[Flutter Style Guide]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Style-guide-for-Flutter-repo.md
[Features we expect every widget to implement]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Style-guide-for-Flutter-repo.md#features-we-expect-every-widget-to-implement
[CLA]: https://cla.developers.google.com/
[flutter/tests]: https://github.com/flutter/tests
[breaking change policy]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Tree-hygiene.md#handling-breaking-changes
[Discord]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Chat.md
[Data Driven Fixes]:
https://github.com/flutter/flutter/blob/main/docs/contributing/Data-driven-Fixes.md

<!-- end_revert_body -->

Co-authored-by: auto-submit[bot] <flutter-engprod-team@google.com>
This commit is contained in:
auto-submit[bot] 2026-01-10 00:19:47 +00:00 committed by GitHub
parent cfb3f18e1d
commit 202e012f59
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 262 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
engine/src/flutter/lib/ui/fixtures/shaders/general_shaders/BUILD.gn
View File

@ -10,7 +10,6 @@ if (enable_unittests) {
test_shaders = [
"blue_green_sampler.frag",
"children_and_uniforms.frag",
"circle_sdf.frag",
"double_sampler_swapped.frag",
"double_sampler.frag",
"filter_shader.frag",
@ -19,16 +18,15 @@ if (enable_unittests) {
"missing_texture.frag",
"no_builtin_redefinition.frag",
"no_uniforms.frag",
"sdf.frag",
"simple.frag",
"texture.frag",
"uniform_arrays.frag",
"uniform_ordering.frag",
"uniforms_inserted.frag",
"uniforms_renamed.frag",
"uniforms_reordered.frag",
"uniforms_sorted.frag",
"uniforms.frag",
"uniforms_renamed.frag",
"vec3_uniform.frag",
]
@ -40,6 +38,18 @@ if (enable_unittests) {
impellerc("compile_general_shaders") {
mnemonic = "IMPELLERC_SKSL"
shaders = test_shaders
shader_target_flags = [ "--sksl" ]
intermediates_subdir = "iplr"
sl_file_extension = "iplr"
iplr = true
}
impellerc("compile_sdf_shaders") {
mnemonic = "IMPELLERC_SDF"
shaders = [
"circle_sdf.frag",
"sdf.frag",
]
shader_target_flags = [
"--sksl",
"--runtime-stage-metal",
@ -52,8 +62,12 @@ if (enable_unittests) {
}
test_fixtures("fixtures") {
deps = [ ":compile_general_shaders" ]
fixtures = get_target_outputs(":compile_general_shaders")
deps = [
":compile_general_shaders",
":compile_sdf_shaders",
]
fixtures = get_target_outputs(":compile_general_shaders") +
get_target_outputs(":compile_sdf_shaders")
dest = "$root_gen_dir/flutter/lib/ui"
}
}

4
engine/src/flutter/lib/ui/fixtures/shaders/general_shaders/blue_green_sampler.frag
View File

@ -6,9 +6,9 @@
precision highp float;
out vec4 oColor;
layout(location = 0) out vec4 oColor;
uniform sampler2D iChild;
layout(location = 0) uniform sampler2D iChild;
void main() {
// iChild1 is an image that is half blue, half green,

8
engine/src/flutter/lib/ui/fixtures/shaders/general_shaders/children_and_uniforms.frag
View File

@ -8,10 +8,10 @@ precision highp float;
layout(location = 0) out vec4 color;
uniform sampler2D child1;
uniform float a;
uniform sampler2D child2;
uniform float b;
layout(location = 0) uniform sampler2D child1;
layout(location = 1) uniform float a;
layout(location = 2) uniform sampler2D child2;
layout(location = 3) uniform float b;
void main() {
// child1 is a 10x10 image where the left half is blue and the right

474
engine/src/flutter/testing/dart/fragment_shader_test.dart
View File

@ -17,6 +17,8 @@ import 'impeller_enabled.dart';
import 'shader_test_file_utils.dart';
void main() async {
final ImageComparer comparer = await ImageComparer.create();
test('impellerc produces reasonable JSON encoded IPLR files', () async {
final Directory directory = shaderDirectory('iplr-json');
final Object? rawData = convert.json.decode(
@ -41,6 +43,11 @@ void main() async {
expect(uniformData['location'] is int, true);
});
if (impellerEnabled) {
// https://github.com/flutter/flutter/issues/122823
return;
}
test('FragmentProgram objects are cached.', () async {
final FragmentProgram programA = await FragmentProgram.fromAsset(
'blue_green_sampler.frag.iplr',
@ -52,6 +59,109 @@ void main() async {
expect(identical(programA, programB), true);
});
group('FragmentProgram getUniform*', () {
late FragmentShader shader;
setUpAll(() async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniforms.frag.iplr');
shader = program.fragmentShader();
});
test('FragmentProgram uniform info', () async {
final List<UniformFloatSlot> slots = [
shader.getUniformFloat('iFloatUniform'),
shader.getUniformFloat('iVec2Uniform', 0),
shader.getUniformFloat('iVec2Uniform', 1),
shader.getUniformFloat('iMat2Uniform', 0),
shader.getUniformFloat('iMat2Uniform', 1),
shader.getUniformFloat('iMat2Uniform', 2),
shader.getUniformFloat('iMat2Uniform', 3),
];
for (var i = 0; i < slots.length; ++i) {
expect(slots[i].shaderIndex, equals(i));
}
});
test('FragmentProgram getUniformFloat unknown', () async {
try {
shader.getUniformFloat('unknown');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('No uniform named "unknown".'));
}
});
test('FragmentProgram getUniformFloat offset overflow', () async {
try {
shader.getUniformFloat('iVec2Uniform', 2);
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Index `2` out of bounds for `iVec2Uniform`.'));
}
});
test('FragmentProgram getUniformFloat offset underflow', () async {
try {
shader.getUniformFloat('iVec2Uniform', -1);
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Index `-1` out of bounds for `iVec2Uniform`.'));
}
});
test('FragmentProgram getUniformVec2', () async {
final UniformVec2Slot slot = shader.getUniformVec2('iVec2Uniform');
slot.set(6.0, 7.0);
});
test('FragmentProgram getUniformVec2 wrong size', () async {
try {
shader.getUniformVec2('iVec3Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec3Uniform` has size 3, not size 2.'));
}
try {
shader.getUniformVec2('iFloatUniform');
} catch (e) {
expect(e.toString(), contains('`iFloatUniform` has size 1, not size 2.'));
}
});
test('FragmentProgram getUniformVec3', () async {
final UniformVec3Slot slot = shader.getUniformVec3('iVec3Uniform');
slot.set(0.8, 0.1, 0.3);
});
test('FragmentProgram getUniformVec3 wrong size', () async {
try {
shader.getUniformVec3('iVec2Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec2Uniform` has size 2, not size 3.'));
}
try {
shader.getUniformVec3('iVec4Uniform');
} catch (e) {
expect(e.toString(), contains('`iVec4Uniform` has size 4, not size 3.'));
}
});
test('FragmentProgram getUniformVec4', () async {
final UniformVec4Slot slot = shader.getUniformVec4('iVec4Uniform');
slot.set(11.0, 22.0, 19.0, 96.0);
});
test('FragmentProgram getUniformVec4 wrong size', () async {
try {
shader.getUniformVec4('iVec3Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec3Uniform` has size 3, not size 4.'));
}
});
});
test('FragmentProgram getImageSampler', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniform_ordering.frag.iplr');
final FragmentShader shader = program.fragmentShader();
@ -72,6 +182,17 @@ void main() async {
}
});
test('FragmentProgram getImageSampler wrong type', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniform_ordering.frag.iplr');
final FragmentShader shader = program.fragmentShader();
try {
shader.getImageSampler('b');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Uniform "b" is not an image sampler.'));
}
});
test('FragmentShader setSampler throws with out-of-bounds index', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('blue_green_sampler.frag.iplr');
final Image blueGreenImage = await _createBlueGreenImage();
@ -210,6 +331,13 @@ void main() async {
);
});
test('FragmentShader simple shader renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('functions.frag.iplr');
final FragmentShader shader = program.fragmentShader()..setFloat(0, 1.0);
await _expectShaderRendersGreen(shader);
shader.dispose();
});
test('Reused FragmentShader simple shader renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('functions.frag.iplr');
final FragmentShader shader = program.fragmentShader()..setFloat(0, 1.0);
@ -239,6 +367,77 @@ void main() async {
blueGreenImage.dispose();
});
for (final (filterQuality, goldenFilename) in [
(FilterQuality.none, 'fragment_shader_texture_with_quality_none.png'),
(FilterQuality.low, 'fragment_shader_texture_with_quality_low.png'),
(FilterQuality.medium, 'fragment_shader_texture_with_quality_medium.png'),
(FilterQuality.high, 'fragment_shader_texture_with_quality_high.png'),
]) {
test('FragmentShader renders sampler with filter quality ${filterQuality.name}', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('texture.frag.iplr');
final Image image = _createOvalGradientImage(imageDimension: 16);
final FragmentShader shader = program.fragmentShader()
..setImageSampler(0, image, filterQuality: filterQuality);
shader.getUniformFloat('u_size', 0).set(300);
shader.getUniformFloat('u_size', 1).set(300);
final Image shaderImage = await _imageFromShader(shader: shader, imageDimension: 300);
await comparer.addGoldenImage(shaderImage, goldenFilename);
shader.dispose();
image.dispose();
});
}
test('FragmentShader with uniforms renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniforms.frag.iplr');
final FragmentShader shader = program.fragmentShader()
..setFloat(0, 0.0)
..setFloat(1, 0.25)
..setFloat(2, 0.75)
..setFloat(3, 0.0)
..setFloat(4, 0.0)
..setFloat(5, 0.0)
..setFloat(6, 1.0);
final ByteData renderedBytes = (await _imageByteDataFromShader(shader: shader))!;
expect(toFloat(renderedBytes.getUint8(0)), closeTo(0.0, epsilon));
expect(toFloat(renderedBytes.getUint8(1)), closeTo(0.25, epsilon));
expect(toFloat(renderedBytes.getUint8(2)), closeTo(0.75, epsilon));
expect(toFloat(renderedBytes.getUint8(3)), closeTo(1.0, epsilon));
shader.dispose();
});
test('FragmentShader shader with array uniforms renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniform_arrays.frag.iplr');
final FragmentShader shader = program.fragmentShader();
for (var i = 0; i < 20; i++) {
shader.setFloat(i, i.toDouble());
}
await _expectShaderRendersGreen(shader);
shader.dispose();
});
test('FragmentShader The ink_sparkle shader is accepted', () async {
if (impellerEnabled) {
print('Skipped for Impeller - https://github.com/flutter/flutter/issues/122823');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset('ink_sparkle.frag.iplr');
final FragmentShader shader = program.fragmentShader();
await _imageByteDataFromShader(shader: shader);
// Testing that no exceptions are thrown. Tests that the ink_sparkle shader
// produces the correct pixels are in the framework.
shader.dispose();
});
test('FragmentShader Uniforms are sorted correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniforms_sorted.frag.iplr');
@ -293,6 +492,10 @@ void main() async {
});
test('FragmentShader user defined functions do not redefine builtins', () async {
if (impellerEnabled) {
print('Skipped for Impeller - https://github.com/flutter/flutter/issues/122823');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset(
'no_builtin_redefinition.frag.iplr',
);
@ -302,198 +505,19 @@ void main() async {
});
test('FragmentShader fromAsset accepts a shader with no uniforms', () async {
if (impellerEnabled) {
print('Skipped for Impeller - https://github.com/flutter/flutter/issues/122823');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset('no_uniforms.frag.iplr');
final FragmentShader shader = program.fragmentShader();
await _expectShaderRendersGreen(shader);
shader.dispose();
});
group('FragmentProgram getUniform*', () {
late FragmentShader shader;
setUpAll(() async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniforms.frag.iplr');
shader = program.fragmentShader();
});
_runSkiaTest('FragmentProgram uniform info', () async {
final List<UniformFloatSlot> slots = [
shader.getUniformFloat('iFloatUniform'),
shader.getUniformFloat('iVec2Uniform', 0),
shader.getUniformFloat('iVec2Uniform', 1),
shader.getUniformFloat('iMat2Uniform', 0),
shader.getUniformFloat('iMat2Uniform', 1),
shader.getUniformFloat('iMat2Uniform', 2),
shader.getUniformFloat('iMat2Uniform', 3),
];
for (var i = 0; i < slots.length; ++i) {
expect(slots[i].shaderIndex, equals(i));
}
});
_runSkiaTest('FragmentProgram getUniformFloat unknown', () async {
try {
shader.getUniformFloat('unknown');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('No uniform named "unknown".'));
}
});
_runSkiaTest('FragmentProgram getUniformFloat offset overflow', () async {
try {
shader.getUniformFloat('iVec2Uniform', 2);
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Index `2` out of bounds for `iVec2Uniform`.'));
}
});
_runSkiaTest('FragmentProgram getUniformFloat offset underflow', () async {
try {
shader.getUniformFloat('iVec2Uniform', -1);
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Index `-1` out of bounds for `iVec2Uniform`.'));
}
});
_runSkiaTest('FragmentProgram getUniformVec2', () async {
final UniformVec2Slot slot = shader.getUniformVec2('iVec2Uniform');
slot.set(6.0, 7.0);
});
_runSkiaTest('FragmentProgram getUniformVec2 wrong size', () async {
try {
shader.getUniformVec2('iVec3Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec3Uniform` has size 3, not size 2.'));
}
try {
shader.getUniformVec2('iFloatUniform');
} catch (e) {
expect(e.toString(), contains('`iFloatUniform` has size 1, not size 2.'));
}
});
_runSkiaTest('FragmentProgram getUniformVec3', () async {
final UniformVec3Slot slot = shader.getUniformVec3('iVec3Uniform');
slot.set(0.8, 0.1, 0.3);
});
_runSkiaTest('FragmentProgram getUniformVec3 wrong size', () async {
try {
shader.getUniformVec3('iVec2Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec2Uniform` has size 2, not size 3.'));
}
try {
shader.getUniformVec3('iVec4Uniform');
} catch (e) {
expect(e.toString(), contains('`iVec4Uniform` has size 4, not size 3.'));
}
});
_runSkiaTest('FragmentProgram getUniformVec4', () async {
final UniformVec4Slot slot = shader.getUniformVec4('iVec4Uniform');
slot.set(11.0, 22.0, 19.0, 96.0);
});
_runSkiaTest('FragmentProgram getUniformVec4 wrong size', () async {
try {
shader.getUniformVec4('iVec3Uniform');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('`iVec3Uniform` has size 3, not size 4.'));
}
});
});
_runSkiaTest('FragmentProgram getImageSampler wrong type', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniform_ordering.frag.iplr');
final FragmentShader shader = program.fragmentShader();
try {
shader.getImageSampler('b');
fail('Unreachable');
} catch (e) {
expect(e.toString(), contains('Uniform "b" is not an image sampler.'));
}
});
final ImageComparer comparer = await ImageComparer.create();
for (final (filterQuality, goldenFilename) in [
(FilterQuality.none, 'fragment_shader_texture_with_quality_none.png'),
(FilterQuality.low, 'fragment_shader_texture_with_quality_low.png'),
(FilterQuality.medium, 'fragment_shader_texture_with_quality_medium.png'),
(FilterQuality.high, 'fragment_shader_texture_with_quality_high.png'),
]) {
_runSkiaTest(
'FragmentShader renders sampler with filter quality ${filterQuality.name}',
() async {
final FragmentProgram program = await FragmentProgram.fromAsset('texture.frag.iplr');
final Image image = _createOvalGradientImage(imageDimension: 16);
final FragmentShader shader = program.fragmentShader()
..setImageSampler(0, image, filterQuality: filterQuality);
shader.getUniformFloat('u_size', 0).set(300);
shader.getUniformFloat('u_size', 1).set(300);
final Image shaderImage = await _imageFromShader(shader: shader, imageDimension: 300);
await comparer.addGoldenImage(shaderImage, goldenFilename);
shader.dispose();
image.dispose();
},
);
}
_runSkiaTest('FragmentShader simple shader renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('functions.frag.iplr');
final FragmentShader shader = program.fragmentShader()..setFloat(0, 1.0);
await _expectShaderRendersGreen(shader);
shader.dispose();
});
_runSkiaTest('FragmentShader with uniforms renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniforms.frag.iplr');
final FragmentShader shader = program.fragmentShader()
..setFloat(0, 0.0)
..setFloat(1, 0.25)
..setFloat(2, 0.75)
..setFloat(3, 0.0)
..setFloat(4, 0.0)
..setFloat(5, 0.0)
..setFloat(6, 1.0);
final ByteData renderedBytes = (await _imageByteDataFromShader(shader: shader))!;
expect(toFloat(renderedBytes.getUint8(0)), closeTo(0.0, epsilon));
expect(toFloat(renderedBytes.getUint8(1)), closeTo(0.25, epsilon));
expect(toFloat(renderedBytes.getUint8(2)), closeTo(0.75, epsilon));
expect(toFloat(renderedBytes.getUint8(3)), closeTo(1.0, epsilon));
shader.dispose();
});
_runSkiaTest('FragmentShader shader with array uniforms renders correctly', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('uniform_arrays.frag.iplr');
final FragmentShader shader = program.fragmentShader();
for (var i = 0; i < 20; i++) {
shader.setFloat(i, i.toDouble());
}
await _expectShaderRendersGreen(shader);
shader.dispose();
});
test('ImageFilter.shader errors if shader does not have correct uniform layout', () async {
if (impellerEnabled || !impellerEnabled) {
// TODO(gaaclarke): This test was disabled for a long time and atrophied
// we need to fix it or delete it.
print('This test atrophied and is disabled.');
if (!impellerEnabled) {
print('Skipped for Skia');
return;
}
const shaders = <String>[
@ -524,7 +548,12 @@ void main() async {
}
});
_runImpellerTest('Shader Compiler appropriately pads vec3 uniform arrays', () async {
test('Shader Compiler appropriately pads vec3 uniform arrays', () async {
if (!impellerEnabled) {
print('Skipped for Skia');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset('vec3_uniform.frag.iplr');
final FragmentShader shader = program.fragmentShader();
@ -537,7 +566,11 @@ void main() async {
await _expectShaderRendersGreen(shader);
});
_runImpellerTest('ImageFilter.shader can be applied to canvas operations', () async {
test('ImageFilter.shader can be applied to canvas operations', () async {
if (!impellerEnabled) {
print('Skipped for Skia');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset('filter_shader.frag.iplr');
final FragmentShader shader = program.fragmentShader();
final recorder = PictureRecorder();
@ -556,9 +589,8 @@ void main() async {
// For an explaination of the problem see https://github.com/flutter/flutter/issues/163302 .
test('ImageFilter.shader equality checks consider uniform values', () async {
if (impellerEnabled || !impellerEnabled) {
// TODO(gaaclarke): Delete or fix this test.
print("This test was skipped and now doesn't work.");
if (!impellerEnabled) {
print('Skipped for Skia');
return;
}
final FragmentProgram program = await FragmentProgram.fromAsset('filter_shader.frag.iplr');
@ -583,56 +615,24 @@ void main() async {
expect(identical(filter, filter_3), false);
});
_runSkiaTest('FragmentShader The ink_sparkle shader is accepted', () async {
final FragmentProgram program = await FragmentProgram.fromAsset('ink_sparkle.frag.iplr');
final FragmentShader shader = program.fragmentShader();
await _imageByteDataFromShader(shader: shader);
// Testing that no exceptions are thrown. Tests that the ink_sparkle shader
// produces the correct pixels are in the framework.
shader.dispose();
});
if (!impellerEnabled) {
// Test all supported GLSL ops. See lib/spirv/lib/src/constants.dart
final Map<String, FragmentProgram> iplrSupportedGLSLOpShaders = await _loadShaderAssets(
path.join('supported_glsl_op_shaders', 'iplr'),
'.iplr',
);
_expectFragmentShadersRenderGreen(iplrSupportedGLSLOpShaders);
// Test all supported instructions. See lib/spirv/lib/src/constants.dart
final Map<String, FragmentProgram> iplrSupportedOpShaders = await _loadShaderAssets(
path.join('supported_op_shaders', 'iplr'),
'.iplr',
);
_expectFragmentShadersRenderGreen(iplrSupportedOpShaders);
if (impellerEnabled) {
print('Skipped for Impeller - https://github.com/flutter/flutter/issues/122823');
return;
}
}
////////////////////////////////////////////////////////////////////////////////
// Helper Functions ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Test all supported GLSL ops. See lib/spirv/lib/src/constants.dart
final Map<String, FragmentProgram> iplrSupportedGLSLOpShaders = await _loadShaderAssets(
path.join('supported_glsl_op_shaders', 'iplr'),
'.iplr',
);
_expectFragmentShadersRenderGreen(iplrSupportedGLSLOpShaders);
void _runSkiaTest(String name, void Function() callback) {
test(name, () {
if (impellerEnabled) {
print('skipped for Impeller - https://github.com/flutter/flutter/issues/122823');
return;
}
callback();
});
}
void _runImpellerTest(String name, void Function() callback) {
test(name, () {
if (!impellerEnabled) {
print('skipped for Skia');
return;
}
callback();
});
// Test all supported instructions. See lib/spirv/lib/src/constants.dart
final Map<String, FragmentProgram> iplrSupportedOpShaders = await _loadShaderAssets(
path.join('supported_op_shaders', 'iplr'),
'.iplr',
);
_expectFragmentShadersRenderGreen(iplrSupportedOpShaders);
}
// Expect that all of the shaders in this folder render green.