override_test.dart 10.4 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6 7 8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:flutter_test/flutter_test.dart';
9 10 11 12 13 14 15 16
import 'package:intl/intl.dart' as intl;

class FooMaterialLocalizations extends MaterialLocalizationEn {
  FooMaterialLocalizations(
    Locale localeName,
    this.backButtonTooltip,
  ) : super(
    localeName: localeName.toString(),
17
    fullYearFormat: intl.DateFormat.y(),
18 19
    compactDateFormat: intl.DateFormat.yMd(),
    shortDateFormat: intl.DateFormat.yMMMd(),
20 21 22
    mediumDateFormat: intl.DateFormat('E, MMM\u00a0d'),
    longDateFormat: intl.DateFormat.yMMMMEEEEd(),
    yearMonthFormat: intl.DateFormat.yMMMM(),
23
    shortMonthDayFormat: intl.DateFormat.MMMd(),
24 25
    decimalFormat: intl.NumberFormat.decimalPattern(),
    twoDigitZeroPaddedFormat: intl.NumberFormat('00'),
26
  );
27 28

  @override
29
  final String backButtonTooltip;
30 31 32
}

class FooMaterialLocalizationsDelegate extends LocalizationsDelegate<MaterialLocalizations> {
33
  const FooMaterialLocalizationsDelegate({
34
    this.supportedLanguage = 'en',
35
    this.backButtonTooltip = 'foo',
36 37 38 39 40 41 42
  });

  final String supportedLanguage;
  final String backButtonTooltip;

  @override
  bool isSupported(Locale locale) {
43
    return supportedLanguage == 'allLanguages' || locale.languageCode == supportedLanguage;
44
  }
45 46 47

  @override
  Future<FooMaterialLocalizations> load(Locale locale) {
48
    return SynchronousFuture<FooMaterialLocalizations>(FooMaterialLocalizations(locale, backButtonTooltip));
49 50 51 52 53 54 55
  }

  @override
  bool shouldReload(FooMaterialLocalizationsDelegate old) => false;
}

Widget buildFrame({
56
  Locale? locale,
57
  Iterable<LocalizationsDelegate<dynamic>> delegates = GlobalMaterialLocalizations.delegates,
58 59
  required WidgetBuilder buildContent,
  LocaleResolutionCallback? localeResolutionCallback,
60
  Iterable<Locale> supportedLocales = const <Locale>[
61
    Locale('en', 'US'),
62
    Locale('es', 'ES'),
63 64
  ],
}) {
65
  return MaterialApp(
66 67 68 69 70 71
    color: const Color(0xFFFFFFFF),
    locale: locale,
    supportedLocales: supportedLocales,
    localizationsDelegates: delegates,
    localeResolutionCallback: localeResolutionCallback,
    onGenerateRoute: (RouteSettings settings) {
72
      return MaterialPageRoute<void>(
73 74 75 76 77 78 79 80 81 82
        builder: (BuildContext context) {
          return buildContent(context);
        }
      );
    },
  );
}

void main() {
  testWidgets('Locale fallbacks', (WidgetTester tester) async {
83
    final Key textKey = UniqueKey();
84 85 86 87

    await tester.pumpWidget(
      buildFrame(
        buildContent: (BuildContext context) {
88
          return Text(
89 90 91 92 93 94 95 96 97 98
            MaterialLocalizations.of(context).backButtonTooltip,
            key: textKey,
          );
        }
      )
    );

    expect(tester.widget<Text>(find.byKey(textKey)).data, 'Back');

    // Unrecognized locale falls back to 'en'
99
    await tester.binding.setLocale('foo', 'BAR');
100 101 102 103
    await tester.pump();
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'Back');

    // Spanish Bolivia locale, falls back to just 'es'
104
    await tester.binding.setLocale('es', 'BO');
105
    await tester.pump();
106
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'Atrás');
107 108
  });

