mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
6c15c4587f
> [!NOTE] > This PR lands https://github.com/flutter/flutter/pull/158473 (closed due to confusing git-isms). Please see that PR for all comments and discussion on landing this feature. ### Overview Implements setting content sensitivity on Android via a new widget called `SensitiveContent` that currently will only function on Android. ### How it's implemented There are three different content sensitivity levels: [`autoSensitive`](https://developer.android.com/reference/android/view/View#CONTENT_SENSITIVITY_AUTO), [`sensitive`](https://developer.android.com/reference/android/view/View#CONTENT_SENSITIVITY_SENSITIVE), [`notSensitive`](https://developer.android.com/reference/android/view/View#CONTENT_SENSITIVITY_NOT_SENSITIVE). All except `autoSensitive` behave as their Android counterpart level behaves (see links on the levels); for Flutter, `autoSensitive` will behave the same as `notSensitive` though it is implemented as if it works (see https://github.com/flutter/flutter/issues/160879 for more details. In any given Flutter view, each `SensitiveContent` widget sets a content sensitivity level and there may be multiple `SensitiveContent` widgets in the widget tree at a time, but only the most severe content sensitivity level in the tree will be maintained in order to ensure secure content remains obscured during screen projection. This means that even widgets that are not visible may still impact the overall content sensitivity of the entire Flutter view (see https://github.com/flutter/flutter/issues/160051 for more details). Under the hood, the implementation uses method channels. Theoretically, this could cause a delay in setting the content sensitivity level and a Flutter view being obscured during screen projection on time, so we will investigate using JNIgen in the future (see https://github.com/flutter/flutter/issues/160050 for more details). Over the method channel, the framework will send a Flutter view ID and content sensitivity level to the engine to set the expected content sensitivity level for the view. ### Timeline #### Required for feature shipping - Land this PR with the method channel implementation of content sensitivity. #### Short-term follow up tasks - Ensure every `FlutterView` has a unique ID for the native `SensitiveContentPlugin` to identify them by: https://github.com/flutter/flutter/pull/162685 - Add `SensitiveContent` widget to relevant Flutter widgets: https://github.com/flutter/flutter/issues/167302 #### Long-term follow up tasks - Convert this PR to use JNIgen: https://github.com/flutter/flutter/issues/160050. Verify no frames are dropped, revealing sensitive content during media projection: https://github.com/flutter/flutter/issues/164820. #### Stretch goals - Make the `SensitiveContent` widget sensitive to the visibility of child widgets: https://github.com/flutter/flutter/issues/160051 - Implement `autoSensitivity` mode: https://github.com/flutter/flutter/issues/160879 - Investigate backwards compatibility for APIs < 35: https://github.com/flutter/flutter/issues/159208 ### Open questions - ~Is it okay to hard-code the `FlutterActivity` and `FlutterFragment` view IDs? Does this impact add-to-app in any way? I assume we would need extenders of those classes to use a different view ID than the hardcoded one.~ Approach not used. - ~Should we expose `autoSensitive` for now? If so, what behavior should it have?~ Exposing `autoSensitive` as if it works. ### One way to test this PR (rough steps) 1. Create a Flutter app that has some number of `SensitiveContent` widgets. 9. Run the app on an emulator/device that runs API 35 and has the Google meets app downloaded. 10. Start a Google meets meeting and screen share (works with full screen and single app mode). 11. Join the Google meets meeting from another device and witness a blacked out screen if content has been marked sensitive. ## 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]. <!-- 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
2271 lines
81 KiB
Dart
2271 lines
81 KiB
Dart
// Copyright 2014 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
|
|
import 'sensitive_content_utils.dart';
|
|
|
|
void main() {
|
|
// Default content sensitivity setting for testing.
|
|
const ContentSensitivity defaultContentSensitivitySetting = ContentSensitivity.autoSensitive;
|
|
|
|
// The state of content sensitivity in the app.
|
|
final SensitiveContentHost sensitiveContentHost = SensitiveContentHost.instance;
|
|
|
|
// The ContentSenstivity levels that get set by the native platform via calls to
|
|
// `SensitiveContent.setContentSensitivity`.
|
|
List<ContentSensitivity> setContentSensitivityArgs = <ContentSensitivity>[];
|
|
|
|
setUp(() {
|
|
// Reset number of method channel calls to `SensitiveContent.setContentSensitivity`.
|
|
setContentSensitivityArgs = <ContentSensitivity>[];
|
|
|
|
// Mock calls to the sensitive content method channel.
|
|
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
|
|
SystemChannels.sensitiveContent,
|
|
(MethodCall methodCall) async {
|
|
if (methodCall.method == 'SensitiveContent.setContentSensitivity') {
|
|
setContentSensitivityArgs.add(
|
|
ContentSensitivity.values.firstWhere(
|
|
(ContentSensitivity cs) => cs.index == methodCall.arguments as int,
|
|
),
|
|
);
|
|
} else if (methodCall.method == 'SensitiveContent.getContentSensitivity') {
|
|
return defaultContentSensitivitySetting.index;
|
|
} else if (methodCall.method == 'SensitiveContent.isSupported') {
|
|
return true;
|
|
}
|
|
return null;
|
|
},
|
|
);
|
|
});
|
|
|
|
tearDown(() {
|
|
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler(
|
|
SystemChannels.sensitiveContent,
|
|
null,
|
|
);
|
|
});
|
|
|
|
testWidgets('one SenstiveContent widget sets content sensitivity for tree as expected', (
|
|
WidgetTester tester,
|
|
) async {
|
|
await tester.pumpWidget(
|
|
SensitiveContent(sensitivity: ContentSensitivity.sensitive, child: Container()),
|
|
);
|
|
|
|
expect(sensitiveContentHost.calculatedContentSensitivity, equals(ContentSensitivity.sensitive));
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets(
|
|
'disposing only SensitiveContent widget in the tree sets content sensitivity back to the default as expected',
|
|
(WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
SensitiveContent(sensitivity: ContentSensitivity.sensitive, child: Container()),
|
|
);
|
|
await tester.pumpWidget(Container());
|
|
|
|
expect(sensitiveContentHost.calculatedContentSensitivity, isNull);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
defaultContentSensitivitySetting,
|
|
]);
|
|
},
|
|
);
|
|
|
|
group(
|
|
'one sensitive SensitiveContent widget in the tree determines content sensitivity for tree as expected',
|
|
() {
|
|
// Tests with other sensitive widget(s):
|
|
testWidgets('with another sensitive widget', (WidgetTester tester) async {
|
|
await tester.pumpWidget(
|
|
Column(
|
|
children: <Widget>[
|
|
SensitiveContent(sensitivity: ContentSensitivity.sensitive, child: Container()),
|
|
SensitiveContent(sensitivity: ContentSensitivity.sensitive, child: Container()),
|
|
],
|
|
),
|
|
);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(
|
|
setContentSensitivityArgs.every(
|
|
(ContentSensitivity arg) => arg == ContentSensitivity.sensitive,
|
|
),
|
|
isTrue,
|
|
);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with another sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2]));
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('with two other sensitive widgets', (WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc3 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, sc3]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('with two other sensitive widgets and one gets disposed', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc3 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, sc3]));
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
// Tests with auto sensitive widget(s):
|
|
testWidgets('with one auto sensitive widget', (WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with one auto sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1]));
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('with one auto sensitive widget that gets disposed', (WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('with two auto sensitive widgets and one gets disposed', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, asc2]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
// Tests with not sensitive widget(s):
|
|
testWidgets('with one not sensitive widget', (WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, nsc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with one not sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, nsc1]));
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.notSensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('with one not sensitive widget that gets disposed', (WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, nsc1]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('with two not sensitive widgets and one gets disposed', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc2]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
// Tests with an auto sensitive and a not sensitive widget(s):
|
|
testWidgets('with one not sensitive widget and one auto sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets(
|
|
'when it gets disposed with one not sensitive widget and one auto sensitive widget',
|
|
(WidgetTester tester) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc1]));
|
|
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with one not sensitive widget and one auto sensitive widget and auto sensitive widget gets disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with one not sensitive widget and one auto sensitive widget and not sensitive widget gets disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc1]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
// Tests with another sensitive widget, an auto sensitive, and a not sensitive widget:
|
|
testWidgets(
|
|
'with another sensitive widget, one not sensitive widget, and one auto sensitive widget',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, asc1, nsc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when it gets disposed with another sensitive widget, one not sensitive widget, and one auto sensitive widget',
|
|
(WidgetTester tester) async {
|
|
const Key sc1Key = Key('sc1');
|
|
final DisposeTester sc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: sc1Key,
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, asc1, nsc1]));
|
|
|
|
final DisposeTesterState sc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(sc1Key),
|
|
);
|
|
sc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with another sensitive widget, one not sensitive widget, and one auto sensitive widget and the auto sensitive widget is disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, asc1, nsc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with another sensitive widget, one not sensitive widget, and one auto sensitive widget and the not sensitive widget is disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2, asc1, nsc1]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
// Tests with mutliple non-sensitive (auto sensitive, not sensitive) widgets:
|
|
testWidgets(
|
|
'with two auto sensitive widgets and one not sensitive widget and one auto sensitive widget gets disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, asc2, nsc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with one auto sensitive widgets and two not sensitive widgets and one not sensitive widget gets disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent sc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, asc1, nsc1, nsc2]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
},
|
|
);
|
|
|
|
group(
|
|
'one auto-sensitive (with no sensitive SensitiveContent widgets in the tree) determines content sensitivity for tree as expected',
|
|
() {
|
|
// Tests with other auto sensitive widget(s):
|
|
testWidgets('with another auto sensitive widget', (WidgetTester tester) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with another auto sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
// Tests with not sensitive widget(s):
|
|
testWidgets('with one not sensitive widget', (WidgetTester tester) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, nsc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with one not sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, nsc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
});
|
|
|
|
testWidgets('with one not sensitive widget that gets disposed', (WidgetTester tester) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, nsc1]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
testWidgets('with two not sensitive widgets and one gets disposed', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, nsc1, nsc2]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
// Tests with another auto sensitive widget and a not sensitive widget(s):
|
|
testWidgets('with another auto sensitive widget and one not sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2, nsc1]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
testWidgets(
|
|
'when it gets disposed with another auto sensitive widget and one not sensitive widget',
|
|
(WidgetTester tester) async {
|
|
const Key asc1Key = Key('asc1');
|
|
final DisposeTester asc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: asc1Key,
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2, nsc1]));
|
|
|
|
final DisposeTesterState asc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(asc1Key),
|
|
);
|
|
asc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'with another auto sensitive widget and one not sensitive widget and the not sensitive widget gets disposed',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent asc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2, nsc1]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
},
|
|
);
|
|
},
|
|
);
|
|
|
|
group(
|
|
'one not sensitive (with no sensitive or auto sensitive SensitiveContent widgets in the tree) SensitiveContent widget in the tree determines content sensitivity for tree as expected',
|
|
() {
|
|
testWidgets('with another not sensitive widget', (WidgetTester tester) async {
|
|
final SensitiveContent nsc1 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc1, nsc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 1);
|
|
});
|
|
|
|
testWidgets('when it gets disposed with one not sensitive widget', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key nsc1Key = Key('nsc1');
|
|
final DisposeTester nsc1 = DisposeTester(
|
|
child: SensitiveContent(
|
|
key: nsc1Key,
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
),
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc1, nsc2]));
|
|
|
|
final DisposeTesterState nsc1DiposeTesterState = tester.firstState<DisposeTesterState>(
|
|
find.byKey(nsc1Key),
|
|
);
|
|
nsc1DiposeTesterState.disposeWidget();
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
});
|
|
},
|
|
);
|
|
|
|
group('changing SensitiveContent sensitivityLevel updates sensitive content setting as expected', () {
|
|
// Tests for one SensitiveContent widget changing sensitivity:
|
|
testWidgets('when one sensitive SensitiveContent widget changes to sensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('when one sensitive SensitiveContent widget changes to autoSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('when one sensitive SensitiveContent widget changes to notSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.notSensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('when one autoSensitive SensitiveContent widget changes to sensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
});
|
|
|
|
testWidgets('when one autoSensitive SensitiveContent widget changes to autoSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
});
|
|
|
|
testWidgets('when one autoSensitive SensitiveContent widget changes to notSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
});
|
|
|
|
testWidgets('when one notSensitive SensitiveContent widget changes to sensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
|
|
// Change content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('when one notSensitive SensitiveContent widget changes to autoSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
|
|
// Change content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
});
|
|
|
|
testWidgets('when one notSensitive SensitiveContent widget changes to notSensitive', (
|
|
WidgetTester tester,
|
|
) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
|
|
// Change content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
});
|
|
|
|
// Test cases with two SensitiveContent widgets, where one changes states:
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to autoSensitive with another sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key sc1Key = Key('sc1Key');
|
|
const ChangeContentSensitivityTester sc1 = ChangeContentSensitivityTester(
|
|
key: sc1Key,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc1 content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState sc1State = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(sc1Key));
|
|
sc1State.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to notSensitive with another sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key sc1Key = Key('sc1Key');
|
|
const ChangeContentSensitivityTester sc1 = ChangeContentSensitivityTester(
|
|
key: sc1Key,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent sc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc1, sc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc1 content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState sc1State = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(sc1Key));
|
|
sc1State.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to autoSensitive with an autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent asc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc, asc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to notSensitive with an autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent asc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc, asc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to autoSensitive with a notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key scKey = Key('sc1Key');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc, nsc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one sensitive SensitiveContent widget changes to notSensitive with a notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key scKey = Key('scKey');
|
|
const ChangeContentSensitivityTester sc = ChangeContentSensitivityTester(
|
|
key: scKey,
|
|
initialContentSensitivity: ContentSensitivity.sensitive,
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[sc, nsc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change sc content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState scState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(scKey));
|
|
scState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.sensitive,
|
|
ContentSensitivity.notSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to sensitive with a sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key ascKey = Key('ascKey');
|
|
const ChangeContentSensitivityTester asc = ChangeContentSensitivityTester(
|
|
key: ascKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc, sc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change asc content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState ascState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(ascKey));
|
|
ascState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to notSensitive with a sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key ascKey = Key('ascKey');
|
|
const ChangeContentSensitivityTester asc = ChangeContentSensitivityTester(
|
|
key: ascKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc, sc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
|
|
// Change asc content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState ascState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(ascKey));
|
|
ascState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to sensitive with another autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key asc1Key = Key('asc1Key');
|
|
const ChangeContentSensitivityTester asc1 = ChangeContentSensitivityTester(
|
|
key: asc1Key,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change asc1 content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState asc1State = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(asc1Key));
|
|
asc1State.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to notSensitive with another autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key asc1Key = Key('asc1Key');
|
|
const ChangeContentSensitivityTester asc1 = ChangeContentSensitivityTester(
|
|
key: asc1Key,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc1, asc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change asc1 content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState asc1State = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(asc1Key));
|
|
asc1State.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to sensitive with a notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key ascKey = Key('ascKey');
|
|
const ChangeContentSensitivityTester asc = ChangeContentSensitivityTester(
|
|
key: ascKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc, nsc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change asc content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState ascState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(ascKey));
|
|
ascState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one autoSensitive SensitiveContent widget changes to notSensitive with a notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key ascKey = Key('ascKey');
|
|
const ChangeContentSensitivityTester asc = ChangeContentSensitivityTester(
|
|
key: ascKey,
|
|
initialContentSensitivity: ContentSensitivity.autoSensitive,
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[asc, nsc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
|
|
// Change asc content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState ascState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(ascKey));
|
|
ascState.changeContentSensitivityTo(ContentSensitivity.notSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to sensitive with a sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nscKey = Key('nscKey');
|
|
const ChangeContentSensitivityTester nsc = ChangeContentSensitivityTester(
|
|
key: nscKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc, sc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
|
|
// Change nsc content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState nscState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nscKey));
|
|
nscState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to autoSensitive with a sensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nscKey = Key('nscKey');
|
|
const ChangeContentSensitivityTester nsc = ChangeContentSensitivityTester(
|
|
key: nscKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc, sc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
|
|
// Change nsc content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState nscState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nscKey));
|
|
nscState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to sensitive with an autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nscKey = Key('nscKey');
|
|
const ChangeContentSensitivityTester nsc = ChangeContentSensitivityTester(
|
|
key: nscKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent asc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc, asc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
|
|
// Change nsc content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState nscState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nscKey));
|
|
nscState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to autoSensitive with an autoSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nscKey = Key('nscKey');
|
|
const ChangeContentSensitivityTester nsc = ChangeContentSensitivityTester(
|
|
key: nscKey,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent asc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc, asc]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
|
|
// Change nsc content sensitivity to autoSensitive.
|
|
final ChangeContentSensitivityTesterState nscState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nscKey));
|
|
nscState.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to sensitive with another notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nsc1Key = Key('nsc1Key');
|
|
const ChangeContentSensitivityTester nsc1 = ChangeContentSensitivityTester(
|
|
key: nsc1Key,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc1, nsc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
|
|
// Change nsc content sensitivity to sensitive.
|
|
final ChangeContentSensitivityTesterState nscState = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nsc1Key));
|
|
nscState.changeContentSensitivityTo(ContentSensitivity.sensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when one notSensitive SensitiveContent widget changes to autoSensitive with another notSensitive SensitiveContent widget',
|
|
(WidgetTester tester) async {
|
|
const Key nsc1Key = Key('nsc1Key');
|
|
const ChangeContentSensitivityTester nsc1 = ChangeContentSensitivityTester(
|
|
key: nsc1Key,
|
|
initialContentSensitivity: ContentSensitivity.notSensitive,
|
|
);
|
|
final SensitiveContent nsc2 = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
|
|
await tester.pumpWidget(Column(children: <Widget>[nsc1, nsc2]));
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.notSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.notSensitive]);
|
|
|
|
// Change nsc1 content sensitivity to notSensitive.
|
|
final ChangeContentSensitivityTesterState nsc1State = tester
|
|
.firstState<ChangeContentSensitivityTesterState>(find.byKey(nsc1Key));
|
|
nsc1State.changeContentSensitivityTo(ContentSensitivity.autoSensitive);
|
|
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
});
|
|
|
|
group('SensitiveContent children of SensitiveContent widgets behaves as expected', () {
|
|
testWidgets('when a sensitive SensitiveContent widget has any SensitiveContent children', (
|
|
WidgetTester tester,
|
|
) async {
|
|
for (final ContentSensitivity contentSensitivity in ContentSensitivity.values) {
|
|
if (contentSensitivity != ContentSensitivity.autoSensitive ||
|
|
contentSensitivity != ContentSensitivity.sensitive ||
|
|
contentSensitivity != ContentSensitivity.notSensitive) {
|
|
// Ignore ContentSensitivity.unknown for this test.
|
|
break;
|
|
}
|
|
final SensitiveContent scChild = SensitiveContent(
|
|
sensitivity: contentSensitivity,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: scChild,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
}
|
|
});
|
|
|
|
testWidgets(
|
|
'when an autoSensitive SensitiveContent widget has a sensitive SensitiveContent child',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent ascChild = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent sc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: ascChild,
|
|
);
|
|
|
|
await tester.pumpWidget(sc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[ContentSensitivity.sensitive]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when an autoSensitive SensitiveContent widget has an autoSensitive SensitiveContent child',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent ascChild = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: ascChild,
|
|
);
|
|
|
|
await tester.pumpWidget(asc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when an autoSensitive SensitiveContent widget has an notSensitive SensitiveContent child',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent nscChild = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent asc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: nscChild,
|
|
);
|
|
|
|
await tester.pumpWidget(asc);
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs.length, 0);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when an notSensitive SensitiveContent widget has a sensitive SensitiveContent child',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent scChild = SensitiveContent(
|
|
sensitivity: ContentSensitivity.sensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: scChild,
|
|
);
|
|
|
|
await tester.pumpWidget(nsc);
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.sensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.sensitive,
|
|
]);
|
|
},
|
|
);
|
|
|
|
testWidgets(
|
|
'when an notSensitive SensitiveContent widget has an autoSensitive SensitiveContent child',
|
|
(WidgetTester tester) async {
|
|
final SensitiveContent ascChild = SensitiveContent(
|
|
sensitivity: ContentSensitivity.autoSensitive,
|
|
child: Container(),
|
|
);
|
|
final SensitiveContent nsc = SensitiveContent(
|
|
sensitivity: ContentSensitivity.notSensitive,
|
|
child: ascChild,
|
|
);
|
|
|
|
await tester.pumpWidget(nsc);
|
|
await tester.pump();
|
|
|
|
expect(
|
|
sensitiveContentHost.calculatedContentSensitivity,
|
|
equals(ContentSensitivity.autoSensitive),
|
|
);
|
|
expect(setContentSensitivityArgs, <ContentSensitivity>[
|
|
ContentSensitivity.notSensitive,
|
|
ContentSensitivity.autoSensitive,
|
|
]);
|
|
},
|
|
);
|
|
});
|
|
}
|