109
  testWidgets("Localizations.override widget tracks parent's locale", (WidgetTester tester) async {
110 111 112
    Widget buildLocaleFrame(Locale locale) {
      return buildFrame(
        locale: locale,
113
        supportedLocales: <Locale>[locale],
114
        buildContent: (BuildContext context) {
115
          return Localizations.override(
116
            context: context,
117
            child: Builder(
118 119 120 121 122
              builder: (BuildContext context) {
                // No MaterialLocalizations are defined for the first Localizations
                // ancestor, so we should get the values from the default one, i.e.
                // the one created by WidgetsApp via the LocalizationsDelegate
                // provided by MaterialApp.
123
                return Text(MaterialLocalizations.of(context).backButtonTooltip);
124 125 126
              },
            ),
          );
127
        },
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
      );
    }

    await tester.pumpWidget(buildLocaleFrame(const Locale('en', 'US')));
    expect(find.text('Back'), findsOneWidget);

    await tester.pumpWidget(buildLocaleFrame(const Locale('de', 'DE')));
    expect(find.text('Zurück'), findsOneWidget);

    await tester.pumpWidget(buildLocaleFrame(const Locale('zh', 'CN')));
    expect(find.text('返回'), findsOneWidget);
  });

  testWidgets('Localizations.override widget with hardwired locale', (WidgetTester tester) async {
    Widget buildLocaleFrame(Locale locale) {
      return buildFrame(
        locale: locale,
        buildContent: (BuildContext context) {
146
          return Localizations.override(
147 148
            context: context,
            locale: const Locale('en', 'US'),
149
            child: Builder(
150 151 152 153 154
              builder: (BuildContext context) {
                // No MaterialLocalizations are defined for the Localizations.override
                // ancestor, so we should get all values from the default one, i.e.
                // the one created by WidgetsApp via the LocalizationsDelegate
                // provided by MaterialApp.
155
                return Text(MaterialLocalizations.of(context).backButtonTooltip);
156 157 158
              },
            ),
          );
159
        },
160 161 162 163 164 165 166 167 168 169 170 171 172
      );
    }

    await tester.pumpWidget(buildLocaleFrame(const Locale('en', 'US')));
    expect(find.text('Back'), findsOneWidget);

    await tester.pumpWidget(buildLocaleFrame(const Locale('de', 'DE')));
    expect(find.text('Back'), findsOneWidget);

    await tester.pumpWidget(buildLocaleFrame(const Locale('zh', 'CN')));
    expect(find.text('Back'), findsOneWidget);
  });

173
  testWidgets('MaterialApp adds MaterialLocalizations for additional languages', (WidgetTester tester) async {
174
    final Key textKey = UniqueKey();
175 176 177

    await tester.pumpWidget(
      buildFrame(
178
        delegates: <LocalizationsDelegate<dynamic>>[
179 180
          const FooMaterialLocalizationsDelegate(supportedLanguage: 'fr', backButtonTooltip: 'FR'),
          const FooMaterialLocalizationsDelegate(supportedLanguage: 'de', backButtonTooltip: 'DE'),
181
          GlobalCupertinoLocalizations.delegate,
182 183
        ],
        supportedLocales: const <Locale>[
184 185 186
          Locale('en'),
          Locale('fr'),
          Locale('de'),
187 188
        ],
        buildContent: (BuildContext context) {
189
          return Text(
190 191 192
            MaterialLocalizations.of(context).backButtonTooltip,
            key: textKey,
          );
193
        },
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
      )
    );

    expect(tester.widget<Text>(find.byKey(textKey)).data, 'Back');

    await tester.binding.setLocale('fr', 'CA');
    await tester.pump();
    expect(find.text('FR'), findsOneWidget);

    await tester.binding.setLocale('de', 'DE');
    await tester.pump();
    expect(find.text('DE'), findsOneWidget);
  });

  testWidgets('MaterialApp overrides MaterialLocalizations for all locales', (WidgetTester tester) async {
209
    final Key textKey = UniqueKey();
210 211 212 213

    await tester.pumpWidget(
      buildFrame(
        // Accept whatever locale we're given
214
        localeResolutionCallback: (Locale? locale, Iterable<Locale> supportedLocales) => locale,
215
        delegates: <LocalizationsDelegate<dynamic>>[
216
          const FooMaterialLocalizationsDelegate(supportedLanguage: 'allLanguages'),
217
          GlobalCupertinoLocalizations.delegate,
218 219 220
        ],
        buildContent: (BuildContext context) {
          // Should always be 'foo', no matter what the locale is
221
          return Text(
222 223 224
            MaterialLocalizations.of(context).backButtonTooltip,
            key: textKey,
          );
225
        },
226 227 228 229 230 231 232 233 234 235 236 237 238 239
      )
    );

    expect(tester.widget<Text>(find.byKey(textKey)).data, 'foo');

    await tester.binding.setLocale('zh', 'CN');
    await tester.pump();
    expect(find.text('foo'), findsOneWidget);

    await tester.binding.setLocale('de', 'DE');
    await tester.pump();
    expect(find.text('foo'), findsOneWidget);
  });

240
  testWidgets('MaterialApp overrides MaterialLocalizations for default locale', (WidgetTester tester) async {
241
    final Key textKey = UniqueKey();
242 243 244

    await tester.pumpWidget(
      buildFrame(
245
        delegates: <LocalizationsDelegate<dynamic>>[
246
          const FooMaterialLocalizationsDelegate(),
247
          GlobalCupertinoLocalizations.delegate,
248 249 250
        ],
        // supportedLocales not specified, so all locales resolve to 'en'
        buildContent: (BuildContext context) {
251
          return Text(
252 253 254
            MaterialLocalizations.of(context).backButtonTooltip,
            key: textKey,
          );
255
        },
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
      )
    );

    // Unsupported locale '_' (the widget tester's default) resolves to 'en'.
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'foo');

    // Unsupported locale 'zh' resolves to 'en'.
    await tester.binding.setLocale('zh', 'CN');
    await tester.pump();
    expect(find.text('foo'), findsOneWidget);

    // Unsupported locale 'de' resolves to 'en'.
    await tester.binding.setLocale('de', 'DE');
    await tester.pump();
    expect(find.text('foo'), findsOneWidget);
  });

273
  testWidgets('deprecated Android/Java locales are modernized', (WidgetTester tester) async {
274
    final Key textKey = UniqueKey();
275 276 277 278 279 280 281 282 283 284

    await tester.pumpWidget(
      buildFrame(
        supportedLocales: <Locale>[
          const Locale('en', 'US'),
          const Locale('he', 'IL'),
          const Locale('yi', 'IL'),
          const Locale('id', 'JV'),
        ],
        buildContent: (BuildContext context) {
285
          return Text(
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
            '${Localizations.localeOf(context)}',
            key: textKey,
          );
        },
      )
    );

    expect(tester.widget<Text>(find.byKey(textKey)).data, 'en_US');

    // Hebrew was iw (ISO-639) is he (ISO-639-1)
    await tester.binding.setLocale('iw', 'IL');
    await tester.pump();
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'he_IL');

    // Yiddish was ji (ISO-639) is yi (ISO-639-1)
    await tester.binding.setLocale('ji', 'IL');
    await tester.pump();
303
    expect(tester.takeException(), "Warning: This application's locale, yi_IL, is not supported by all of its localization delegates.");
304 305 306 307 308 309 310 311
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'yi_IL');

    // Indonesian was in (ISO-639) is id (ISO-639-1)
    await tester.binding.setLocale('in', 'JV');
    await tester.pump();
    expect(tester.widget<Text>(find.byKey(textKey)).data, 'id_JV');
  });
}