Dataset Viewer
code
stringlengths 8
3.25M
| repository
stringlengths 15
175
| metadata
stringlengths 66
249
|
|---|---|---|
import 'package:flutter/material.dart';
class XMargin extends StatelessWidget {
const XMargin(this.width, {super.key});
final double width;
@override
Widget build(BuildContext context) {
return SizedBox(
width: width,
);
}
}
| Calculator-Flutter/lib/utils/margins/x_margin.dart/0 | {'file_path': 'Calculator-Flutter/lib/utils/margins/x_margin.dart', 'repo_id': 'Calculator-Flutter', 'token_count': 91} |
analyzer:
exclude:
- nested_flutter_example/**
| Dart-Code/src/test/test_projects/dart_nested_flutter2/analysis_options.yaml/0 | {'file_path': 'Dart-Code/src/test/test_projects/dart_nested_flutter2/analysis_options.yaml', 'repo_id': 'Dart-Code', 'token_count': 20} |
import 'package:hello_world/deferred_script.dart' deferred as def;
main() async {
await def.loadLibrary();
def.do_print();
}
| Dart-Code/src/test/test_projects/hello_world/bin/deferred_entry.dart/0 | {'file_path': 'Dart-Code/src/test/test_projects/hello_world/bin/deferred_entry.dart', 'repo_id': 'Dart-Code', 'token_count': 45} |
name: hello_world_example
publish_to: none
environment:
sdk: '>=2.12.0 <3.0.0'
dev_dependencies:
test: '>=0.12.34'
| Dart-Code/src/test/test_projects/hello_world/example/pubspec.yaml/0 | {'file_path': 'Dart-Code/src/test/test_projects/hello_world/example/pubspec.yaml', 'repo_id': 'Dart-Code', 'token_count': 59} |
part 'part.dart';
| Dart-Code/src/test/test_projects/hello_world/lib/part_wrapper.dart/0 | {'file_path': 'Dart-Code/src/test/test_projects/hello_world/lib/part_wrapper.dart', 'repo_id': 'Dart-Code', 'token_count': 8} |
import "package:test/test.dart";
// This comment is extracted by the test and compared to a text representation
// built from the tree provider in the test. It must be maintained to match
// the results from the tests below.
// == EXPECTED RESULTS ==
// test/short_test.dart [1/1 passed] Passed
// group1 [1/1 passed] Passed
// test1 Passed
// == /EXPECTED RESULTS ==
void main() {
group("group1", () {
test("test1", () {});
});
}
| Dart-Code/src/test/test_projects/hello_world/test/short_test.dart/0 | {'file_path': 'Dart-Code/src/test/test_projects/hello_world/test/short_test.dart', 'repo_id': 'Dart-Code', 'token_count': 150} |
import 'package:first_desktop_application/app-level/assets/assets.dart';
import 'package:first_desktop_application/app-level/styles/colors.dart';
import 'package:first_desktop_application/app-level/utils/screen_size.dart';
import 'package:flutter/material.dart';
import 'image_loader.dart';
import 'link_content.dart';
typedef OnFavClick = void Function();
class ParallaxButton extends StatefulWidget {
const ParallaxButton({
Key key,
this.text,
@required this.medium,
@required this.website,
@required this.youtubeLink,
@required this.isFavorite,
}) : super(key: key);
final String medium;
final String website;
final String youtubeLink;
final bool isFavorite;
final String text;
@override
_ParallaxButtonState createState() => _ParallaxButtonState();
}
class _ParallaxButtonState extends State<ParallaxButton> {
ShapeBorder get shape => const RoundedRectangleBorder(
borderRadius: BorderRadius.only(
topLeft: Radius.circular(32.0),
topRight: Radius.circular(32.0),
),
);
double get _height => ScreenQueries.instance.height(context);
double get _width => ScreenQueries.instance.width(context);
double localX = 0;
double localY = 0;
bool defaultPosition = true;
double percentageX;
double percentageY;
@override
Widget build(BuildContext context) {
//
return SizedBox(
width: (_width * 0.15).roundToDouble(),
height: (_height * 0.41).roundToDouble(),
child: LayoutBuilder(
builder: (context, constraints) {
//
final _maxHeight = constraints.maxHeight;
final _maxWidth = constraints.maxWidth;
percentageX = (localX / _maxWidth) * 100;
percentageY = (localY / _maxHeight) * 100;
final _rotateX =
defaultPosition ? 0 : (0.3 * (percentageY / 50) + -0.3);
final _rotateY =
defaultPosition ? 0 : (-0.3 * (percentageX / 50) + 0.3);
final _translateX =
defaultPosition ? 0.0 : (15 * (percentageX / 50) + -15);
final _translateY =
defaultPosition ? 0.0 : (15 * (percentageY / 50) + -15);
return GestureDetector(
onPanStart: onPanStart,
onPanUpdate: (details) =>
onPanUpdate(details, _maxHeight, _maxWidth),
onPanEnd: (details) => onPanEnd(details, _maxHeight, _maxWidth),
onPanCancel: onPanCancel,
onPanDown: onPanDown,
child: Transform(
alignment: FractionalOffset.center,
transform: Matrix4.identity()
..setEntry(3, 2, 0.001)
..rotateX(_rotateX.ceilToDouble())
..rotateY(_rotateY.ceilToDouble()),
child: Stack(
fit: StackFit.expand,
children: [
Card(
color: AppColors.brandColor,
margin:
const EdgeInsets.only(left: 8, right: 8, bottom: 24),
elevation: 8,
shape: shape,
child: Transform(
alignment: FractionalOffset.center,
transform: Matrix4.identity()
..translate(_translateX, _translateY, 0),
child: Column(
children: [
const Expanded(
flex: 2,
child: ClipRRect(
borderRadius: BorderRadius.vertical(
top: Radius.circular(32),
),
child: ImageWidgetPlaceholder(
image: WebAssets.logo,
width: double.maxFinite,
fit: BoxFit.fitWidth,
),
),
),
Expanded(
child: Container(
color: Colors.grey.shade200,
child: LinkContent(
isFavorite: widget.isFavorite,
medium: widget.medium,
text: widget.text,
website: widget.website,
youtubeLink: widget.youtubeLink,
),
),
),
],
),
),
),
],
),
),
);
},
),
);
}
void onPanStart(DragStartDetails details) {}
void onPanUpdate(DragUpdateDetails details, double height, double width) {
setState(() {
if (mounted) {
defaultPosition = false;
}
final _localPos = details.localPosition;
if (_localPos.dx > 0 && _localPos.dy < height) {
localX = _localPos.dx;
localY = _localPos.dy;
}
});
}
void onPanEnd(DragEndDetails details, double height, double width) {
setState(() {
localX = width / 2;
localY = height / 2;
defaultPosition = true;
});
}
void onPanCancel() {
setState(() => defaultPosition = true);
}
void onPanDown(DragDownDetails details) {
setState(() => defaultPosition = false);
}
}
// https://medium.com/flutter-community/flutter-mouse-hover-parallax-effect-116b85bb5a80
| Experiments_with_Desktop/first_desktop_application/lib/app-level/widgets/parallax_btn.dart/0 | {'file_path': 'Experiments_with_Desktop/first_desktop_application/lib/app-level/widgets/parallax_btn.dart', 'repo_id': 'Experiments_with_Desktop', 'token_count': 2921} |
// ignore_for_file: leading_newlines_in_multiline_strings,unnecessary_string_escapes,avoid_print
class TerminalBlock {
TerminalBlock._();
static void blockBoy([
String message =
'This is Aseem Wangoo! Visit flatteredwithflutter.com for more details',
]) {
print('''
.-"""-.
/ .===. \
\/ 6 6 \/
( \___/ )
_________________ooo__\_____/_____________________
/ \
| $message |
\______________________________ooo_________________/
| | |
|_ | _|
| | |
|__|__|
/-'Y'-\
(__/ \__)''');
}
}
| Experiments_with_Desktop/first_desktop_application/lib/ffi/utils/terminal_blocks.dart/0 | {'file_path': 'Experiments_with_Desktop/first_desktop_application/lib/ffi/utils/terminal_blocks.dart', 'repo_id': 'Experiments_with_Desktop', 'token_count': 488} |
import 'package:first_desktop_application/inking/constants.dart';
import 'package:flutter/material.dart';
class DarkInkContent extends StatelessWidget {
final bool darkMode;
// TODO(Aseem): Add scroll
const DarkInkContent({Key key, this.darkMode = false}) : super(key: key);
@override
Widget build(BuildContext context) {
const lightTextColor = Color(0xFFBCFEEA);
const lightSubHeaderColor = Color(0xFF00EBAC);
const darkSubHeaderColor = Color(0xFF008F9C);
const darkTextColor = Color(0xFF210A3B);
return SingleChildScrollView(
child: Container(
color: darkMode ? const Color(0xFF313466) : const Color(0xFFFFFFFF),
padding: const EdgeInsets.all(37.0),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
InkingConstants.headerText,
style: TextStyle(
fontSize: 36,
fontFamily: 'Merriweather',
fontWeight: FontWeight.bold,
color: darkMode ? lightTextColor : darkTextColor,
decoration: TextDecoration.none,
),
),
const Padding(padding: EdgeInsets.only(top: 24.0)),
Text(
InkingConstants.subHeaderText,
style: TextStyle(
fontSize: 12,
fontFamily: 'Merriweather',
color: darkMode ? lightSubHeaderColor : darkSubHeaderColor,
decoration: TextDecoration.none,
),
),
const Padding(padding: EdgeInsets.only(top: 12)),
Container(
height: 1.0,
color:
darkMode ? const Color(0x510098A3) : const Color(0x512B777E),
),
const Padding(padding: EdgeInsets.only(top: 24.0)),
Text(
InkingConstants.bodyText,
style: TextStyle(
fontSize: 16,
fontFamily: 'Barlow',
letterSpacing: 0.5,
height: 1.5,
fontWeight: FontWeight.w500,
color: darkMode ? lightTextColor : darkTextColor,
decoration: TextDecoration.none,
),
),
const Padding(padding: EdgeInsets.only(top: 64.0)),
],
),
),
);
}
}
| Experiments_with_Desktop/first_desktop_application/lib/inking/widgets/dark_ink_content.dart/0 | {'file_path': 'Experiments_with_Desktop/first_desktop_application/lib/inking/widgets/dark_ink_content.dart', 'repo_id': 'Experiments_with_Desktop', 'token_count': 1200} |
import 'dart:math';
import 'package:flutter/material.dart';
class RoundedShadow extends StatelessWidget {
final Widget child;
final Color shadowColor;
final double topLeftRadius;
final double topRightRadius;
final double bottomLeftRadius;
final double bottomRightRadius;
const RoundedShadow({
Key key,
this.child,
this.shadowColor,
this.topLeftRadius = 48,
this.topRightRadius = 48,
this.bottomLeftRadius = 48,
this.bottomRightRadius = 48,
}) : super(key: key);
const RoundedShadow.fromRadius(
double radius, {
this.child,
this.shadowColor,
}) : topLeftRadius = radius,
topRightRadius = radius,
bottomRightRadius = radius,
bottomLeftRadius = radius;
@override
Widget build(BuildContext context) {
// Create a border radius, only applies to the bottom
final BorderRadius borderRadius = BorderRadius.only(
topLeft: Radius.circular(topLeftRadius),
topRight: Radius.circular(topRightRadius),
bottomLeft: Radius.circular(bottomLeftRadius),
bottomRight: Radius.circular(bottomRightRadius),
);
final Color sColor = shadowColor ?? const Color(0x20000000);
final double maxRadius = [
topLeftRadius,
topRightRadius,
bottomLeftRadius,
bottomRightRadius
].reduce(max);
return Container(
decoration: BoxDecoration(
borderRadius: borderRadius,
boxShadow: [
BoxShadow(color: sColor, blurRadius: maxRadius * .5),
],
),
child: ClipRRect(
borderRadius: borderRadius,
child: child,
),
);
}
}
| Experiments_with_Desktop/first_desktop_application/lib/liquid_cards/widgets/rounded_shadow.dart/0 | {'file_path': 'Experiments_with_Desktop/first_desktop_application/lib/liquid_cards/widgets/rounded_shadow.dart', 'repo_id': 'Experiments_with_Desktop', 'token_count': 632} |
import 'package:dartz/dartz.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:xafe/app/authentication/data/datasource/authentication_data_source.dart';
import 'package:xafe/app/authentication/data/models/user_model.dart';
import 'package:xafe/app/authentication/domain/params/post_params/post_params.dart';
import 'package:xafe/app/authentication/domain/repository/authentication_repo.dart';
import 'package:xafe/core/error/failures.dart';
import 'package:xafe/core/error/helpers/helpers.dart';
class AuthenticationRepoImpl implements AuthenticationRepo {
AuthenticationRepoImpl({
this.authenticationDataSource,
});
final AuthenticationDataSource authenticationDataSource;
@override
Future<Either<Failure, User>> loginUser(EmailPasswordParams params) async {
return successFailureInterceptor(
() => authenticationDataSource.postLoginUser(params),
);
}
@override
Future<Either<Failure, User>> registerUser(EmailPasswordParams params) {
return successFailureInterceptor(
() => authenticationDataSource.postRegisterUser(params),
);
}
@override
Future<Either<Failure, void>> createUser(UserModel params) {
return successFailureInterceptor(
() => authenticationDataSource.postCreateUser(params),
);
}
@override
Future<Either<Failure, UserModel>> getUser(String id) {
return successFailureInterceptor(
() => authenticationDataSource.postGetUser(id),
);
}
}
| Xafe/lib/app/authentication/data/repository/authentication_repo_impl.dart/0 | {'file_path': 'Xafe/lib/app/authentication/data/repository/authentication_repo_impl.dart', 'repo_id': 'Xafe', 'token_count': 466} |
import 'package:xafe/app/budget/data/datasource/budget_datasource.dart';
import 'package:xafe/app/budget/data/datasource/impl/budget_datasource_impl.dart';
import 'package:xafe/app/budget/data/repository/budget_repo_impl.dart';
import 'package:xafe/app/budget/domain/repository/budget_repo.dart';
import 'package:xafe/app/budget/domain/usecases/create_budget.dart';
import 'package:xafe/app/budget/domain/usecases/create_budget_expense.dart';
import 'package:xafe/app/budget/domain/usecases/delete_budget.dart';
import 'package:xafe/app/budget/domain/usecases/edit_budget.dart';
import 'package:xafe/app/budget/domain/usecases/listen_to_budgets.dart';
import 'package:xafe/core/config/di_config.dart';
import 'domain/usecases/listen_to_budget_expenses.dart';
void registerBudgetsDIs() {
//Use cases
locator.registerLazySingleton(() => CreateBudget(locator()));
locator.registerLazySingleton(() => CreateBudgetExpense(locator()));
locator.registerLazySingleton(() => DeleteBudget(locator()));
locator.registerLazySingleton(() => EditBudget(locator()));
locator.registerLazySingleton(() => ListenToBudgets(locator()));
locator.registerLazySingleton(() => ListenToBudgetExpenses(locator()));
//Repository
locator.registerLazySingleton<BudgetRepo>(
() => BudgetRepoImpl(
locator(),
),
);
// Data sources
locator.registerLazySingleton<BudgetDataSource>(
() => BudgetDataSourceImpl(
locator(),
),
);
}
| Xafe/lib/app/budget/budget_dependencies.dart/0 | {'file_path': 'Xafe/lib/app/budget/budget_dependencies.dart', 'repo_id': 'Xafe', 'token_count': 530} |
import 'package:flutter/material.dart';
import 'package:stacked/stacked.dart';
import 'package:uuid/uuid.dart';
import 'package:xafe/app/categories/data/model/category_model.dart';
import 'package:xafe/app/categories/presentation/logic/viewmodels/create_category_viewmodel.dart';
import 'package:xafe/core/config/di_config.dart';
import 'package:xafe/src/res/components/back_arrow/src/app_back_arrow.dart';
import 'package:xafe/src/res/components/buttons/src/xafe_button.dart';
import 'package:xafe/src/res/res.dart';
import 'package:xafe/src/utils/scaler/scaler.dart';
class AddSpendingCategoryScreen extends StatefulWidget {
@override
_AddSpendingCategoryScreenState createState() =>
_AddSpendingCategoryScreenState();
}
class _AddSpendingCategoryScreenState extends State<AddSpendingCategoryScreen> {
final _categoryEmojis = [
'🍖',
'✈️',
'🤵♂️',
'🛒',
'🏥',
'🏡',
'🎥',
];
final ValueNotifier<String> _currentSelectedValue = ValueNotifier(null);
TextEditingController _categoryNameController;
TextEditingController _categoryEmojiController;
@override
void initState() {
super.initState();
_categoryNameController = TextEditingController(
text: '',
);
_categoryEmojiController = TextEditingController(
text: '',
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
resizeToAvoidBottomInset: true,
body: Padding(
padding: context.insetsSymetric(
horizontal: 20.0,
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
const YMargin(66.45),
KAppBackArrow(),
const YMargin(60.45),
const Text(
'Add a spending category',
style: TextStyle(
fontWeight: FontWeight.w400,
fontSize: 24,
color: kColorAppBlack,
),
),
const YMargin(35),
TextFormField(
decoration:
const InputDecoration(hintText: 'Enter category name'),
controller: _categoryNameController,
),
const YMargin(10),
ValueListenableBuilder(
valueListenable: _currentSelectedValue,
builder: (_, value, child) {
return DropdownButtonFormField(
iconEnabledColor: kColorAppBlack,
iconDisabledColor: kColorAppBlack,
value: value,
onChanged: (value) {
_currentSelectedValue.value = value;
},
items: _categoryEmojis.map((String value) {
return DropdownMenuItem<String>(
value: value,
child: Text(value),
);
}).toList(),
decoration: const InputDecoration(
hintText: 'Choose category emoji',
),
);
}),
const Spacer(),
ViewModelBuilder<CreateCategoryViewmodel>.reactive(
viewModelBuilder: () => CreateCategoryViewmodel(locator()),
builder: (_, model, __) {
return XafeButton(
isLoading: model.isBusy,
onPressed: () {
model.createCategory(
params: CategoryModel(
categoryId: const Uuid().v4(),
categoryName: _categoryNameController.text,
categoryEmoji: _currentSelectedValue.value,
),
context: context,
);
},
text: 'Create Category',
);
}),
const YMargin(80),
],
),
),
);
}
}
| Xafe/lib/app/categories/presentation/screens/add_spending_category_screen.dart/0 | {'file_path': 'Xafe/lib/app/categories/presentation/screens/add_spending_category_screen.dart', 'repo_id': 'Xafe', 'token_count': 2081} |
export 'services/auth_service.dart';
export 'services/firestore_service.dart';
| Xafe/lib/core/config/firebase/firebase.dart/0 | {'file_path': 'Xafe/lib/core/config/firebase/firebase.dart', 'repo_id': 'Xafe', 'token_count': 25} |
import 'package:flutter/material.dart';
import 'package:flutter_svg/svg.dart';
import 'package:xafe/src/res/values/assets/svgs/svgs.dart';
import 'package:xafe/src/utils/navigation/navigation.dart';
import 'package:xafe/src/utils/scaler/scaler.dart';
class KAppBackArrow extends StatelessWidget {
@override
Widget build(BuildContext context) {
return InkWell(
onTap: () => popView(context),
child: SvgPicture.asset(
kBackArrowIcon,
height: context.scaleY(19),
),
);
}
}
| Xafe/lib/src/res/components/back_arrow/src/app_back_arrow.dart/0 | {'file_path': 'Xafe/lib/src/res/components/back_arrow/src/app_back_arrow.dart', 'repo_id': 'Xafe', 'token_count': 213} |
import 'package:flutter/widgets.dart';
import 'scale.dart';
import 'scale_aware.dart';
extension BuildContextExtensions on BuildContext {
Scale get _scale {
// ignore: always_specify_types
final data = MediaQuery.of(this);
return Scale(
size: data.size,
textScaleFactor: data.textScaleFactor,
config: ScaleAware.of(this));
}
/// Pixels scaled per device from design.
/// Where One pixel on a 160px screen equals two pixels on a 320px screen.
/// Also and alias for scaleX
double scale(num width) => _scale.scale(width);
/// Pixels scaled per device from design in the Vertical direction.
/// Where One pixel on a 160px screen equals two pixels on a 320px screen.
double scaleY(num height) => _scale.scaleY(height);
/// Relative to the font-size setting of the actual device
double fontSize(num fontSize) => _scale.fontScale(fontSize);
EdgeInsets insetsZero() => _scale.zero;
///.
EdgeInsets insetsAll(num inset) => _scale.all(inset.toDouble());
///.
EdgeInsets insetsOnly({
double left = 0,
double top = 0,
double right = 0,
double bottom = 0,
}) =>
_scale.only(left, top, right, bottom);
///.
EdgeInsets insetsFromLTRB({
double left = 0,
double top = 0,
double right = 0,
double bottom = 0,
}) =>
_scale.fromLTRB(left, top, right, bottom);
///.
EdgeInsets insetsSymetric({
double vertical = 0,
double horizontal = 0,
}) =>
_scale.symmetric(vertical, horizontal);
double get height => MediaQuery.of(this).size.height;
double get width => MediaQuery.of(this).size.width;
}
| Xafe/lib/src/utils/scaler/src/extensions.dart/0 | {'file_path': 'Xafe/lib/src/utils/scaler/src/extensions.dart', 'repo_id': 'Xafe', 'token_count': 567} |
import 'package:equatable/equatable.dart';
import 'package:{{project_name.snakeCase()}}/models/Todo.dart';
enum TodosPageStatus { initial, loading, success, failure }
class TodosPageState extends Equatable {
const TodosPageState({
this.status = TodosPageStatus.initial,
this.todos = const [],
});
final TodosPageStatus status;
final List<Todo> todos;
TodosPageState copyWith({
TodosPageStatus Function()? status,
List<Todo> Function()? todos,
}) =>
TodosPageState(
status: status != null ? status() : this.status,
todos: todos != null ? todos() : this.todos,
);
@override
List<Object?> get props => [
status,
todos,
];
}
| amplify_starter/__brick__/{{project_name}}/lib/todos/todos_list/bloc/todos_page_states.dart/0 | {'file_path': 'amplify_starter/__brick__/{{project_name}}/lib/todos/todos_list/bloc/todos_page_states.dart', 'repo_id': 'amplify_starter', 'token_count': 284} |
import 'dart:convert';
class Utils {
static String formatJson(jsonObj) {
// ignore: prefer_final_locals
JsonEncoder encoder = new JsonEncoder.withIndent(' ');
return encoder.convert(jsonObj);
}
}
| appsflyer-flutter-plugin/example/lib/utils.dart/0 | {'file_path': 'appsflyer-flutter-plugin/example/lib/utils.dart', 'repo_id': 'appsflyer-flutter-plugin', 'token_count': 83} |
part of appsflyer_sdk;
class AppsFlyerOptions {
final String afDevKey;
final bool showDebug;
final String appId;
final double? timeToWaitForATTUserAuthorization;
final String? appInviteOneLink;
final bool? disableAdvertisingIdentifier;
final bool? disableCollectASA;
AppsFlyerOptions({
required this.afDevKey,
this.showDebug = false,
this.appId = "",
this.timeToWaitForATTUserAuthorization,
this.appInviteOneLink,
this.disableAdvertisingIdentifier,
this.disableCollectASA,
});
}
| appsflyer-flutter-plugin/lib/src/appsflyer_options.dart/0 | {'file_path': 'appsflyer-flutter-plugin/lib/src/appsflyer_options.dart', 'repo_id': 'appsflyer-flutter-plugin', 'token_count': 181} |
export 'view/app.dart';
| article-hub/flame-game/sample/lib/app/app.dart/0 | {'file_path': 'article-hub/flame-game/sample/lib/app/app.dart', 'repo_id': 'article-hub', 'token_count': 10} |
export 'title_page.dart';
| article-hub/flame-game/sample/lib/title/view/view.dart/0 | {'file_path': 'article-hub/flame-game/sample/lib/title/view/view.dart', 'repo_id': 'article-hub', 'token_count': 10} |
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mockingjay/mockingjay.dart';
import 'package:sample/title/title.dart';
import '../../helpers/helpers.dart';
void main() {
group('TitlePage', () {
testWidgets('renders TitleView', (tester) async {
await tester.pumpApp(const TitlePage());
expect(find.byType(TitleView), findsOneWidget);
});
});
group('TitleView', () {
testWidgets('renders start button', (tester) async {
await tester.pumpApp(const TitleView());
expect(find.byType(ElevatedButton), findsOneWidget);
});
testWidgets('starts the game when start button is tapped', (tester) async {
final navigator = MockNavigator();
when(
() => navigator.pushReplacement<void, void>(any()),
).thenAnswer((_) async {});
await tester.pumpApp(const TitleView(), navigator: navigator);
await tester.tap(find.byType(ElevatedButton));
verify(() => navigator.pushReplacement<void, void>(any())).called(1);
});
});
}
| article-hub/flame-game/sample/test/title/view/title_page_test.dart/0 | {'file_path': 'article-hub/flame-game/sample/test/title/view/title_page_test.dart', 'repo_id': 'article-hub', 'token_count': 402} |
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:async';
/// Simple delegating wrapper around a [Stream].
///
/// Subclasses can override individual methods, or use this to expose only the
/// [Stream] methods of a subclass.
///
/// Note that this is identical to [StreamView] in `dart:async`. It's provided
/// under this name for consistency with other `Delegating*` classes.
class DelegatingStream<T> extends StreamView<T> {
DelegatingStream(Stream<T> stream) : super(stream);
/// Creates a wrapper which throws if [stream]'s events aren't instances of
/// `T`.
///
/// This soundly converts a [Stream] to a `Stream<T>`, regardless of its
/// original generic type, by asserting that its events are instances of `T`
/// whenever they're provided. If they're not, the stream throws a
/// [CastError].
static Stream<T> typed<T>(Stream stream) => stream.cast();
}
| async/lib/src/delegate/stream.dart/0 | {'file_path': 'async/lib/src/delegate/stream.dart', 'repo_id': 'async', 'token_count': 294} |
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:async';
/// A transformer that converts a broadcast stream into a single-subscription
/// stream.
///
/// This buffers the broadcast stream's events, which means that it starts
/// listening to a stream as soon as it's bound.
///
/// This also casts the source stream's events to type `T`. If the cast fails,
/// the result stream will emit a [CastError]. This behavior is deprecated, and
/// should not be relied upon.
class SingleSubscriptionTransformer<S, T> extends StreamTransformerBase<S, T> {
const SingleSubscriptionTransformer();
@override
Stream<T> bind(Stream<S> stream) {
StreamSubscription<S> subscription;
var controller =
StreamController<T>(sync: true, onCancel: () => subscription.cancel());
subscription = stream.listen((value) {
// TODO(nweiz): When we release a new major version, get rid of the second
// type parameter and avoid this conversion.
try {
controller.add(value as T);
} on CastError catch (error, stackTrace) {
controller.addError(error, stackTrace);
}
}, onError: controller.addError, onDone: controller.close);
return controller.stream;
}
}
| async/lib/src/single_subscription_transformer.dart/0 | {'file_path': 'async/lib/src/single_subscription_transformer.dart', 'repo_id': 'async', 'token_count': 420} |
name: async
version: 2.4.1-dev
description: Utility functions and classes related to the 'dart:async' library.
homepage: https://www.github.com/dart-lang/async
environment:
sdk: '>=2.2.0 <3.0.0'
dependencies:
collection: ^1.5.0
dev_dependencies:
fake_async: ^1.0.0
stack_trace: ^1.0.0
test: ^1.0.0
pedantic: ^1.0.0
| async/pubspec.yaml/0 | {'file_path': 'async/pubspec.yaml', 'repo_id': 'async', 'token_count': 145} |
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE filevents.
import 'dart:async';
import 'package:async/async.dart';
import 'package:test/test.dart';
import 'utils.dart';
void main() {
group('source stream', () {
test('is listened to on first request, paused between requests', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
await flushMicrotasks();
expect(controller.hasListener, isFalse);
var next = events.next;
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isFalse);
controller.add(1);
expect(await next, 1);
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isTrue);
next = events.next;
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isFalse);
controller.add(2);
expect(await next, 2);
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isTrue);
events.cancel();
expect(controller.hasListener, isFalse);
});
});
group('eventsDispatched', () {
test('increments after a next future completes', () async {
var events = StreamQueue<int>(createStream());
expect(events.eventsDispatched, equals(0));
await flushMicrotasks();
expect(events.eventsDispatched, equals(0));
var next = events.next;
expect(events.eventsDispatched, equals(0));
await next;
expect(events.eventsDispatched, equals(1));
await events.next;
expect(events.eventsDispatched, equals(2));
});
test('increments multiple times for multi-value requests', () async {
var events = StreamQueue<int>(createStream());
await events.take(3);
expect(events.eventsDispatched, equals(3));
});
test('increments multiple times for an accepted transaction', () async {
var events = StreamQueue<int>(createStream());
await events.withTransaction((queue) async {
await queue.next;
await queue.next;
return true;
});
expect(events.eventsDispatched, equals(2));
});
test("doesn't increment for rest requests", () async {
var events = StreamQueue<int>(createStream());
await events.rest.toList();
expect(events.eventsDispatched, equals(0));
});
});
group('lookAhead operation', () {
test('as simple list of events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(4), [1, 2, 3, 4]);
expect(await events.next, 1);
expect(await events.lookAhead(2), [2, 3]);
expect(await events.take(2), [2, 3]);
expect(await events.next, 4);
await events.cancel();
});
test('of 0 events', () async {
var events = StreamQueue<int>(createStream());
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(1));
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(2));
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(3));
expect(events.lookAhead(0), completion([]));
expect(events.next, completion(4));
expect(events.lookAhead(0), completion([]));
expect(events.lookAhead(5), completion([]));
expect(events.next, throwsStateError);
await events.cancel();
});
test('with bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.lookAhead(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
expect(() => events.lookAhead(-1), throwsArgumentError);
expect(await events.next, 2); // Did not consume event.
await events.cancel();
});
test('of too many arguments', () async {
var events = StreamQueue<int>(createStream());
expect(await events.lookAhead(6), [1, 2, 3, 4]);
await events.cancel();
});
test('too large later', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.lookAhead(6), [3, 4]);
await events.cancel();
});
test('error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(events.lookAhead(4), throwsA('To err is divine!'));
expect(events.take(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
group('next operation', () {
test('simple sequence of requests', () async {
var events = StreamQueue<int>(createStream());
for (var i = 1; i <= 4; i++) {
expect(await events.next, i);
}
expect(events.next, throwsStateError);
});
test('multiple requests at the same time', () async {
var events = StreamQueue<int>(createStream());
var result = await Future.wait(
[events.next, events.next, events.next, events.next]);
expect(result, [1, 2, 3, 4]);
await events.cancel();
});
test('sequence of requests with error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(events.next, throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
group('skip operation', () {
test('of two elements in the middle of sequence', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.skip(2), 0);
expect(await events.next, 4);
await events.cancel();
});
test('with negative/bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.skip(-1), throwsArgumentError);
// A non-int throws either a type error or an argument error,
// depending on whether it's checked mode or not.
expect(await events.next, 1); // Did not consume event.
expect(() => events.skip(-1), throwsArgumentError);
expect(await events.next, 2); // Did not consume event.
await events.cancel();
});
test('of 0 elements works', () async {
var events = StreamQueue<int>(createStream());
expect(events.skip(0), completion(0));
expect(events.next, completion(1));
expect(events.skip(0), completion(0));
expect(events.next, completion(2));
expect(events.skip(0), completion(0));
expect(events.next, completion(3));
expect(events.skip(0), completion(0));
expect(events.next, completion(4));
expect(events.skip(0), completion(0));
expect(events.skip(5), completion(5));
expect(events.next, throwsStateError);
await events.cancel();
});
test('of too many events ends at stream start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.skip(6), 2);
await events.cancel();
});
test('of too many events after some events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.skip(6), 4);
await events.cancel();
});
test('of too many events ends at stream end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.next, 4);
expect(await events.skip(2), 2);
await events.cancel();
});
test('of events with error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(events.skip(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
test('of events with error, and skip again after', () async {
var events = StreamQueue<int>(createErrorStream());
expect(events.skip(4), throwsA('To err is divine!'));
expect(events.skip(2), completion(1));
await events.cancel();
});
test('multiple skips at same time complete in order.', () async {
var events = StreamQueue<int>(createStream());
var skip1 = events.skip(1);
var skip2 = events.skip(0);
var skip3 = events.skip(4);
var skip4 = events.skip(1);
var index = 0;
// Check that futures complete in order.
Func1Required<int> sequence(expectedValue, sequenceIndex) => (value) {
expect(value, expectedValue);
expect(index, sequenceIndex);
index++;
return null;
};
await Future.wait([
skip1.then(sequence(0, 0)),
skip2.then(sequence(0, 1)),
skip3.then(sequence(1, 2)),
skip4.then(sequence(1, 3))
]);
await events.cancel();
});
});
group('take operation', () {
test('as simple take of events', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.take(2), [2, 3]);
expect(await events.next, 4);
await events.cancel();
});
test('of 0 events', () async {
var events = StreamQueue<int>(createStream());
expect(events.take(0), completion([]));
expect(events.next, completion(1));
expect(events.take(0), completion([]));
expect(events.next, completion(2));
expect(events.take(0), completion([]));
expect(events.next, completion(3));
expect(events.take(0), completion([]));
expect(events.next, completion(4));
expect(events.take(0), completion([]));
expect(events.take(5), completion([]));
expect(events.next, throwsStateError);
await events.cancel();
});
test('with bad arguments throws', () async {
var events = StreamQueue<int>(createStream());
expect(() => events.take(-1), throwsArgumentError);
expect(await events.next, 1); // Did not consume event.
expect(() => events.take(-1), throwsArgumentError);
expect(await events.next, 2); // Did not consume event.
await events.cancel();
});
test('of too many arguments', () async {
var events = StreamQueue<int>(createStream());
expect(await events.take(6), [1, 2, 3, 4]);
await events.cancel();
});
test('too large later', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.take(6), [3, 4]);
await events.cancel();
});
test('error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(events.take(4), throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
group('rest operation', () {
test('after single next', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.rest.toList(), [2, 3, 4]);
});
test('at start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.rest.toList(), [1, 2, 3, 4]);
});
test('at end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.next, 4);
expect(await events.rest.toList(), isEmpty);
});
test('after end', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.next, 4);
expect(events.next, throwsStateError);
expect(await events.rest.toList(), isEmpty);
});
test('after receiving done requested before', () async {
var events = StreamQueue<int>(createStream());
var next1 = events.next;
var next2 = events.next;
var next3 = events.next;
var rest = events.rest;
for (var i = 0; i < 10; i++) {
await flushMicrotasks();
}
expect(await next1, 1);
expect(await next2, 2);
expect(await next3, 3);
expect(await rest.toList(), [4]);
});
test('with an error event error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
var rest = events.rest;
var events2 = StreamQueue(rest);
expect(await events2.next, 2);
expect(events2.next, throwsA('To err is divine!'));
expect(await events2.next, 4);
});
test('closes the events, prevents other operations', () async {
var events = StreamQueue<int>(createStream());
var stream = events.rest;
expect(() => events.next, throwsStateError);
expect(() => events.skip(1), throwsStateError);
expect(() => events.take(1), throwsStateError);
expect(() => events.rest, throwsStateError);
expect(() => events.cancel(), throwsStateError);
expect(stream.toList(), completion([1, 2, 3, 4]));
});
test('forwards to underlying stream', () async {
var cancel = Completer();
var controller = StreamController<int>(onCancel: () => cancel.future);
var events = StreamQueue<int>(controller.stream);
expect(controller.hasListener, isFalse);
var next = events.next;
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isFalse);
controller.add(1);
expect(await next, 1);
expect(controller.isPaused, isTrue);
var rest = events.rest;
var subscription = rest.listen(null);
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isFalse);
dynamic lastEvent;
subscription.onData((value) => lastEvent = value);
controller.add(2);
await flushMicrotasks();
expect(lastEvent, 2);
expect(controller.hasListener, isTrue);
expect(controller.isPaused, isFalse);
subscription.pause();
expect(controller.isPaused, isTrue);
controller.add(3);
await flushMicrotasks();
expect(lastEvent, 2);
subscription.resume();
await flushMicrotasks();
expect(lastEvent, 3);
var cancelFuture = subscription.cancel();
expect(controller.hasListener, isFalse);
cancel.complete(42);
expect(cancelFuture, completion(42));
});
});
group('peek operation', () {
test('peeks one event', () async {
var events = StreamQueue<int>(createStream());
expect(await events.peek, 1);
expect(await events.next, 1);
expect(await events.peek, 2);
expect(await events.take(2), [2, 3]);
expect(await events.peek, 4);
expect(await events.next, 4);
// Throws at end.
expect(events.peek, throwsA(anything));
await events.cancel();
});
test('multiple requests at the same time', () async {
var events = StreamQueue<int>(createStream());
var result = await Future.wait(
[events.peek, events.peek, events.next, events.peek, events.peek]);
expect(result, [1, 1, 1, 2, 2]);
await events.cancel();
});
test('sequence of requests with error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(events.peek, throwsA('To err is divine!'));
// Error stays in queue.
expect(events.peek, throwsA('To err is divine!'));
expect(events.next, throwsA('To err is divine!'));
expect(await events.next, 4);
await events.cancel();
});
});
group('cancel operation', () {
test('closes the events, prevents any other operation', () async {
var events = StreamQueue<int>(createStream());
await events.cancel();
expect(() => events.lookAhead(1), throwsStateError);
expect(() => events.next, throwsStateError);
expect(() => events.peek, throwsStateError);
expect(() => events.skip(1), throwsStateError);
expect(() => events.take(1), throwsStateError);
expect(() => events.rest, throwsStateError);
expect(() => events.cancel(), throwsStateError);
});
test('cancels underlying subscription when called before any event',
() async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(), 42);
});
test('cancels underlying subscription, returns result', () async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
var events = StreamQueue<int>(controller.stream);
controller.add(1);
expect(await events.next, 1);
expect(await events.cancel(), 42);
});
group('with immediate: true', () {
test('closes the events, prevents any other operation', () async {
var events = StreamQueue<int>(createStream());
await events.cancel(immediate: true);
expect(() => events.next, throwsStateError);
expect(() => events.skip(1), throwsStateError);
expect(() => events.take(1), throwsStateError);
expect(() => events.rest, throwsStateError);
expect(() => events.cancel(), throwsStateError);
});
test('cancels the underlying subscription immediately', () async {
var controller = StreamController<int>();
controller.add(1);
var events = StreamQueue<int>(controller.stream);
expect(await events.next, 1);
expect(controller.hasListener, isTrue);
await events.cancel(immediate: true);
expect(controller.hasListener, isFalse);
});
test('cancels the underlying subscription when called before any event',
() async {
var cancelFuture = Future.value(42);
var controller = StreamController<int>(onCancel: () => cancelFuture);
var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(immediate: true), 42);
});
test('closes pending requests', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(events.next, throwsStateError);
expect(events.hasNext, completion(isFalse));
await events.cancel(immediate: true);
});
test('returns the result of closing the underlying subscription',
() async {
var controller =
StreamController<int>(onCancel: () => Future.value(42));
var events = StreamQueue<int>(controller.stream);
expect(await events.cancel(immediate: true), 42);
});
test("listens and then cancels a stream that hasn't been listened to yet",
() async {
var wasListened = false;
var controller =
StreamController<int>(onListen: () => wasListened = true);
var events = StreamQueue<int>(controller.stream);
expect(wasListened, isFalse);
expect(controller.hasListener, isFalse);
await events.cancel(immediate: true);
expect(wasListened, isTrue);
expect(controller.hasListener, isFalse);
});
});
});
group('hasNext operation', () {
test('true at start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.hasNext, isTrue);
});
test('true after start', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, isTrue);
});
test('true at end', () async {
var events = StreamQueue<int>(createStream());
for (var i = 1; i <= 4; i++) {
expect(await events.next, i);
}
expect(await events.hasNext, isFalse);
});
test('true when enqueued', () async {
var events = StreamQueue<int>(createStream());
var values = <int>[];
for (var i = 1; i <= 3; i++) {
events.next.then(values.add);
}
expect(values, isEmpty);
expect(await events.hasNext, isTrue);
expect(values, [1, 2, 3]);
});
test('false when enqueued', () async {
var events = StreamQueue<int>(createStream());
var values = <int>[];
for (var i = 1; i <= 4; i++) {
events.next.then(values.add);
}
expect(values, isEmpty);
expect(await events.hasNext, isFalse);
expect(values, [1, 2, 3, 4]);
});
test('true when data event', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
bool hasNext;
events.hasNext.then((result) {
hasNext = result;
});
await flushMicrotasks();
expect(hasNext, isNull);
controller.add(42);
expect(hasNext, isNull);
await flushMicrotasks();
expect(hasNext, isTrue);
});
test('true when error event', () async {
var controller = StreamController<int>();
var events = StreamQueue<int>(controller.stream);
bool hasNext;
events.hasNext.then((result) {
hasNext = result;
});
await flushMicrotasks();
expect(hasNext, isNull);
controller.addError('BAD');
expect(hasNext, isNull);
await flushMicrotasks();
expect(hasNext, isTrue);
expect(events.next, throwsA('BAD'));
});
test('- hasNext after hasNext', () async {
var events = StreamQueue<int>(createStream());
expect(await events.hasNext, true);
expect(await events.hasNext, true);
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.hasNext, true);
expect(await events.next, 2);
expect(await events.hasNext, true);
expect(await events.hasNext, true);
expect(await events.next, 3);
expect(await events.hasNext, true);
expect(await events.hasNext, true);
expect(await events.next, 4);
expect(await events.hasNext, false);
expect(await events.hasNext, false);
});
test('- next after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.next, 2);
expect(await events.next, 3);
});
test('- next after true, enqueued', () async {
var events = StreamQueue<int>(createStream());
var responses = <Object>[];
events.next.then(responses.add);
events.hasNext.then(responses.add);
events.next.then(responses.add);
do {
await flushMicrotasks();
} while (responses.length < 3);
expect(responses, [1, true, 2]);
});
test('- skip 0 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(0), 0);
expect(await events.next, 2);
});
test('- skip 1 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(1), 0);
expect(await events.next, 3);
});
test('- skip 2 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.skip(2), 0);
expect(await events.next, 4);
});
test('- take 0 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(0), isEmpty);
expect(await events.next, 2);
});
test('- take 1 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(1), [2]);
expect(await events.next, 3);
});
test('- take 2 after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
expect(await events.take(2), [2, 3]);
expect(await events.next, 4);
});
test('- rest after true', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.hasNext, true);
var stream = events.rest;
expect(await stream.toList(), [2, 3, 4]);
});
test('- rest after true, at last', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.hasNext, true);
var stream = events.rest;
expect(await stream.toList(), [4]);
});
test('- rest after false', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.next, 4);
expect(await events.hasNext, false);
var stream = events.rest;
expect(await stream.toList(), isEmpty);
});
test('- cancel after true on data', () async {
var events = StreamQueue<int>(createStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.hasNext, true);
expect(await events.cancel(), null);
});
test('- cancel after true on error', () async {
var events = StreamQueue<int>(createErrorStream());
expect(await events.next, 1);
expect(await events.next, 2);
expect(await events.hasNext, true);
expect(await events.cancel(), null);
});
});
group('startTransaction operation produces a transaction that', () {
StreamQueue<int> events;
StreamQueueTransaction<int> transaction;
StreamQueue<int> queue1;
StreamQueue<int> queue2;
setUp(() async {
events = StreamQueue(createStream());
expect(await events.next, 1);
transaction = events.startTransaction();
queue1 = transaction.newQueue();
queue2 = transaction.newQueue();
});
group('emits queues that', () {
test('independently emit events', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
expect(await queue1.next, 3);
expect(await queue1.next, 4);
expect(await queue2.next, 4);
expect(await queue1.hasNext, isFalse);
expect(await queue2.hasNext, isFalse);
});
test('queue requests for events', () async {
expect(queue1.next, completion(2));
expect(queue2.next, completion(2));
expect(queue2.next, completion(3));
expect(queue1.next, completion(3));
expect(queue1.next, completion(4));
expect(queue2.next, completion(4));
expect(queue1.hasNext, completion(isFalse));
expect(queue2.hasNext, completion(isFalse));
});
test('independently emit errors', () async {
events = StreamQueue(createErrorStream());
expect(await events.next, 1);
transaction = events.startTransaction();
queue1 = transaction.newQueue();
queue2 = transaction.newQueue();
expect(queue1.next, completion(2));
expect(queue2.next, completion(2));
expect(queue2.next, throwsA('To err is divine!'));
expect(queue1.next, throwsA('To err is divine!'));
expect(queue1.next, completion(4));
expect(queue2.next, completion(4));
expect(queue1.hasNext, completion(isFalse));
expect(queue2.hasNext, completion(isFalse));
});
});
group('when rejected', () {
test('further original requests use the previous state', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
await flushMicrotasks();
transaction.reject();
expect(await events.next, 2);
expect(await events.next, 3);
expect(await events.next, 4);
expect(await events.hasNext, isFalse);
});
test('pending original requests use the previous state', () async {
expect(await queue1.next, 2);
expect(await queue2.next, 2);
expect(await queue2.next, 3);
expect(events.next, completion(2));
expect(events.next, completion(3));
expect(events.next, completion(4));
expect(events.hasNext, completion(isFalse));
await flushMicrotasks();
transaction.reject();
});
test('further child requests act as though the stream was closed',
() async {
expect(await queue1.next, 2);
transaction.reject();
expect(await queue1.hasNext, isFalse);
expect(queue1.next, throwsStateError);
});
test('pending child requests act as though the stream was closed',
() async {
expect(await queue1.next, 2);
expect(queue1.hasNext, completion(isFalse));
expect(queue1.next, throwsStateError);
transaction.reject();
});
// Regression test.
test('pending child rest requests emit no more events', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
var transaction = events.startTransaction();
var queue = transaction.newQueue();
// This should emit no more events after the transaction is rejected.
queue.rest.listen(expectAsync1((_) {}, count: 3),
onDone: expectAsync0(() {}, count: 0));
controller.add(1);
controller.add(2);
controller.add(3);
await flushMicrotasks();
transaction.reject();
await flushMicrotasks();
// These shouldn't affect the result of `queue.rest.toList()`.
controller.add(4);
controller.add(5);
});
test("child requests' cancel() may still be called explicitly", () async {
transaction.reject();
await queue1.cancel();
});
test('calls to commit() or reject() fail', () async {
transaction.reject();
expect(transaction.reject, throwsStateError);
expect(() => transaction.commit(queue1), throwsStateError);
});
test('before the transaction emits any events, does nothing', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
// Queue a request before the transaction, but don't let it complete
// until we're done with the transaction.
expect(events.next, completion(equals(1)));
events.startTransaction().reject();
expect(events.next, completion(equals(2)));
await flushMicrotasks();
controller.add(1);
await flushMicrotasks();
controller.add(2);
await flushMicrotasks();
controller.close();
});
});
group('when committed', () {
test('further original requests use the committed state', () async {
expect(await queue1.next, 2);
await flushMicrotasks();
transaction.commit(queue1);
expect(await events.next, 3);
});
test('pending original requests use the committed state', () async {
expect(await queue1.next, 2);
expect(events.next, completion(3));
await flushMicrotasks();
transaction.commit(queue1);
});
test('further child requests act as though the stream was closed',
() async {
expect(await queue2.next, 2);
transaction.commit(queue2);
expect(await queue1.hasNext, isFalse);
expect(queue1.next, throwsStateError);
});
test('pending child requests act as though the stream was closed',
() async {
expect(await queue2.next, 2);
expect(queue1.hasNext, completion(isFalse));
expect(queue1.next, throwsStateError);
transaction.commit(queue2);
});
test('further requests act as though the stream was closed', () async {
expect(await queue1.next, 2);
transaction.commit(queue1);
expect(await queue1.hasNext, isFalse);
expect(queue1.next, throwsStateError);
});
test('cancel() may still be called explicitly', () async {
expect(await queue1.next, 2);
transaction.commit(queue1);
await queue1.cancel();
});
test('throws if there are pending requests', () async {
expect(await queue1.next, 2);
expect(queue1.hasNext, completion(isTrue));
expect(() => transaction.commit(queue1), throwsStateError);
});
test('calls to commit() or reject() fail', () async {
transaction.commit(queue1);
expect(transaction.reject, throwsStateError);
expect(() => transaction.commit(queue1), throwsStateError);
});
test('before the transaction emits any events, does nothing', () async {
var controller = StreamController();
var events = StreamQueue(controller.stream);
// Queue a request before the transaction, but don't let it complete
// until we're done with the transaction.
expect(events.next, completion(equals(1)));
var transaction = events.startTransaction();
transaction.commit(transaction.newQueue());
expect(events.next, completion(equals(2)));
await flushMicrotasks();
controller.add(1);
await flushMicrotasks();
controller.add(2);
await flushMicrotasks();
controller.close();
});
});
});
group('withTransaction operation', () {
StreamQueue<int> events;
setUp(() async {
events = StreamQueue(createStream());
expect(await events.next, 1);
});
test('passes a copy of the parent queue', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
expect(await queue.next, 3);
expect(await queue.next, 4);
expect(await queue.hasNext, isFalse);
return true;
}));
});
test(
'the parent queue continues from the child position if it returns '
'true', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
return true;
}));
expect(await events.next, 3);
});
test(
'the parent queue continues from its original position if it returns '
'false', () async {
await events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
return false;
}));
expect(await events.next, 2);
});
test('the parent queue continues from the child position if it throws', () {
expect(events.withTransaction(expectAsync1((queue) async {
expect(await queue.next, 2);
throw 'oh no';
})), throwsA('oh no'));
expect(events.next, completion(3));
});
test('returns whether the transaction succeeded', () {
expect(events.withTransaction((_) async => true), completion(isTrue));
expect(events.withTransaction((_) async => false), completion(isFalse));
});
});
group('cancelable operation', () {
StreamQueue<int> events;
setUp(() async {
events = StreamQueue(createStream());
expect(await events.next, 1);
});
test('passes a copy of the parent queue', () async {
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
expect(await queue.next, 3);
expect(await queue.next, 4);
expect(await queue.hasNext, isFalse);
})).value;
});
test('the parent queue continues from the child position by default',
() async {
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
})).value;
expect(await events.next, 3);
});
test(
'the parent queue continues from the child position if an error is '
'thrown', () async {
expect(
events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
throw 'oh no';
})).value,
throwsA('oh no'));
expect(events.next, completion(3));
});
test('the parent queue continues from the original position if canceled',
() async {
var operation = events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
}));
operation.cancel();
expect(await events.next, 2);
});
test('forwards the value from the callback', () async {
expect(
await events.cancelable(expectAsync1((queue) async {
expect(await queue.next, 2);
return 'value';
})).value,
'value');
});
});
test('all combinations sequential skip/next/take operations', () async {
// Takes all combinations of two of next, skip and take, then ends with
// doing rest. Each of the first rounds do 10 events of each type,
// the rest does 20 elements.
var eventCount = 20 * (3 * 3 + 1);
var events = StreamQueue<int>(createLongStream(eventCount));
// Test expecting [startIndex .. startIndex + 9] as events using
// `next`.
void nextTest(startIndex) {
for (var i = 0; i < 10; i++) {
expect(events.next, completion(startIndex + i));
}
}
// Test expecting 10 events to be skipped.
void skipTest(startIndex) {
expect(events.skip(10), completion(0));
}
// Test expecting [startIndex .. startIndex + 9] as events using
// `take(10)`.
void takeTest(startIndex) {
expect(events.take(10),
completion(List.generate(10, (i) => startIndex + i)));
}
var tests = [nextTest, skipTest, takeTest];
var counter = 0;
// Run through all pairs of two tests and run them.
for (var i = 0; i < tests.length; i++) {
for (var j = 0; j < tests.length; j++) {
tests[i](counter);
tests[j](counter + 10);
counter += 20;
}
}
// Then expect 20 more events as a `rest` call.
expect(events.rest.toList(),
completion(List.generate(20, (i) => counter + i)));
});
}
typedef Func1Required<T> = T Function(T value);
Stream<int> createStream() async* {
yield 1;
await flushMicrotasks();
yield 2;
await flushMicrotasks();
yield 3;
await flushMicrotasks();
yield 4;
}
Stream<int> createErrorStream() {
var controller = StreamController<int>();
() async {
controller.add(1);
await flushMicrotasks();
controller.add(2);
await flushMicrotasks();
controller.addError('To err is divine!');
await flushMicrotasks();
controller.add(4);
await flushMicrotasks();
controller.close();
}();
return controller.stream;
}
Stream<int> createLongStream(int eventCount) async* {
for (var i = 0; i < eventCount; i++) {
yield i;
}
}
| async/test/stream_queue_test.dart/0 | {'file_path': 'async/test/stream_queue_test.dart', 'repo_id': 'async', 'token_count': 15334} |
import 'package:flutter/widgets.dart';
import 'package:atlas/atlas.dart';
/// Callback function taking a single argument.
typedef void ArgumentCallback<T>(T argument);
/// The `Provider` defines the interface to which all `AtlasProviders` must conform.
/// In order to implement a custom `AtlasProvider` you must simply implement `Provider`
/// and set your `AtlasProvider.instance` to the instance of your custom `Provider`.
abstract class Provider {
/// Allows the respective map provider to declare
/// what underlying map types are supported.
///
/// This info can then be used to either cycle through
/// MapTypes with a button on the GUI, or to set the initial
/// [Atlas.mapType] property.
Set<MapType> supportedMapTypes;
Widget build({
final CameraPosition initialCameraPosition,
final Set<Marker> markers,
final Set<Circle> circles,
final Set<Polygon> polygons,
final Set<Polyline> polylines,
final ArgumentCallback<LatLng> onTap,
final ArgumentCallback<LatLng> onLongPress,
final ArgumentCallback<AtlasController> onMapCreated,
final ArgumentCallback<CameraPosition> onCameraPositionChanged,
final bool showMyLocation,
final bool showMyLocationButton,
final MapType mapType,
final bool showTraffic,
});
}
| atlas/packages/atlas/lib/src/provider.dart/0 | {'file_path': 'atlas/packages/atlas/lib/src/provider.dart', 'repo_id': 'atlas', 'token_count': 373} |
import 'package:atlas/atlas.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:google_atlas/src/google_atlas_controller.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart' as GoogleMaps;
import 'package:mockito/mockito.dart';
class MockGoogleMapController extends Mock
implements GoogleMaps.GoogleMapController {}
main() {
group('GoogleAtlasController', () {
GoogleMaps.GoogleMapController googleMapController;
GoogleAtlasController googleAtlasController;
setUp(() {
googleMapController = MockGoogleMapController();
googleAtlasController = GoogleAtlasController(
controller: googleMapController,
);
});
test('throws AssertionError if GoogleMaps.GoogleMapsController is null',
() {
try {
GoogleAtlasController(controller: null);
} catch (error) {
expect(error, isAssertionError);
}
});
group('moveCamera', () {
test('invokes moveCamera', () async {
final CameraPosition cameraPosition = CameraPosition(
target: LatLng(latitude: 10.1, longitude: -80.7),
zoom: 15,
);
await googleAtlasController.moveCamera(cameraPosition);
verify(googleMapController.moveCamera(any)).called(1);
});
});
group('updateBounds', () {
test('invokes newLatLngBounds', () async {
final LatLngBounds bounds = LatLngBounds(
northeast: LatLng(latitude: 1, longitude: 1),
southwest: LatLng(latitude: 0, longitude: 3),
);
await googleAtlasController.updateBounds(bounds, 20);
verify(googleMapController.moveCamera(any)).called(1);
});
});
group('getLatLng', () {
test('invokes getLatLng', () async {
final ScreenCoordinates coordinates = ScreenCoordinates(
x: 1,
y: 2,
);
var googleLatLng = GoogleMaps.LatLng(1.1, 2.2);
when(googleMapController.getLatLng(any))
.thenAnswer((_) => Future.value(googleLatLng));
await googleAtlasController.getLatLng(coordinates);
List<dynamic> results =
verify(googleMapController.getLatLng(captureAny)).captured;
GoogleMaps.ScreenCoordinate resultingScreenCoordinate = results.first;
expect(coordinates.x, resultingScreenCoordinate.x);
expect(coordinates.y, resultingScreenCoordinate.y);
});
});
group('getScreenCoordinate', () {
test('invokes getScreenCoordinate', () async {
final LatLng inputLatLng = LatLng(
latitude: 1.1,
longitude: 2.2,
);
var returnedGoogleScreenCoordinate = GoogleMaps.ScreenCoordinate(
x: 1,
y: 2,
);
when(googleMapController.getScreenCoordinate(any))
.thenAnswer((_) => Future.value(returnedGoogleScreenCoordinate));
await googleAtlasController.getScreenCoordinate(inputLatLng);
List<dynamic> results =
verify(googleMapController.getScreenCoordinate(captureAny))
.captured;
GoogleMaps.LatLng resultingLatLng = results.first;
expect(inputLatLng.latitude, resultingLatLng.latitude);
expect(inputLatLng.longitude, resultingLatLng.longitude);
});
});
});
}
| atlas/packages/google_atlas/test/widget_tests/google_atlas_controller_test.dart/0 | {'file_path': 'atlas/packages/google_atlas/test/widget_tests/google_atlas_controller_test.dart', 'repo_id': 'atlas', 'token_count': 1345} |
import '../platform_features.dart';
import '../source_test_data.dart';
/// Data of a ui test source.
class AppSourceTestData extends SourceTestData {
String sourceKey;
AppSourceTestData({
required this.sourceKey,
required super.duration,
super.isVBR,
});
@override
String toString() {
return 'UiSourceTestData('
'sourceKey: $sourceKey, '
'duration: $duration, '
'isVBR: $isVBR'
')';
}
}
final _features = PlatformFeatures.instance();
// All sources are tested again in lib or platform tests,
// therefore comment most of them to save testing time
final audioTestDataList = [
if (_features.hasUrlSource)
AppSourceTestData(
sourceKey: 'url-remote-wav-1',
duration: const Duration(milliseconds: 451),
),
/*if (_features.hasUrlSource)
AppSourceTestData(
sourceKey: 'url-remote-wav-2',
duration: const Duration(seconds: 1, milliseconds: 068),
),*/
/*if (_features.hasUrlSource)
AppSourceTestData(
sourceKey: 'url-remote-mp3-1',
isVBR: true,
duration: const Duration(minutes: 3, seconds: 30, milliseconds: 77),
),*/
/*if (_features.hasUrlSource)
AppSourceTestData(
sourceKey: 'url-remote-mp3-2',
duration: const Duration(minutes: 1, seconds: 34, milliseconds: 119),
),*/
if (_features.hasUrlSource && _features.hasPlaylistSourceType)
AppSourceTestData(
sourceKey: 'url-remote-m3u8',
duration: null,
),
/*if (_features.hasUrlSource)
AppSourceTestData(
sourceKey: 'url-remote-mpga',
duration: null,
),*/
/*if (_features.hasAssetSource)
AppSourceTestData(
sourceKey: 'asset-wav',
duration: const Duration(seconds: 1, milliseconds: 068),
),*/
/*if (_features.hasAssetSource)
AppSourceTestData(
sourceKey: 'asset-mp3',
duration: const Duration(minutes: 1, seconds: 34, milliseconds: 119),
),*/
/*if (_features.hasBytesSource)
AppSourceTestData(
sourceKey: 'bytes-local',
duration: const Duration(seconds: 1, milliseconds: 068),
),*/
/*if (_features.hasBytesSource)
AppSourceTestData(
sourceKey: 'bytes-remote',
duration: const Duration(minutes: 3, seconds: 30, milliseconds: 76),
),*/
];
| audioplayers/packages/audioplayers/example/integration_test/app/app_source_test_data.dart/0 | {'file_path': 'audioplayers/packages/audioplayers/example/integration_test/app/app_source_test_data.dart', 'repo_id': 'audioplayers', 'token_count': 866} |
import 'package:flutter/material.dart';
class Cbx extends StatelessWidget {
final String label;
final bool value;
final void Function({required bool? value}) update;
const Cbx(
this.label,
this.update, {
required this.value,
super.key,
});
@override
Widget build(BuildContext context) {
return CheckboxListTile(
title: Text(label),
value: value,
onChanged: (v) => update(value: v),
);
}
}
| audioplayers/packages/audioplayers/example/lib/components/cbx.dart/0 | {'file_path': 'audioplayers/packages/audioplayers/example/lib/components/cbx.dart', 'repo_id': 'audioplayers', 'token_count': 170} |
import 'package:audioplayers/audioplayers.dart';
import 'package:audioplayers_example/components/btn.dart';
import 'package:flutter/material.dart';
class LoggerTab extends StatefulWidget {
final AudioPlayer player;
const LoggerTab({
required this.player,
super.key,
});
@override
LoggerTabState createState() => LoggerTabState();
}
class LoggerTabState extends State<LoggerTab>
with AutomaticKeepAliveClientMixin<LoggerTab> {
AudioLogLevel get currentLogLevel => AudioLogger.logLevel;
set currentLogLevel(AudioLogLevel level) {
AudioLogger.logLevel = level;
}
List<Log> logs = [];
List<Log> globalLogs = [];
@override
void initState() {
super.initState();
AudioPlayer.global.onLog.listen(
(message) {
if (AudioLogLevel.info.level <= currentLogLevel.level) {
setState(() {
globalLogs.add(Log(message, level: AudioLogLevel.info));
});
}
},
onError: (Object o, [StackTrace? stackTrace]) {
if (AudioLogLevel.error.level <= currentLogLevel.level) {
setState(() {
globalLogs.add(
Log(
AudioLogger.errorToString(o, stackTrace),
level: AudioLogLevel.error,
),
);
});
}
},
);
widget.player.onLog.listen(
(message) {
if (AudioLogLevel.info.level <= currentLogLevel.level) {
final msg = '$message\nSource: ${widget.player.source}';
setState(() {
logs.add(Log(msg, level: AudioLogLevel.info));
});
}
},
onError: (Object o, [StackTrace? stackTrace]) {
if (AudioLogLevel.error.level <= currentLogLevel.level) {
setState(() {
logs.add(
Log(
AudioLogger.errorToString(
AudioPlayerException(widget.player, cause: o),
stackTrace,
),
level: AudioLogLevel.error,
),
);
});
}
},
);
}
@override
Widget build(BuildContext context) {
super.build(context);
return Padding(
padding: const EdgeInsets.all(16),
child: Column(
children: [
ListTile(
title: Text(currentLogLevel.toString()),
subtitle: const Text('Log Level'),
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: AudioLogLevel.values
.map(
(level) => Btn(
txt: level.toString().replaceAll('AudioLogLevel.', ''),
onPressed: () {
setState(() => currentLogLevel = level);
},
),
)
.toList(),
),
const Divider(color: Colors.black),
Expanded(
child: LogView(
title: 'Player Logs:',
logs: logs,
onDelete: () => setState(() {
logs.clear();
}),
),
),
const Divider(color: Colors.black),
Expanded(
child: LogView(
title: 'Global Logs:',
logs: globalLogs,
onDelete: () => setState(() {
globalLogs.clear();
}),
),
),
],
),
);
}
@override
bool get wantKeepAlive => true;
}
class LogView extends StatelessWidget {
final String title;
final List<Log> logs;
final VoidCallback onDelete;
const LogView({
required this.logs,
required this.title,
required this.onDelete,
super.key,
});
@override
Widget build(BuildContext context) {
return Column(
children: [
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Text(title),
IconButton(onPressed: onDelete, icon: const Icon(Icons.delete)),
],
),
Expanded(
child: ListView(
children: logs
.map(
(log) => Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
SelectableText(
'${log.level}: ${log.message}',
style: log.level == AudioLogLevel.error
? const TextStyle(color: Colors.red)
: null,
),
Divider(color: Colors.grey.shade400),
],
),
)
.toList(),
),
),
],
);
}
}
class Log {
Log(this.message, {required this.level});
final AudioLogLevel level;
final String message;
}
| audioplayers/packages/audioplayers/example/lib/tabs/logger.dart/0 | {'file_path': 'audioplayers/packages/audioplayers/example/lib/tabs/logger.dart', 'repo_id': 'audioplayers', 'token_count': 2556} |
// ignore_for_file: avoid_print
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';
import 'package:async/async.dart';
import 'package:shelf/shelf.dart';
import 'package:shelf_router/shelf_router.dart';
class StreamRoute {
static const timesRadioUrl = 'https://timesradio.wireless.radio/stream';
static const mpegRecordPath = 'public/files/live_streams/mpeg-record.bin';
final mpegStreamController = StreamController<List<int>>.broadcast();
StreamRoute({bool isLiveMode = false, bool isRecordMode = false})
: assert(!isRecordMode || isLiveMode) {
if (isRecordMode) {
recordLiveStream();
}
if (isLiveMode) {
playLiveStream();
} else {
playLocalStream();
}
}
Future<void> recordLiveStream() async {
const recordingTime = Duration(seconds: 10);
// Save lists of bytes in a file, where each first four bytes indicate the
// length of its following list.
final recordOutput = File(mpegRecordPath);
final fileBytes = <int>[];
final mpegSub = mpegStreamController.stream.listen((bytes) async {
fileBytes.addAll([...int32ToBytes(bytes.length), ...bytes]);
});
Future.delayed(recordingTime).then((value) async {
print('Recording finished');
await mpegSub.cancel();
await recordOutput.writeAsBytes(
fileBytes,
flush: true,
);
});
}
Uint8List int32ToBytes(int value) =>
Uint8List(4)..buffer.asInt32List()[0] = value;
int bytesToInt32(List<int> bytes) =>
Uint8List.fromList(bytes).buffer.asInt32List()[0];
Future<void> playLiveStream() async {
final client = HttpClient();
final request = await client.getUrl(Uri.parse(timesRadioUrl));
final response = await request.close();
mpegStreamController.addStream(response);
}
Future<void> playLocalStream() async {
final recordInput = File(mpegRecordPath);
final streamReader = ChunkedStreamReader(recordInput.openRead());
final fileSize = await recordInput.length();
var position = 0;
final mpegBytes = <List<int>>[];
while (position < fileSize) {
final chunkLength = bytesToInt32(await streamReader.readChunk(4));
final chunk = await streamReader.readChunk(chunkLength);
position += chunkLength + 4;
mpegBytes.add(chunk);
}
var mpegBytesPosition = 0;
Timer.periodic(const Duration(milliseconds: 150), (timer) {
mpegStreamController.add(mpegBytes[mpegBytesPosition]);
mpegBytesPosition++;
if (mpegBytesPosition >= mpegBytes.length) {
mpegBytesPosition = 0;
}
});
}
Router get router {
final router = Router();
router.get('/wav', (Request request) async {
final range = request.headers['range'];
const contentType = {'Content-Type': 'audio/wav'};
final file = File('public/files/audio/laser.wav');
if (range != null) {
final fileSize = await file.length();
final parts = range.replaceFirst('bytes=', '').split('-');
final start = int.parse(parts[0]);
final end = int.tryParse(parts[1]) ?? fileSize - 1;
if (start >= fileSize) {
return Response(
416,
body: 'Requested range not satisfiable\n$start >= $fileSize',
);
}
final streamReader = ChunkedStreamReader<int>(file.openRead());
final chunkLength = end - start + 1;
final head = {
'Content-Range': 'bytes $start-$end/$fileSize',
'Accept-Ranges': 'bytes',
'Content-Length': '$chunkLength',
...contentType,
};
if (start > 0) {
await streamReader.readChunk(start);
}
final res = Response.ok(
await streamReader.readChunk(chunkLength),
headers: head,
);
return res;
} else {
final bytes = await file.readAsBytes();
final fileSize = bytes.length;
final head = {
'Content-Length': '$fileSize',
...contentType,
};
final res = Response.ok(
bytes.toList(),
headers: head,
);
return res;
}
});
router.get('/mpeg', (Request request) async {
const contentType = {'Content-Type': 'audio/mpeg'};
final head = {
'Accept-Ranges': 'bytes',
...contentType,
};
final res = Response.ok(
mpegStreamController.stream,
headers: head,
);
return res;
});
return router;
}
Handler get pipeline {
return const Pipeline().addHandler(router);
}
}
| audioplayers/packages/audioplayers/example/server/bin/stream_route.dart/0 | {'file_path': 'audioplayers/packages/audioplayers/example/server/bin/stream_route.dart', 'repo_id': 'audioplayers', 'token_count': 1850} |
import 'dart:async';
import 'package:audioplayers/audioplayers.dart';
import 'package:flutter/foundation.dart';
import 'package:synchronized/synchronized.dart';
/// Represents a function that can stop an audio playing.
typedef StopFunction = Future<void> Function();
/// An AudioPool is a provider of AudioPlayers that are pre-loaded with an asset
/// to minimize delays.
///
/// All AudioPlayers are loaded with the same audio [source].
/// If you want multiple sounds use multiple [AudioPool]s.
///
/// Use this class if you for example have extremely quick firing, repetitive
/// or simultaneous sounds.
class AudioPool {
@visibleForTesting
final Map<String, AudioPlayer> currentPlayers = {};
@visibleForTesting
final List<AudioPlayer> availablePlayers = [];
/// Instance of [AudioCache] to be used by all players.
final AudioCache audioCache;
/// The source of the sound for this pool.
final Source source;
/// The minimum numbers of players, this is the amount of players that the
/// pool is initialized with.
final int minPlayers;
/// The maximum number of players to be kept in the pool.
///
/// If `start` is called after the pool is full there will still be new
/// [AudioPlayer]s created, but once they are stopped they will not be
/// returned to the pool.
final int maxPlayers;
final Lock _lock = Lock();
AudioPool._({
required this.minPlayers,
required this.maxPlayers,
required this.source,
AudioCache? audioCache,
}) : audioCache = audioCache ?? AudioCache.instance;
/// Creates an [AudioPool] instance with the given parameters.
static Future<AudioPool> create({
required Source source,
required int maxPlayers,
AudioCache? audioCache,
int minPlayers = 1,
}) async {
final instance = AudioPool._(
source: source,
audioCache: audioCache,
maxPlayers: maxPlayers,
minPlayers: minPlayers,
);
final players = await Future.wait(
List.generate(minPlayers, (_) => instance._createNewAudioPlayer()),
);
return instance..availablePlayers.addAll(players);
}
/// Creates an [AudioPool] instance with the asset from the given [path].
static Future<AudioPool> createFromAsset({
required String path,
required int maxPlayers,
AudioCache? audioCache,
int minPlayers = 1,
}) async {
return create(
source: AssetSource(path),
audioCache: audioCache,
minPlayers: minPlayers,
maxPlayers: maxPlayers,
);
}
/// Starts playing the audio, returns a function that can stop the audio.
Future<StopFunction> start({double volume = 1.0}) async {
return _lock.synchronized(() async {
if (availablePlayers.isEmpty) {
availablePlayers.add(await _createNewAudioPlayer());
}
final player = availablePlayers.removeAt(0);
currentPlayers[player.playerId] = player;
await player.setVolume(volume);
await player.resume();
late StreamSubscription<void> subscription;
Future<void> stop() {
return _lock.synchronized(() async {
final removedPlayer = currentPlayers.remove(player.playerId);
if (removedPlayer != null) {
subscription.cancel();
await removedPlayer.stop();
if (availablePlayers.length >= maxPlayers) {
await removedPlayer.release();
} else {
availablePlayers.add(removedPlayer);
}
}
});
}
subscription = player.onPlayerComplete.listen((_) => stop());
return stop;
});
}
Future<AudioPlayer> _createNewAudioPlayer() async {
final player = AudioPlayer()..audioCache = audioCache;
await player.setSource(source);
await player.setReleaseMode(ReleaseMode.stop);
return player;
}
/// Disposes the audio pool. Then it cannot be used anymore.
Future<void> dispose() =>
Future.wait(availablePlayers.map((e) => e.dispose()));
}
| audioplayers/packages/audioplayers/lib/src/audio_pool.dart/0 | {'file_path': 'audioplayers/packages/audioplayers/lib/src/audio_pool.dart', 'repo_id': 'audioplayers', 'token_count': 1310} |
import 'package:audioplayers_platform_interface/src/api/audio_context.dart';
import 'package:audioplayers_platform_interface/src/api/global_audio_event.dart';
import 'package:audioplayers_platform_interface/src/global_audioplayers_platform_interface.dart';
import 'package:audioplayers_platform_interface/src/map_extension.dart';
import 'package:audioplayers_platform_interface/src/method_channel_extension.dart';
import 'package:flutter/services.dart';
class GlobalAudioplayersPlatform extends GlobalAudioplayersPlatformInterface
with
MethodChannelGlobalAudioplayersPlatform,
EventChannelGlobalAudioplayersPlatform {
GlobalAudioplayersPlatform();
}
mixin MethodChannelGlobalAudioplayersPlatform
implements MethodChannelGlobalAudioplayersPlatformInterface {
static const MethodChannel _globalMethodChannel =
MethodChannel('xyz.luan/audioplayers.global');
@override
Future<void> setGlobalAudioContext(AudioContext ctx) {
return _globalMethodChannel.call(
'setAudioContext',
ctx.toJson(),
);
}
@override
Future<void> emitGlobalLog(String message) {
return _globalMethodChannel.call(
'emitLog',
<String, dynamic>{
'message': message,
},
);
}
@override
Future<void> emitGlobalError(String code, String message) {
return _globalMethodChannel.call(
'emitError',
<String, dynamic>{
'code': code,
'message': message,
},
);
}
}
mixin EventChannelGlobalAudioplayersPlatform
implements EventChannelGlobalAudioplayersPlatformInterface {
static const _globalEventChannel =
EventChannel('xyz.luan/audioplayers.global/events');
@override
Stream<GlobalAudioEvent> getGlobalEventStream() {
return _globalEventChannel.receiveBroadcastStream().map((dynamic event) {
final map = event as Map<dynamic, dynamic>;
final eventType = map.getString('event');
switch (eventType) {
case 'audio.onLog':
final value = map.getString('value');
return GlobalAudioEvent(
eventType: GlobalAudioEventType.log,
logMessage: value,
);
default:
throw UnimplementedError(
'Global Event Method does not exist $eventType',
);
}
});
}
}
| audioplayers/packages/audioplayers_platform_interface/lib/src/global_audioplayers_platform.dart/0 | {'file_path': 'audioplayers/packages/audioplayers_platform_interface/lib/src/global_audioplayers_platform.dart', 'repo_id': 'audioplayers', 'token_count': 848} |
import 'dart:async';
import 'package:audioplayers_platform_interface/audioplayers_platform_interface.dart';
import 'package:flutter/services.dart';
class WebGlobalAudioplayersPlatform
extends GlobalAudioplayersPlatformInterface {
final _eventStreamController = StreamController<GlobalAudioEvent>.broadcast();
@override
Future<void> setGlobalAudioContext(AudioContext ctx) async {
_eventStreamController.add(
const GlobalAudioEvent(
eventType: GlobalAudioEventType.log,
logMessage: 'Setting global AudioContext is not supported on Web',
),
);
}
@override
Stream<GlobalAudioEvent> getGlobalEventStream() {
return _eventStreamController.stream;
}
@override
Future<void> emitGlobalLog(String message) async {
_eventStreamController.add(
GlobalAudioEvent(
eventType: GlobalAudioEventType.log,
logMessage: message,
),
);
}
@override
Future<void> emitGlobalError(String code, String message) async {
_eventStreamController
.addError(PlatformException(code: code, message: message));
}
}
| audioplayers/packages/audioplayers_web/lib/global_audioplayers_web.dart/0 | {'file_path': 'audioplayers/packages/audioplayers_web/lib/global_audioplayers_web.dart', 'repo_id': 'audioplayers', 'token_count': 370} |
import 'package:benckmark/item.dart';
import 'package:get/get.dart';
class Controller extends GetController {
@override
onInit() async {
for (int i = 0; i < 10; i++) {
await Future.delayed(Duration(milliseconds: 500));
addItem(Item(title: DateTime.now().toString()));
}
print("It's done. Print now!");
super.onInit();
}
final items = List<Item>.of(sampleItems);
void addItem(Item item) {
items.add(item);
update();
}
}
| benchmarks/state_managers/lib/_get/_store.dart/0 | {'file_path': 'benchmarks/state_managers/lib/_get/_store.dart', 'repo_id': 'benchmarks', 'token_count': 182} |
import 'dart:async';
import 'dart:convert';
import 'package:uuid/uuid.dart';
import 'package:json_annotation/json_annotation.dart';
import 'package:play_games/play_games.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'async_saver.dart';
import 'buy.dart';
import 'iap.dart';
import 'options.dart';
import 'play_user.dart';
import 'skin_list.dart';
import 'stats.dart';
part 'data.g.dart';
@JsonSerializable()
class SavedData {
Options options;
Stats stats;
Buy buy;
bool showTutorial;
SavedData() {
showTutorial = true;
options = Options();
stats = Stats();
buy = Buy();
}
factory SavedData.fromJson(Map<String, dynamic> json) => _$SavedDataFromJson(json);
Map<String, dynamic> toJson() => _$SavedDataToJson(this);
static SavedData merge(SavedData s1, SavedData s2) {
return SavedData()
..showTutorial = s1.showTutorial || s2.showTutorial
..options = s1.options ?? s2.options
..stats = Stats.merge(s1.stats, s2.stats)
..buy = Buy.merge(s1.buy, s2.buy);
}
}
class Data {
static const SAVE_NAME = 'bgug.data.v3';
static SkinList skinList;
static SavedData _data;
static Options get options => _data.options ??= Options();
static set options(Options options) => _data.options = options ?? Options();
static Stats get stats => _data.stats ??= Stats();
static Buy get buy => _data.buy ??= Buy();
static PlayUser _user;
static PlayUser get user => _user;
static set user(PlayUser user) {
_user = user;
userStream.values.forEach((fn) => fn(user));
}
static Options currentOptions;
static bool pristine = true;
static bool isSaving = false;
static bool hasOpened = false;
static Map<String, void Function(PlayUser)> userStream = {};
static String addUserCallback(void Function(PlayUser) fn) {
final key = Uuid().v4();
userStream[key] = fn;
return key;
}
static void removeUserCallback(String key) {
userStream.remove(key);
}
static void checkAchievementsAndSkins() {
if (stats.totalDistance >= 21000) {
_achievement('achievement_half_marathoner');
}
if (stats.totalDistance >= 42000) {
_achievement('achievement_marathoner');
if (!buy.skinsOwned.contains('marathonist.png')) {
buy.skinsOwned.add('marathonist.png');
}
}
if (stats.totalJumps > 500) {
_achievement('achievement_jumper');
}
if (stats.totalJumps > 1000) {
_achievement('achievement_super_jumper');
if (!buy.skinsOwned.contains('jumping.png')) {
buy.skinsOwned.add('jumping.png');
}
}
if (buy.skinsOwned.length > 1) {
_achievement('achievement_the_disguised_bot');
}
if (buy.skinsOwned.length > 10) {
_achievement('achievement_a_small_collection');
}
if (buy.skinsOwned.length > 20) {
_achievement('achievement_the_collector');
}
if (buy.skinsOwned.length > 30) {
_achievement('achievement_the_completionist');
}
}
static Future _achievement(String name) async {
if (user != null) {
await PlayGames.unlockAchievementByName(name);
}
}
static Future loadHardData() {
return SkinList.fetch().then((r) => skinList = r);
}
static Future loadLocalSoftData() async {
pristine = true;
_data = await Data.fetch(true);
validatePro(IAP.pro);
}
static bool get hasData => _data != null;
static bool get playGames => user != null;
static Future<bool> getAndToggleShowTutorial() async {
if (_data.showTutorial) {
_data.showTutorial = false;
await save();
return true;
}
return false;
}
static Future save() async {
if (isSaving) {
print('will save in a while!');
return Future.delayed(const Duration(seconds: 3)).then((_) => save());
}
isSaving = true;
pristine = false;
final data = json.encode(_data.toJson());
final result = await _saveInternal(data);
print('Saved data! playGames: $playGames');
isSaving = false;
return result;
}
static Future<Object> _saveInternal(String data) async {
if (playGames) {
if (!hasOpened) {
await _openInternal();
hasOpened = true;
}
print('Saving $data');
final status = await PlayGames.saveSnapshot(SAVE_NAME, data);
print('Saved $status');
return await _openInternal();
} else {
final SharedPreferences prefs = await SharedPreferences.getInstance();
return prefs.setString(SAVE_NAME, data);
}
}
static Future<Snapshot> _openInternal() async {
try {
return await PlayGames.openSnapshot(SAVE_NAME);
} catch (ex) {
if (ex is CloudSaveConflictError) {
final result = _mergeInternal(ex.local, ex.server);
return await PlayGames.resolveSnapshotConflict(SAVE_NAME, ex.conflictId, result);
}
rethrow;
}
}
static Future<SavedData> fetch(bool createNew) async {
final loaded = await _doFetch(createNew);
loaded?.stats?.firstTimeScoreCheck();
return loaded;
}
static Future<SavedData> _doFetch(bool createNew) async {
if (playGames) {
return await _fetchFromPlayGames(createNew);
} else {
return await _fetchFromSharedPreferences(createNew);
}
}
static Future<SavedData> _fetchFromPlayGames(bool createNew) async {
final snap = await _openInternal();
if (snap.content == null || snap.content.trim().isEmpty) {
return createNew ? SavedData() : null;
}
hasOpened = true;
return SavedData.fromJson(json.decode(snap.content));
}
static Future<SavedData> _fetchFromSharedPreferences(bool createNew) async {
final SharedPreferences prefs = await SharedPreferences.getInstance();
final jsonStr = prefs.getString(SAVE_NAME);
if (jsonStr == null) {
return createNew ? SavedData() : null;
}
return SavedData.fromJson(json.decode(jsonStr));
}
static void forceData(SavedData data) {
pristine = false;
_data = data;
validatePro(IAP.pro);
}
static void mergeData(SavedData other) {
_data = SavedData.merge(other, _data);
validatePro(IAP.pro);
}
static void setData(SavedData data) {
if (Data.pristine) {
Data.forceData(data);
} else {
Data.mergeData(data);
}
}
static String _mergeInternal(Snapshot local, Snapshot server) {
final s1 = SavedData.fromJson(json.decode(local.content));
final s2 = SavedData.fromJson(json.decode(server.content));
return json.encode(SavedData.merge(s1, s2).toJson());
}
static void saveAsync() async {
final saver = AsyncSaver.start();
await Data.save();
saver.stop();
}
static void validatePro(bool pro) {
const goldSkin = 'gold.png';
if (pro == true) {
if (!buy.skinsOwned.contains(goldSkin)) {
buy.skinsOwned.add(goldSkin);
}
} else {
buy.skinsOwned.remove(goldSkin);
if (buy.selectedSkin == goldSkin) {
buy.selectedSkin = 'asimov.png';
}
}
}
}
| bgug/lib/data.dart/0 | {'file_path': 'bgug/lib/data.dart', 'repo_id': 'bgug', 'token_count': 2750} |
import 'dart:typed_data';
import '../bitmap.dart';
import 'operation.dart';
class BitmapRotate implements BitmapOperation {
final _Rotate _rotate;
BitmapRotate.rotateClockwise() : _rotate = _RotateClockwise();
BitmapRotate.rotate180() : _rotate = _Rotate180();
BitmapRotate.rotateCounterClockwise() : _rotate = _RotateCounterClockwise();
@override
Bitmap applyTo(Bitmap bitmap) {
return _rotate.doRotate(bitmap);
}
}
abstract class _Rotate {
Bitmap doRotate(Bitmap bitmap);
}
class _RotateClockwise implements _Rotate {
@override
Bitmap doRotate(Bitmap bitmap) {
final Bitmap rotated = Bitmap.fromHeadless(
bitmap.height,
bitmap.width,
Uint8List(bitmap.width * bitmap.height * RGBA32BitmapHeader.pixelLength),
);
_rotateClockwiseCore(
bitmap.content,
rotated.content,
bitmap.width,
bitmap.height,
);
return rotated;
}
void _rotateClockwiseCore(
Uint8List sourceBmp,
Uint8List destBmp,
int width,
int height,
) {
assert(width > 0 && height > 0);
const pixelLength = RGBA32BitmapHeader.pixelLength;
final int lineLength = width * pixelLength;
for (int line = 0; line < height; line++) {
final startOfLine = line * lineLength;
for (int column = 0; column < width; column++) {
final int columnStart = column * pixelLength;
final int pixelStart = startOfLine + columnStart;
final int pixelEnd = pixelStart + pixelLength;
final int rotatedStart =
(height * column) * pixelLength + (height - line - 1) * pixelLength;
final int rotatedEnd = rotatedStart + pixelLength;
final Uint8List sourcePixel = sourceBmp.sublist(pixelStart, pixelEnd);
destBmp.setRange(rotatedStart, rotatedEnd, sourcePixel);
}
}
}
}
class _RotateCounterClockwise implements _Rotate {
@override
Bitmap doRotate(Bitmap bitmap) {
final Bitmap rotated = Bitmap.fromHeadless(
bitmap.height,
bitmap.width,
Uint8List(bitmap.width * bitmap.height * RGBA32BitmapHeader.pixelLength),
);
_rotateCounterClockwiseCore(
bitmap.content,
rotated.content,
bitmap.width,
bitmap.height,
);
return rotated;
}
void _rotateCounterClockwiseCore(
Uint8List sourceBmp,
Uint8List destBmp,
int width,
int height,
) {
assert(width > 0 && height > 0);
const pixelLength = RGBA32BitmapHeader.pixelLength;
final int lineLength = width * pixelLength;
for (int line = 0; line < height; line++) {
final startOfLine = line * lineLength;
for (int column = 0; column < width; column++) {
final int columnStart = column * pixelLength;
final int pixelStart = startOfLine + columnStart;
final int pixelEnd = pixelStart + pixelLength;
final int rotatedStart =
(height * (width - column - 1)) * pixelLength + line * pixelLength;
final int rotatedEnd = rotatedStart + pixelLength;
final Uint8List sourcePixel = sourceBmp.sublist(pixelStart, pixelEnd);
destBmp.setRange(rotatedStart, rotatedEnd, sourcePixel);
}
}
}
}
class _Rotate180 implements _Rotate {
@override
Bitmap doRotate(Bitmap bitmap) {
final Bitmap rotated = Bitmap.fromHeadless(
bitmap.height,
bitmap.width,
Uint8List(bitmap.width * bitmap.height * RGBA32BitmapHeader.pixelLength),
);
_rotate180Core(
bitmap.content,
rotated.content,
bitmap.width,
bitmap.height,
);
return rotated;
}
void _rotate180Core(
Uint8List sourceBmp,
Uint8List destBmp,
int width,
int height,
) {
assert(width > 0 && height > 0);
const pixelLength = RGBA32BitmapHeader.pixelLength;
final int lineLength = width * pixelLength;
for (int line = 0; line < height; line++) {
final startOfLine = line * lineLength;
for (int column = 0; column < width; column++) {
final int columnStart = column * pixelLength;
final int pixelStart = startOfLine + columnStart;
final int pixelEnd = pixelStart + pixelLength;
final int rotatedStart = width * (height - line - 1) * pixelLength +
(width - column - 1) * pixelLength;
final int rotatedEnd = rotatedStart + pixelLength;
final Uint8List sourcePixel = sourceBmp.sublist(pixelStart, pixelEnd);
destBmp.setRange(rotatedStart, rotatedEnd, sourcePixel);
}
}
}
}
| bitmap/lib/src/operation/rotation.dart/0 | {'file_path': 'bitmap/lib/src/operation/rotation.dart', 'repo_id': 'bitmap', 'token_count': 1744} |
blank_issues_enabled: false | bloc/.github/ISSUE_TEMPLATE/config.yml/0 | {'file_path': 'bloc/.github/ISSUE_TEMPLATE/config.yml', 'repo_id': 'bloc', 'token_count': 7} |
name: docs
on:
push:
branches:
- master
paths:
- '.github/workflows/docs.yaml'
- 'README.md'
- 'docs/*'
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: JasonEtco/create-an-issue@v2
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
filename: .github/DOCS_ISSUE_TEMPLATE.md
| bloc/.github/workflows/docs.yaml/0 | {'file_path': 'bloc/.github/workflows/docs.yaml', 'repo_id': 'bloc', 'token_count': 207} |
import 'package:flutter/widgets.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../{{name.snakeCase()}}.dart';
class {{name.pascalCase()}}Page extends StatelessWidget {
const {{name.pascalCase()}}Page({super.key});
@override
Widget build(BuildContext context) {
{{#is_bloc}}{{> bloc_provider }}{{/is_bloc}}{{^is_bloc}}{{> cubit_bloc_provider }}{{/is_bloc}}
}
}
class {{name.pascalCase()}}View extends StatelessWidget {
const {{name.pascalCase()}}View({super.key});
@override
Widget build(BuildContext context) {
{{#is_bloc}}{{> bloc_builder }}{{/is_bloc}}{{^is_bloc}}{{> cubit_bloc_builder }}{{/is_bloc}}
}
}
| bloc/bricks/flutter_bloc_feature/__brick__/{{name.snakeCase()}}/view/{{name.snakeCase()}}_page.dart/0 | {'file_path': 'bloc/bricks/flutter_bloc_feature/__brick__/{{name.snakeCase()}}/view/{{name.snakeCase()}}_page.dart', 'repo_id': 'bloc', 'token_count': 257} |
// ignore_for_file: prefer_const_constructors
import 'package:flutter_bloc_with_stream/bloc/ticker_bloc.dart';
import 'package:flutter_test/flutter_test.dart';
void main() {
group('TickerEvent', () {
group('TickerStarted', () {
test('supports value comparison', () {
expect(TickerStarted(), equals(TickerStarted()));
});
});
});
}
| bloc/examples/flutter_bloc_with_stream/test/bloc/ticker_event_test.dart/0 | {'file_path': 'bloc/examples/flutter_bloc_with_stream/test/bloc/ticker_event_test.dart', 'repo_id': 'bloc', 'token_count': 144} |
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_complex_list/complex_list/complex_list.dart';
import 'package:flutter_complex_list/repository.dart';
class App extends MaterialApp {
App({super.key, required Repository repository})
: super(
home: RepositoryProvider.value(
value: repository,
child: const ComplexListPage(),
),
);
}
| bloc/examples/flutter_complex_list/lib/app.dart/0 | {'file_path': 'bloc/examples/flutter_complex_list/lib/app.dart', 'repo_id': 'bloc', 'token_count': 180} |
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_complex_list/complex_list/complex_list.dart';
import 'package:flutter_complex_list/repository.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
class MockRepository extends Mock implements Repository {}
class MockComplexListCubit extends MockCubit<ComplexListState>
implements ComplexListCubit {}
class FakeComplexListState extends Fake implements ComplexListState {}
extension on WidgetTester {
Future<void> pumpListPage(Repository repository) {
return pumpWidget(
MaterialApp(
home: RepositoryProvider.value(
value: repository,
child: const ComplexListPage(),
),
),
);
}
Future<void> pumpListView(ComplexListCubit listCubit) {
return pumpWidget(
MaterialApp(
home: BlocProvider.value(
value: listCubit,
child: const ComplexListView(),
),
),
);
}
}
void main() {
const mockItems = [
Item(id: '1', value: 'Item 1'),
Item(id: '2', value: 'Item 2'),
Item(id: '3', value: 'Item 3'),
];
late Repository repository;
late ComplexListCubit listCubit;
setUpAll(() {
registerFallbackValue(FakeComplexListState());
});
setUp(() {
repository = MockRepository();
listCubit = MockComplexListCubit();
});
group('ListPage', () {
testWidgets('renders ComplexListView', (tester) async {
when(() => repository.fetchItems()).thenAnswer((_) async => []);
await tester.pumpListPage(repository);
expect(find.byType(ComplexListView), findsOneWidget);
});
});
group('ComplexListView', () {
testWidgets(
'renders CircularProgressIndicator while '
'waiting for items to load', (tester) async {
when(() => listCubit.state).thenReturn(const ComplexListState.loading());
await tester.pumpListView(listCubit);
expect(find.byType(CircularProgressIndicator), findsOneWidget);
});
testWidgets(
'renders error text '
'when items fail to load', (tester) async {
when(() => listCubit.state).thenReturn(const ComplexListState.failure());
await tester.pumpListView(listCubit);
expect(find.text('Oops something went wrong!'), findsOneWidget);
});
testWidgets(
'renders ComplexListView after items '
'are finished loading', (tester) async {
when(() => listCubit.state).thenReturn(
const ComplexListState.success(mockItems),
);
await tester.pumpListView(listCubit);
expect(find.byType(ComplexListView), findsOneWidget);
});
testWidgets(
'renders no content text when '
'no items are present', (tester) async {
when(() => listCubit.state).thenReturn(
const ComplexListState.success([]),
);
await tester.pumpListView(listCubit);
expect(find.text('no content'), findsOneWidget);
});
testWidgets('renders three ItemTiles', (tester) async {
when(() => listCubit.state).thenReturn(
const ComplexListState.success(mockItems),
);
await tester.pumpListView(listCubit);
expect(find.byType(ItemTile), findsNWidgets(3));
});
testWidgets('deletes first item', (tester) async {
when(() => listCubit.state).thenReturn(
const ComplexListState.success(mockItems),
);
when(() => listCubit.deleteItem('1')).thenAnswer((_) async {});
await tester.pumpListView(listCubit);
await tester.tap(find.byIcon(Icons.delete).first);
verify(() => listCubit.deleteItem('1')).called(1);
});
});
group('ItemTile', () {
testWidgets('renders id and value text', (tester) async {
const mockItem = Item(id: '1', value: 'Item 1');
when(() => listCubit.state).thenReturn(
const ComplexListState.success([mockItem]),
);
await tester.pumpListView(listCubit);
expect(find.text('#1'), findsOneWidget);
expect(find.text('Item 1'), findsOneWidget);
});
testWidgets(
'renders delete icon button '
'when item is not being deleted', (tester) async {
const mockItem = Item(id: '1', value: 'Item 1');
when(() => listCubit.state).thenReturn(
const ComplexListState.success([mockItem]),
);
await tester.pumpListView(listCubit);
expect(find.byIcon(Icons.delete), findsOneWidget);
});
testWidgets(
'renders CircularProgressIndicator '
'when item is being deleting', (tester) async {
const mockItem = Item(id: '1', value: 'Item 1', isDeleting: true);
when(() => listCubit.state).thenReturn(
const ComplexListState.success([mockItem]),
);
await tester.pumpListView(listCubit);
expect(find.byType(CircularProgressIndicator), findsOneWidget);
});
});
}
| bloc/examples/flutter_complex_list/test/complex_list/view/complex_list_page_test.dart/0 | {'file_path': 'bloc/examples/flutter_complex_list/test/complex_list/view/complex_list_page_test.dart', 'repo_id': 'bloc', 'token_count': 1954} |
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_counter/counter/counter.dart';
import 'package:flutter_test/flutter_test.dart';
void main() {
group('CounterCubit', () {
test('initial state is 0', () {
expect(CounterCubit().state, 0);
});
group('increment', () {
blocTest<CounterCubit, int>(
'emits [1] when state is 0',
build: CounterCubit.new,
act: (cubit) => cubit.increment(),
expect: () => const <int>[1],
);
blocTest<CounterCubit, int>(
'emits [1, 2] when state is 0 and invoked twice',
build: CounterCubit.new,
act: (cubit) => cubit
..increment()
..increment(),
expect: () => const <int>[1, 2],
);
blocTest<CounterCubit, int>(
'emits [42] when state is 41',
build: CounterCubit.new,
seed: () => 41,
act: (cubit) => cubit.increment(),
expect: () => const <int>[42],
);
});
group('decrement', () {
blocTest<CounterCubit, int>(
'emits [-1] when state is 0',
build: CounterCubit.new,
act: (cubit) => cubit.decrement(),
expect: () => const <int>[-1],
);
blocTest<CounterCubit, int>(
'emits [-1, -2] when state is 0 and invoked twice',
build: CounterCubit.new,
act: (cubit) => cubit
..decrement()
..decrement(),
expect: () => const <int>[-1, -2],
);
blocTest<CounterCubit, int>(
'emits [42] when state is 43',
build: CounterCubit.new,
seed: () => 43,
act: (cubit) => cubit.decrement(),
expect: () => const <int>[42],
);
});
});
}
| bloc/examples/flutter_counter/test/counter/cubit/counter_cubit_test.dart/0 | {'file_path': 'bloc/examples/flutter_counter/test/counter/cubit/counter_cubit_test.dart', 'repo_id': 'bloc', 'token_count': 821} |
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_dynamic_form/new_car/new_car.dart';
import 'package:flutter_dynamic_form/new_car_repository.dart';
class NewCarPage extends StatelessWidget {
const NewCarPage({super.key});
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Flutter Dynamic Form')),
body: BlocProvider(
create: (_) => NewCarBloc(
newCarRepository: context.read<NewCarRepository>(),
)..add(const NewCarFormLoaded()),
child: const NewCarForm(),
),
);
}
}
class NewCarForm extends StatelessWidget {
const NewCarForm({super.key});
@override
Widget build(BuildContext context) {
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: const <Widget>[
_BrandDropdownButton(),
_ModelDropdownButton(),
_YearDropdownButton(),
_FormSubmitButton(),
],
);
}
}
class _BrandDropdownButton extends StatelessWidget {
const _BrandDropdownButton();
@override
Widget build(BuildContext context) {
final brands = context.select((NewCarBloc bloc) => bloc.state.brands);
final brand = context.select((NewCarBloc bloc) => bloc.state.brand);
return Material(
child: DropdownButton<String>(
key: const Key('newCarForm_brand_dropdownButton'),
items: brands.isNotEmpty
? brands.map((brand) {
return DropdownMenuItem(value: brand, child: Text(brand));
}).toList()
: const [],
value: brand,
hint: const Text('Select a Brand'),
onChanged: (brand) {
context.read<NewCarBloc>().add(NewCarBrandChanged(brand: brand));
},
),
);
}
}
class _ModelDropdownButton extends StatelessWidget {
const _ModelDropdownButton();
@override
Widget build(BuildContext context) {
final models = context.select((NewCarBloc bloc) => bloc.state.models);
final model = context.select((NewCarBloc bloc) => bloc.state.model);
return Material(
child: DropdownButton<String>(
key: const Key('newCarForm_model_dropdownButton'),
items: models.isNotEmpty
? models.map((model) {
return DropdownMenuItem(value: model, child: Text(model));
}).toList()
: const [],
value: model,
hint: const Text('Select a Model'),
onChanged: (model) {
context.read<NewCarBloc>().add(NewCarModelChanged(model: model));
},
),
);
}
}
class _YearDropdownButton extends StatelessWidget {
const _YearDropdownButton();
@override
Widget build(BuildContext context) {
final years = context.select((NewCarBloc bloc) => bloc.state.years);
final year = context.select((NewCarBloc bloc) => bloc.state.year);
return Material(
child: DropdownButton<String>(
key: const Key('newCarForm_year_dropdownButton'),
items: years.isNotEmpty
? years.map((year) {
return DropdownMenuItem(value: year, child: Text(year));
}).toList()
: const [],
value: year,
hint: const Text('Select a Year'),
onChanged: (year) {
context.read<NewCarBloc>().add(NewCarYearChanged(year: year));
},
),
);
}
}
class _FormSubmitButton extends StatelessWidget {
const _FormSubmitButton();
@override
Widget build(BuildContext context) {
final state = context.watch<NewCarBloc>().state;
void onFormSubmitted() {
ScaffoldMessenger.of(context)
..hideCurrentSnackBar()
..showSnackBar(
SnackBar(
content:
Text('Submitted ${state.brand} ${state.model} ${state.year}'),
),
);
}
return ElevatedButton(
onPressed: state.isComplete ? onFormSubmitted : null,
child: const Text('Submit'),
);
}
}
| bloc/examples/flutter_dynamic_form/lib/new_car/view/new_car_page.dart/0 | {'file_path': 'bloc/examples/flutter_dynamic_form/lib/new_car/view/new_car_page.dart', 'repo_id': 'bloc', 'token_count': 1662} |
// ignore_for_file: avoid_print
import 'package:bloc/bloc.dart';
class AppBlocObserver extends BlocObserver {
const AppBlocObserver();
@override
void onEvent(Bloc<dynamic, dynamic> bloc, Object? event) {
super.onEvent(bloc, event);
print(event);
}
@override
void onError(BlocBase<dynamic> bloc, Object error, StackTrace stackTrace) {
print(error);
super.onError(bloc, error, stackTrace);
}
@override
void onChange(BlocBase<dynamic> bloc, Change<dynamic> change) {
super.onChange(bloc, change);
print(change);
}
@override
void onTransition(
Bloc<dynamic, dynamic> bloc,
Transition<dynamic, dynamic> transition,
) {
super.onTransition(bloc, transition);
print(transition);
}
}
| bloc/examples/flutter_firebase_login/lib/app/bloc_observer.dart/0 | {'file_path': 'bloc/examples/flutter_firebase_login/lib/app/bloc_observer.dart', 'repo_id': 'bloc', 'token_count': 284} |
part of 'sign_up_cubit.dart';
enum ConfirmPasswordValidationError { invalid }
class SignUpState extends Equatable {
const SignUpState({
this.email = const Email.pure(),
this.password = const Password.pure(),
this.confirmedPassword = const ConfirmedPassword.pure(),
this.status = FormzStatus.pure,
this.errorMessage,
});
final Email email;
final Password password;
final ConfirmedPassword confirmedPassword;
final FormzStatus status;
final String? errorMessage;
@override
List<Object> get props => [email, password, confirmedPassword, status];
SignUpState copyWith({
Email? email,
Password? password,
ConfirmedPassword? confirmedPassword,
FormzStatus? status,
String? errorMessage,
}) {
return SignUpState(
email: email ?? this.email,
password: password ?? this.password,
confirmedPassword: confirmedPassword ?? this.confirmedPassword,
status: status ?? this.status,
errorMessage: errorMessage ?? this.errorMessage,
);
}
}
| bloc/examples/flutter_firebase_login/lib/sign_up/cubit/sign_up_state.dart/0 | {'file_path': 'bloc/examples/flutter_firebase_login/lib/sign_up/cubit/sign_up_state.dart', 'repo_id': 'bloc', 'token_count': 326} |
name: cache
description: A simple in memory cache made for dart
version: 1.0.0
publish_to: none
environment:
sdk: ">=2.19.0 <3.0.0"
dev_dependencies:
test: ^1.17.11
very_good_analysis: ^3.1.0
| bloc/examples/flutter_firebase_login/packages/cache/pubspec.yaml/0 | {'file_path': 'bloc/examples/flutter_firebase_login/packages/cache/pubspec.yaml', 'repo_id': 'bloc', 'token_count': 85} |
// ignore_for_file: prefer_const_constructors
import 'package:authentication_repository/authentication_repository.dart';
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_firebase_login/login/login.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:form_inputs/form_inputs.dart';
import 'package:formz/formz.dart';
import 'package:mocktail/mocktail.dart';
class MockAuthenticationRepository extends Mock
implements AuthenticationRepository {}
void main() {
const invalidEmailString = 'invalid';
const invalidEmail = Email.dirty(invalidEmailString);
const validEmailString = 'test@gmail.com';
const validEmail = Email.dirty(validEmailString);
const invalidPasswordString = 'invalid';
const invalidPassword = Password.dirty(invalidPasswordString);
const validPasswordString = 't0pS3cret1234';
const validPassword = Password.dirty(validPasswordString);
group('LoginCubit', () {
late AuthenticationRepository authenticationRepository;
setUp(() {
authenticationRepository = MockAuthenticationRepository();
when(
() => authenticationRepository.logInWithGoogle(),
).thenAnswer((_) async {});
when(
() => authenticationRepository.logInWithEmailAndPassword(
email: any(named: 'email'),
password: any(named: 'password'),
),
).thenAnswer((_) async {});
});
test('initial state is LoginState', () {
expect(LoginCubit(authenticationRepository).state, LoginState());
});
group('emailChanged', () {
blocTest<LoginCubit, LoginState>(
'emits [invalid] when email/password are invalid',
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.emailChanged(invalidEmailString),
expect: () => const <LoginState>[
LoginState(email: invalidEmail, status: FormzStatus.invalid),
],
);
blocTest<LoginCubit, LoginState>(
'emits [valid] when email/password are valid',
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(password: validPassword),
act: (cubit) => cubit.emailChanged(validEmailString),
expect: () => const <LoginState>[
LoginState(
email: validEmail,
password: validPassword,
status: FormzStatus.valid,
),
],
);
});
group('passwordChanged', () {
blocTest<LoginCubit, LoginState>(
'emits [invalid] when email/password are invalid',
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.passwordChanged(invalidPasswordString),
expect: () => const <LoginState>[
LoginState(
password: invalidPassword,
status: FormzStatus.invalid,
),
],
);
blocTest<LoginCubit, LoginState>(
'emits [valid] when email/password are valid',
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(email: validEmail),
act: (cubit) => cubit.passwordChanged(validPasswordString),
expect: () => const <LoginState>[
LoginState(
email: validEmail,
password: validPassword,
status: FormzStatus.valid,
),
],
);
});
group('logInWithCredentials', () {
blocTest<LoginCubit, LoginState>(
'does nothing when status is not validated',
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.logInWithCredentials(),
expect: () => const <LoginState>[],
);
blocTest<LoginCubit, LoginState>(
'calls logInWithEmailAndPassword with correct email/password',
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(
status: FormzStatus.valid,
email: validEmail,
password: validPassword,
),
act: (cubit) => cubit.logInWithCredentials(),
verify: (_) {
verify(
() => authenticationRepository.logInWithEmailAndPassword(
email: validEmailString,
password: validPasswordString,
),
).called(1);
},
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionSuccess] '
'when logInWithEmailAndPassword succeeds',
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(
status: FormzStatus.valid,
email: validEmail,
password: validPassword,
),
act: (cubit) => cubit.logInWithCredentials(),
expect: () => const <LoginState>[
LoginState(
status: FormzStatus.submissionInProgress,
email: validEmail,
password: validPassword,
),
LoginState(
status: FormzStatus.submissionSuccess,
email: validEmail,
password: validPassword,
)
],
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionFailure] '
'when logInWithEmailAndPassword fails '
'due to LogInWithEmailAndPasswordFailure',
setUp: () {
when(
() => authenticationRepository.logInWithEmailAndPassword(
email: any(named: 'email'),
password: any(named: 'password'),
),
).thenThrow(LogInWithEmailAndPasswordFailure('oops'));
},
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(
status: FormzStatus.valid,
email: validEmail,
password: validPassword,
),
act: (cubit) => cubit.logInWithCredentials(),
expect: () => const <LoginState>[
LoginState(
status: FormzStatus.submissionInProgress,
email: validEmail,
password: validPassword,
),
LoginState(
status: FormzStatus.submissionFailure,
errorMessage: 'oops',
email: validEmail,
password: validPassword,
)
],
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionFailure] '
'when logInWithEmailAndPassword fails due to generic exception',
setUp: () {
when(
() => authenticationRepository.logInWithEmailAndPassword(
email: any(named: 'email'),
password: any(named: 'password'),
),
).thenThrow(Exception('oops'));
},
build: () => LoginCubit(authenticationRepository),
seed: () => LoginState(
status: FormzStatus.valid,
email: validEmail,
password: validPassword,
),
act: (cubit) => cubit.logInWithCredentials(),
expect: () => const <LoginState>[
LoginState(
status: FormzStatus.submissionInProgress,
email: validEmail,
password: validPassword,
),
LoginState(
status: FormzStatus.submissionFailure,
email: validEmail,
password: validPassword,
)
],
);
});
group('logInWithGoogle', () {
blocTest<LoginCubit, LoginState>(
'calls logInWithGoogle',
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.logInWithGoogle(),
verify: (_) {
verify(() => authenticationRepository.logInWithGoogle()).called(1);
},
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionSuccess] '
'when logInWithGoogle succeeds',
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.logInWithGoogle(),
expect: () => const <LoginState>[
LoginState(status: FormzStatus.submissionInProgress),
LoginState(status: FormzStatus.submissionSuccess)
],
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionFailure] '
'when logInWithGoogle fails due to LogInWithGoogleFailure',
setUp: () {
when(
() => authenticationRepository.logInWithGoogle(),
).thenThrow(LogInWithGoogleFailure('oops'));
},
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.logInWithGoogle(),
expect: () => const <LoginState>[
LoginState(status: FormzStatus.submissionInProgress),
LoginState(
status: FormzStatus.submissionFailure,
errorMessage: 'oops',
)
],
);
blocTest<LoginCubit, LoginState>(
'emits [submissionInProgress, submissionFailure] '
'when logInWithGoogle fails due to generic exception',
setUp: () {
when(
() => authenticationRepository.logInWithGoogle(),
).thenThrow(Exception('oops'));
},
build: () => LoginCubit(authenticationRepository),
act: (cubit) => cubit.logInWithGoogle(),
expect: () => const <LoginState>[
LoginState(status: FormzStatus.submissionInProgress),
LoginState(status: FormzStatus.submissionFailure)
],
);
});
});
}
| bloc/examples/flutter_firebase_login/test/login/cubit/login_cubit_test.dart/0 | {'file_path': 'bloc/examples/flutter_firebase_login/test/login/cubit/login_cubit_test.dart', 'repo_id': 'bloc', 'token_count': 4033} |
part of 'my_form_bloc.dart';
abstract class MyFormEvent extends Equatable {
const MyFormEvent();
@override
List<Object> get props => [];
}
class EmailChanged extends MyFormEvent {
const EmailChanged({required this.email});
final String email;
@override
List<Object> get props => [email];
}
class EmailUnfocused extends MyFormEvent {}
class PasswordChanged extends MyFormEvent {
const PasswordChanged({required this.password});
final String password;
@override
List<Object> get props => [password];
}
class PasswordUnfocused extends MyFormEvent {}
class FormSubmitted extends MyFormEvent {}
| bloc/examples/flutter_form_validation/lib/bloc/my_form_event.dart/0 | {'file_path': 'bloc/examples/flutter_form_validation/lib/bloc/my_form_event.dart', 'repo_id': 'bloc', 'token_count': 175} |
part of 'post_bloc.dart';
abstract class PostEvent extends Equatable {
@override
List<Object> get props => [];
}
class PostFetched extends PostEvent {}
| bloc/examples/flutter_infinite_list/lib/posts/bloc/post_event.dart/0 | {'file_path': 'bloc/examples/flutter_infinite_list/lib/posts/bloc/post_event.dart', 'repo_id': 'bloc', 'token_count': 51} |
name: flutter_infinite_list
description: A new Flutter project.
version: 1.0.0+1
publish_to: none
environment:
sdk: ">=2.19.0 <3.0.0"
dependencies:
bloc: ^8.1.0
bloc_concurrency: ^0.2.0
equatable: ^2.0.3
flutter:
sdk: flutter
flutter_bloc: ^8.1.1
http: ^0.13.0
stream_transform: ^2.0.0
dev_dependencies:
bloc_test: ^9.0.0
flutter_test:
sdk: flutter
mocktail: ^0.3.0
very_good_analysis: ^3.1.0
dependency_overrides:
bloc:
path: ../../packages/bloc
bloc_test:
path: ../../packages/bloc_test
flutter_bloc:
path: ../../packages/flutter_bloc
flutter:
uses-material-design: true
| bloc/examples/flutter_infinite_list/pubspec.yaml/0 | {'file_path': 'bloc/examples/flutter_infinite_list/pubspec.yaml', 'repo_id': 'bloc', 'token_count': 294} |
import 'package:authentication_repository/authentication_repository.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_login/login/login.dart';
class LoginPage extends StatelessWidget {
const LoginPage({super.key});
static Route<void> route() {
return MaterialPageRoute<void>(builder: (_) => const LoginPage());
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Login')),
body: Padding(
padding: const EdgeInsets.all(12),
child: BlocProvider(
create: (context) {
return LoginBloc(
authenticationRepository:
RepositoryProvider.of<AuthenticationRepository>(context),
);
},
child: const LoginForm(),
),
),
);
}
}
| bloc/examples/flutter_login/lib/login/view/login_page.dart/0 | {'file_path': 'bloc/examples/flutter_login/lib/login/view/login_page.dart', 'repo_id': 'bloc', 'token_count': 362} |
import 'dart:async';
import 'package:user_repository/src/models/models.dart';
import 'package:uuid/uuid.dart';
class UserRepository {
User? _user;
Future<User?> getUser() async {
if (_user != null) return _user;
return Future.delayed(
const Duration(milliseconds: 300),
() => _user = User(const Uuid().v4()),
);
}
}
| bloc/examples/flutter_login/packages/user_repository/lib/src/user_repository.dart/0 | {'file_path': 'bloc/examples/flutter_login/packages/user_repository/lib/src/user_repository.dart', 'repo_id': 'bloc', 'token_count': 140} |
import 'package:equatable/equatable.dart';
import 'package:flutter/material.dart';
class Item extends Equatable {
Item(this.id, this.name)
: color = Colors.primaries[id % Colors.primaries.length];
final int id;
final String name;
final Color color;
final int price = 42;
@override
List<Object> get props => [id, name, color, price];
}
| bloc/examples/flutter_shopping_cart/lib/catalog/models/item.dart/0 | {'file_path': 'bloc/examples/flutter_shopping_cart/lib/catalog/models/item.dart', 'repo_id': 'bloc', 'token_count': 121} |
// ignore_for_file: prefer_const_constructors
import 'package:flutter/material.dart';
import 'package:flutter_shopping_cart/cart/cart.dart';
import 'package:flutter_shopping_cart/catalog/catalog.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import '../../helper.dart';
void main() {
late CartBloc cartBloc;
final mockItems = [
Item(1, 'item #1'),
Item(2, 'item #2'),
Item(3, 'item #3'),
];
setUp(() {
cartBloc = MockCartBloc();
});
group('CartPage', () {
testWidgets('renders CartList and CartTotal', (tester) async {
when(() => cartBloc.state).thenReturn(CartLoading());
await tester.pumpApp(
cartBloc: cartBloc,
child: CartPage(),
);
expect(find.byType(CartList), findsOneWidget);
expect(find.byType(CartTotal), findsOneWidget);
});
});
group('CartList', () {
testWidgets(
'renders CircularProgressIndicator '
'when cart is loading', (tester) async {
when(() => cartBloc.state).thenReturn(CartLoading());
await tester.pumpApp(
cartBloc: cartBloc,
child: CartList(),
);
expect(find.byType(CircularProgressIndicator), findsOneWidget);
});
testWidgets(
'renders 3 ListTile '
'when cart is loaded with three items', (tester) async {
when(() => cartBloc.state)
.thenReturn(CartLoaded(cart: Cart(items: mockItems)));
await tester.pumpApp(
cartBloc: cartBloc,
child: CartList(),
);
expect(find.byType(ListTile), findsNWidgets(3));
});
testWidgets(
'renders error text '
'when cart fails to load', (tester) async {
when(() => cartBloc.state).thenReturn(CartError());
await tester.pumpApp(
cartBloc: cartBloc,
child: CartList(),
);
expect(find.text('Something went wrong!'), findsOneWidget);
});
});
group('CartTotal', () {
testWidgets(
'renders CircularProgressIndicator '
'when cart is loading', (tester) async {
when(() => cartBloc.state).thenReturn(CartLoading());
await tester.pumpApp(
cartBloc: cartBloc,
child: CartTotal(),
);
expect(find.byType(CircularProgressIndicator), findsOneWidget);
});
testWidgets(
'renders total price '
'when cart is loaded with three items', (tester) async {
when(() => cartBloc.state)
.thenReturn(CartLoaded(cart: Cart(items: mockItems)));
await tester.pumpApp(
cartBloc: cartBloc,
child: CartTotal(),
);
expect(find.text('\$${42 * 3}'), findsOneWidget);
});
testWidgets(
'renders error text '
'when cart fails to load', (tester) async {
when(() => cartBloc.state).thenReturn(CartError());
await tester.pumpApp(
cartBloc: cartBloc,
child: CartTotal(),
);
expect(find.text('Something went wrong!'), findsOneWidget);
});
testWidgets(
'renders SnackBar after '
"tapping the 'BUY' button", (tester) async {
when(() => cartBloc.state)
.thenReturn(CartLoaded(cart: Cart(items: mockItems)));
await tester.pumpApp(
cartBloc: cartBloc,
child: Scaffold(body: CartTotal()),
);
await tester.tap(find.text('BUY'));
await tester.pumpAndSettle();
expect(find.byType(SnackBar), findsOneWidget);
expect(find.text('Buying not supported yet.'), findsOneWidget);
});
testWidgets('adds CartItemRemoved on long press', (tester) async {
when(() => cartBloc.state).thenReturn(
CartLoaded(cart: Cart(items: mockItems)),
);
final mockItemToRemove = mockItems.last;
await tester.pumpApp(
cartBloc: cartBloc,
child: Scaffold(body: CartList()),
);
await tester.longPress(find.text(mockItemToRemove.name));
verify(() => cartBloc.add(CartItemRemoved(mockItemToRemove))).called(1);
});
});
}
| bloc/examples/flutter_shopping_cart/test/cart/view/cart_page_test.dart/0 | {'file_path': 'bloc/examples/flutter_shopping_cart/test/cart/view/cart_page_test.dart', 'repo_id': 'bloc', 'token_count': 1737} |
import 'package:flutter/material.dart';
import 'package:flutter_timer/app.dart';
void main() => runApp(const App());
| bloc/examples/flutter_timer/lib/main.dart/0 | {'file_path': 'bloc/examples/flutter_timer/lib/main.dart', 'repo_id': 'bloc', 'token_count': 40} |
import 'dart:async';
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_timer/timer/timer.dart';
import 'package:mocktail/mocktail.dart';
class _MockTimerBloc extends MockBloc<TimerEvent, TimerState>
implements TimerBloc {}
class _FakeTimerEvent extends Fake implements TimerEvent {}
extension on WidgetTester {
Future<void> pumpTimerView(TimerBloc timerBloc) {
return pumpWidget(
MaterialApp(
home: BlocProvider.value(value: timerBloc, child: const TimerView()),
),
);
}
}
void main() {
late TimerBloc timerBloc;
setUpAll(() {
registerFallbackValue(_FakeTimerEvent());
});
setUp(() {
timerBloc = _MockTimerBloc();
});
tearDown(() => reset(timerBloc));
group('TimerPage', () {
testWidgets('renders TimerView', (tester) async {
await tester.pumpWidget(const MaterialApp(home: TimerPage()));
expect(find.byType(TimerView), findsOneWidget);
});
});
group('TimerView', () {
testWidgets('renders initial Timer view', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerInitial(60));
await tester.pumpTimerView(timerBloc);
expect(find.text('01:00'), findsOneWidget);
expect(find.byIcon(Icons.play_arrow), findsOneWidget);
});
testWidgets('renders pause and reset button when timer is in progress',
(tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunInProgress(59));
await tester.pumpTimerView(timerBloc);
expect(find.text('00:59'), findsOneWidget);
expect(find.byIcon(Icons.pause), findsOneWidget);
expect(find.byIcon(Icons.replay), findsOneWidget);
});
testWidgets('renders play and reset button when timer is paused',
(tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunPause(600));
await tester.pumpTimerView(timerBloc);
expect(find.text('10:00'), findsOneWidget);
expect(find.byIcon(Icons.play_arrow), findsOneWidget);
expect(find.byIcon(Icons.replay), findsOneWidget);
});
testWidgets('renders replay button when timer is finished', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunComplete());
await tester.pumpTimerView(timerBloc);
expect(find.text('00:00'), findsOneWidget);
expect(find.byIcon(Icons.replay), findsOneWidget);
});
testWidgets('timer started when play arrow button is pressed',
(tester) async {
when(() => timerBloc.state).thenReturn(const TimerInitial(60));
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.play_arrow));
verify(
() => timerBloc.add(
any(
that: isA<TimerStarted>().having((e) => e.duration, 'duration', 60),
),
),
).called(1);
});
testWidgets(
'timer pauses when pause button is pressed '
'while timer is in progress', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunInProgress(30));
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.pause));
verify(() => timerBloc.add(const TimerPaused())).called(1);
});
testWidgets(
'timer resets when replay button is pressed '
'while timer is in progress', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunInProgress(30));
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.replay));
verify(() => timerBloc.add(const TimerReset())).called(1);
});
testWidgets(
'timer resumes when play arrow button is pressed '
'while timer is paused', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunPause(30));
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.play_arrow));
verify(() => timerBloc.add(const TimerResumed())).called(1);
});
testWidgets(
'timer resets when reset button is pressed '
'while timer is paused', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunPause(30));
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.replay));
verify(() => timerBloc.add(const TimerReset())).called(1);
});
testWidgets(
'timer resets when reset button is pressed '
'when timer is finished', (tester) async {
when(() => timerBloc.state).thenReturn(const TimerRunComplete());
await tester.pumpTimerView(timerBloc);
await tester.tap(find.byIcon(Icons.replay));
verify(() => timerBloc.add(const TimerReset())).called(1);
});
testWidgets('actions are not rebuilt when timer is running',
(tester) async {
final controller = StreamController<TimerState>();
whenListen(
timerBloc,
controller.stream,
initialState: const TimerRunInProgress(10),
);
await tester.pumpTimerView(timerBloc);
FloatingActionButton findPauseButton() {
return tester.widget<FloatingActionButton>(
find.byWidgetPredicate(
(widget) =>
widget is FloatingActionButton &&
widget.child is Icon &&
(widget.child! as Icon).icon == Icons.pause,
),
);
}
final pauseButton = findPauseButton();
controller.add(const TimerRunInProgress(9));
await tester.pump();
expect(pauseButton, equals(findPauseButton()));
});
});
}
| bloc/examples/flutter_timer/test/timer/view/timer_page_test.dart/0 | {'file_path': 'bloc/examples/flutter_timer/test/timer/view/timer_page_test.dart', 'repo_id': 'bloc', 'token_count': 2275} |
export 'edit_todo_page.dart';
| bloc/examples/flutter_todos/lib/edit_todo/view/view.dart/0 | {'file_path': 'bloc/examples/flutter_todos/lib/edit_todo/view/view.dart', 'repo_id': 'bloc', 'token_count': 13} |
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_todos/l10n/l10n.dart';
import 'package:flutter_todos/stats/stats.dart';
import 'package:todos_repository/todos_repository.dart';
class StatsPage extends StatelessWidget {
const StatsPage({super.key});
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) => StatsBloc(
todosRepository: context.read<TodosRepository>(),
)..add(const StatsSubscriptionRequested()),
child: const StatsView(),
);
}
}
class StatsView extends StatelessWidget {
const StatsView({super.key});
@override
Widget build(BuildContext context) {
final l10n = context.l10n;
final state = context.watch<StatsBloc>().state;
final textTheme = Theme.of(context).textTheme;
return Scaffold(
appBar: AppBar(
title: Text(l10n.statsAppBarTitle),
),
body: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
ListTile(
key: const Key('statsView_completedTodos_listTile'),
leading: const Icon(Icons.check_rounded),
title: Text(l10n.statsCompletedTodoCountLabel),
trailing: Text(
'${state.completedTodos}',
style: textTheme.headlineSmall,
),
),
ListTile(
key: const Key('statsView_activeTodos_listTile'),
leading: const Icon(Icons.radio_button_unchecked_rounded),
title: Text(l10n.statsActiveTodoCountLabel),
trailing: Text(
'${state.activeTodos}',
style: textTheme.headlineSmall,
),
),
],
),
);
}
}
| bloc/examples/flutter_todos/lib/stats/view/stats_page.dart/0 | {'file_path': 'bloc/examples/flutter_todos/lib/stats/view/stats_page.dart', 'repo_id': 'bloc', 'token_count': 793} |
// ignore_for_file: avoid_redundant_argument_values
import 'package:test/test.dart';
import 'package:todos_api/todos_api.dart';
void main() {
group('Todo', () {
Todo createSubject({
String? id = '1',
String title = 'title',
String description = 'description',
bool isCompleted = true,
}) {
return Todo(
id: id,
title: title,
description: description,
isCompleted: isCompleted,
);
}
group('constructor', () {
test('works correctly', () {
expect(
createSubject,
returnsNormally,
);
});
test('throws AssertionError when id is empty', () {
expect(
() => createSubject(id: ''),
throwsA(isA<AssertionError>()),
);
});
test('sets id if not provided', () {
expect(
createSubject(id: null).id,
isNotEmpty,
);
});
});
test('supports value equality', () {
expect(
createSubject(),
equals(createSubject()),
);
});
test('props are correct', () {
expect(
createSubject().props,
equals([
'1', // id
'title', // title
'description', // description
true, // isCompleted
]),
);
});
group('copyWith', () {
test('returns the same object if not arguments are provided', () {
expect(
createSubject().copyWith(),
equals(createSubject()),
);
});
test('retains the old value for every parameter if null is provided', () {
expect(
createSubject().copyWith(
id: null,
title: null,
description: null,
isCompleted: null,
),
equals(createSubject()),
);
});
test('replaces every non-null parameter', () {
expect(
createSubject().copyWith(
id: '2',
title: 'new title',
description: 'new description',
isCompleted: false,
),
equals(
createSubject(
id: '2',
title: 'new title',
description: 'new description',
isCompleted: false,
),
),
);
});
});
group('fromJson', () {
test('works correctly', () {
expect(
Todo.fromJson(<String, dynamic>{
'id': '1',
'title': 'title',
'description': 'description',
'isCompleted': true,
}),
equals(createSubject()),
);
});
});
group('toJson', () {
test('works correctly', () {
expect(
createSubject().toJson(),
equals(<String, dynamic>{
'id': '1',
'title': 'title',
'description': 'description',
'isCompleted': true,
}),
);
});
});
});
}
| bloc/examples/flutter_todos/packages/todos_api/test/models/todo_test.dart/0 | {'file_path': 'bloc/examples/flutter_todos/packages/todos_api/test/models/todo_test.dart', 'repo_id': 'bloc', 'token_count': 1511} |
import 'package:flutter_test/flutter_test.dart';
extension ExtraFinders on CommonFinders {
/// Finds a widget by a specific type [T].
///
/// ```dart
/// find.bySpecificType<Foo<Bar>>()
/// ```
Finder bySpecificType<T>() => find.byType(T);
}
| bloc/examples/flutter_todos/test/helpers/finders.dart/0 | {'file_path': 'bloc/examples/flutter_todos/test/helpers/finders.dart', 'repo_id': 'bloc', 'token_count': 94} |
// ignore_for_file: avoid_redundant_argument_values
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_todos/todos_overview/todos_overview.dart';
import 'package:mocktail/mocktail.dart';
import '../../helpers/helpers.dart';
class MockTodosOverviewBloc
extends MockBloc<TodosOverviewEvent, TodosOverviewState>
implements TodosOverviewBloc {}
extension on CommonFinders {
Finder filterMenuItem({
required TodosViewFilter filter,
required String title,
}) {
return find.descendant(
of: find.byWidgetPredicate(
(w) => w is PopupMenuItem && w.value == filter,
),
matching: find.text(title),
);
}
}
extension on WidgetTester {
Future<void> openPopup() async {
await tap(find.byType(TodosOverviewFilterButton));
await pumpAndSettle();
}
}
void main() {
group('TodosOverviewFilterButton', () {
late TodosOverviewBloc todosOverviewBloc;
setUp(() {
todosOverviewBloc = MockTodosOverviewBloc();
when(() => todosOverviewBloc.state).thenReturn(
const TodosOverviewState(
status: TodosOverviewStatus.success,
todos: [],
),
);
});
Widget buildSubject() {
return BlocProvider.value(
value: todosOverviewBloc,
child: const TodosOverviewFilterButton(),
);
}
group('constructor', () {
test('works properly', () {
expect(
() => const TodosOverviewFilterButton(),
returnsNormally,
);
});
});
testWidgets('renders filter list icon', (tester) async {
await tester.pumpApp(buildSubject());
expect(
find.byIcon(Icons.filter_list_rounded),
findsOneWidget,
);
});
group('internal PopupMenuButton', () {
testWidgets('is rendered', (tester) async {
await tester.pumpApp(buildSubject());
expect(
find.bySpecificType<PopupMenuButton<TodosViewFilter>>(),
findsOneWidget,
);
});
testWidgets('has initial value set to active filter', (tester) async {
when(() => todosOverviewBloc.state).thenReturn(
const TodosOverviewState(
filter: TodosViewFilter.completedOnly,
),
);
await tester.pumpApp(buildSubject());
final popupMenuButton = tester.widget<PopupMenuButton<TodosViewFilter>>(
find.bySpecificType<PopupMenuButton<TodosViewFilter>>(),
);
expect(
popupMenuButton.initialValue,
equals(TodosViewFilter.completedOnly),
);
});
testWidgets(
'renders items for each filter type when pressed',
(tester) async {
await tester.pumpApp(buildSubject());
await tester.openPopup();
expect(
find.filterMenuItem(
filter: TodosViewFilter.all,
title: l10n.todosOverviewFilterAll,
),
findsOneWidget,
);
expect(
find.filterMenuItem(
filter: TodosViewFilter.activeOnly,
title: l10n.todosOverviewFilterActiveOnly,
),
findsOneWidget,
);
expect(
find.filterMenuItem(
filter: TodosViewFilter.completedOnly,
title: l10n.todosOverviewFilterCompletedOnly,
),
findsOneWidget,
);
},
);
testWidgets(
'adds TodosOverviewFilterChanged '
'to TodosOverviewBloc '
'when new filter is pressed',
(tester) async {
when(() => todosOverviewBloc.state).thenReturn(
const TodosOverviewState(
filter: TodosViewFilter.all,
),
);
await tester.pumpApp(buildSubject());
await tester.openPopup();
await tester.tap(find.text(l10n.todosOverviewFilterCompletedOnly));
await tester.pumpAndSettle();
verify(
() => todosOverviewBloc.add(
const TodosOverviewFilterChanged(TodosViewFilter.completedOnly),
),
).called(1);
},
);
});
});
}
| bloc/examples/flutter_todos/test/todos_overview/widgets/todos_overview_filter_button_test.dart/0 | {'file_path': 'bloc/examples/flutter_todos/test/todos_overview/widgets/todos_overview_filter_button_test.dart', 'repo_id': 'bloc', 'token_count': 1999} |
export 'view/settings_page.dart';
| bloc/examples/flutter_weather/lib/settings/settings.dart/0 | {'file_path': 'bloc/examples/flutter_weather/lib/settings/settings.dart', 'repo_id': 'bloc', 'token_count': 12} |
name: open_meteo_api
description: A Dart API Client for the Open-Meteo API.
version: 1.0.0+1
environment:
sdk: ">=2.19.0 <3.0.0"
dependencies:
http: ^0.13.0
json_annotation: ^4.6.0
dev_dependencies:
build_runner: ^2.0.0
json_serializable: ^6.3.1
mocktail: ^0.3.0
test: ^1.16.4
very_good_analysis: ^3.0.2
| bloc/examples/flutter_weather/packages/open_meteo_api/pubspec.yaml/0 | {'file_path': 'bloc/examples/flutter_weather/packages/open_meteo_api/pubspec.yaml', 'repo_id': 'bloc', 'token_count': 155} |
import 'package:bloc_test/bloc_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_weather/app.dart';
import 'package:flutter_weather/theme/theme.dart';
import 'package:flutter_weather/weather/weather.dart';
import 'package:mocktail/mocktail.dart';
import 'package:weather_repository/weather_repository.dart';
import 'helpers/hydrated_bloc.dart';
class MockThemeCubit extends MockCubit<Color> implements ThemeCubit {}
class MockWeatherRepository extends Mock implements WeatherRepository {}
void main() {
initHydratedStorage();
group('WeatherApp', () {
late WeatherRepository weatherRepository;
setUp(() {
weatherRepository = MockWeatherRepository();
});
testWidgets('renders WeatherAppView', (tester) async {
await tester.pumpWidget(
WeatherApp(weatherRepository: weatherRepository),
);
expect(find.byType(WeatherAppView), findsOneWidget);
});
});
group('WeatherAppView', () {
late ThemeCubit themeCubit;
late WeatherRepository weatherRepository;
setUp(() {
themeCubit = MockThemeCubit();
weatherRepository = MockWeatherRepository();
});
testWidgets('renders WeatherPage', (tester) async {
when(() => themeCubit.state).thenReturn(Colors.blue);
await tester.pumpWidget(
RepositoryProvider.value(
value: weatherRepository,
child: BlocProvider.value(
value: themeCubit,
child: const WeatherAppView(),
),
),
);
expect(find.byType(WeatherPage), findsOneWidget);
});
testWidgets('has correct theme primary color', (tester) async {
const color = Color(0xFFD2D2D2);
when(() => themeCubit.state).thenReturn(color);
await tester.pumpWidget(
RepositoryProvider.value(
value: weatherRepository,
child: BlocProvider.value(
value: themeCubit,
child: const WeatherAppView(),
),
),
);
final materialApp = tester.widget<MaterialApp>(find.byType(MaterialApp));
expect(materialApp.theme?.primaryColor, color);
});
});
}
| bloc/examples/flutter_weather/test/app_test.dart/0 | {'file_path': 'bloc/examples/flutter_weather/test/app_test.dart', 'repo_id': 'bloc', 'token_count': 873} |
name: angular_github_search
description: A web app that uses AngularDart Components
environment:
sdk: ">=2.19.0 <3.0.0"
dependencies:
angular_bloc: ^8.0.0
bloc: ^8.1.0
common_github_search:
path: ../common_github_search
ngdart: ^8.0.0-dev.0
dev_dependencies:
build_runner: ^2.0.0
build_web_compilers: ^3.0.0
very_good_analysis: ^4.0.0
| bloc/examples/github_search/angular_github_search/pubspec.yaml/0 | {'file_path': 'bloc/examples/github_search/angular_github_search/pubspec.yaml', 'repo_id': 'bloc', 'token_count': 157} |
import 'package:common_github_search/common_github_search.dart';
class SearchResult {
const SearchResult({required this.items});
factory SearchResult.fromJson(Map<String, dynamic> json) {
final items = (json['items'] as List<dynamic>)
.map(
(dynamic item) =>
SearchResultItem.fromJson(item as Map<String, dynamic>),
)
.toList();
return SearchResult(items: items);
}
final List<SearchResultItem> items;
}
| bloc/examples/github_search/common_github_search/lib/src/models/search_result.dart/0 | {'file_path': 'bloc/examples/github_search/common_github_search/lib/src/models/search_result.dart', 'repo_id': 'bloc', 'token_count': 181} |
# As of test: ^0.12.32, we can use a common/base dart_test.yaml, which this is.
#
# See documentation:
# * https://github.com/dart-lang/test/blob/master/doc/configuration.md
# * https://github.com/dart-lang/test/blob/master/doc/configuration.md#include
presets:
# When run with -P travis, we have different settings/options.
#
# 1: We don't use Chrome --headless:
# 2: We use --reporter expanded
# 3: We skip anything tagged "fails-on-travis".
travis:
override_platforms:
chrome:
settings:
# Disable some security options, since this is only on Travis.
# https://chromium.googlesource.com/chromium/src/+/master/docs/design/sandbox.md
# https://docs.travis-ci.com/user/chrome#Sandboxing
arguments: --no-sandbox
# TODO(https://github.com/dart-lang/test/issues/772)
headless: false
# Don't run any tests that are tagged ["fails-on-travis"].
exclude_tags: "fails-on-travis"
# https://github.com/dart-lang/test/blob/master/doc/configuration.md#reporter
reporter: expanded
# This repository has only web tests.
platforms:
- chrome | bloc/packages/angular_bloc/dart_test.yaml/0 | {'file_path': 'bloc/packages/angular_bloc/dart_test.yaml', 'repo_id': 'bloc', 'token_count': 442} |
part of 'bloc.dart';
/// An object that provides access to a stream of states over time.
abstract class Streamable<State extends Object?> {
/// The current [stream] of states.
Stream<State> get stream;
}
/// A [Streamable] that provides synchronous access to the current [state].
abstract class StateStreamable<State> implements Streamable<State> {
/// The current [state].
State get state;
}
/// A [StateStreamable] that must be closed when no longer in use.
abstract class StateStreamableSource<State>
implements StateStreamable<State>, Closable {}
/// An object that must be closed when no longer in use.
abstract class Closable {
/// Closes the current instance.
/// The returned future completes when the instance has been closed.
FutureOr<void> close();
/// Whether the object is closed.
///
/// An object is considered closed once [close] is called.
bool get isClosed;
}
/// An object that can emit new states.
abstract class Emittable<State extends Object?> {
/// Emits a new [state].
void emit(State state);
}
/// A generic destination for errors.
///
/// Multiple errors can be reported to the sink via `addError`.
abstract class ErrorSink implements Closable {
/// Adds an [error] to the sink with an optional [stackTrace].
///
/// Must not be called on a closed sink.
void addError(Object error, [StackTrace? stackTrace]);
}
/// {@template bloc_base}
/// An interface for the core functionality implemented by
/// both [Bloc] and [Cubit].
/// {@endtemplate}
abstract class BlocBase<State>
implements StateStreamableSource<State>, Emittable<State>, ErrorSink {
/// {@macro bloc_base}
BlocBase(this._state) {
// ignore: invalid_use_of_protected_member
_blocObserver.onCreate(this);
}
// ignore: deprecated_member_use_from_same_package
final _blocObserver = BlocOverrides.current?.blocObserver ?? Bloc.observer;
late final _stateController = StreamController<State>.broadcast();
State _state;
bool _emitted = false;
@override
State get state => _state;
@override
Stream<State> get stream => _stateController.stream;
/// Whether the bloc is closed.
///
/// A bloc is considered closed once [close] is called.
/// Subsequent state changes cannot occur within a closed bloc.
@override
bool get isClosed => _stateController.isClosed;
/// Updates the [state] to the provided [state].
/// [emit] does nothing if the [state] being emitted
/// is equal to the current [state].
///
/// To allow for the possibility of notifying listeners of the initial state,
/// emitting a state which is equal to the initial state is allowed as long
/// as it is the first thing emitted by the instance.
///
/// * Throws a [StateError] if the bloc is closed.
@protected
@visibleForTesting
@override
void emit(State state) {
try {
if (isClosed) {
throw StateError('Cannot emit new states after calling close');
}
if (state == _state && _emitted) return;
onChange(Change<State>(currentState: this.state, nextState: state));
_state = state;
_stateController.add(_state);
_emitted = true;
} catch (error, stackTrace) {
onError(error, stackTrace);
rethrow;
}
}
/// Called whenever a [change] occurs with the given [change].
/// A [change] occurs when a new `state` is emitted.
/// [onChange] is called before the `state` of the `cubit` is updated.
/// [onChange] is a great spot to add logging/analytics for a specific `cubit`.
///
/// **Note: `super.onChange` should always be called first.**
/// ```dart
/// @override
/// void onChange(Change change) {
/// // Always call super.onChange with the current change
/// super.onChange(change);
///
/// // Custom onChange logic goes here
/// }
/// ```
///
/// See also:
///
/// * [BlocObserver] for observing [Cubit] behavior globally.
///
@protected
@mustCallSuper
void onChange(Change<State> change) {
// ignore: invalid_use_of_protected_member
_blocObserver.onChange(this, change);
}
/// Reports an [error] which triggers [onError] with an optional [StackTrace].
@protected
@mustCallSuper
@override
void addError(Object error, [StackTrace? stackTrace]) {
onError(error, stackTrace ?? StackTrace.current);
}
/// Called whenever an [error] occurs and notifies [BlocObserver.onError].
///
/// **Note: `super.onError` should always be called last.**
///
/// ```dart
/// @override
/// void onError(Object error, StackTrace stackTrace) {
/// // Custom onError logic goes here
///
/// // Always call super.onError with the current error and stackTrace
/// super.onError(error, stackTrace);
/// }
/// ```
@protected
@mustCallSuper
void onError(Object error, StackTrace stackTrace) {
// ignore: invalid_use_of_protected_member
_blocObserver.onError(this, error, stackTrace);
}
/// Closes the instance.
/// This method should be called when the instance is no longer needed.
/// Once [close] is called, the instance can no longer be used.
@mustCallSuper
@override
Future<void> close() async {
// ignore: invalid_use_of_protected_member
_blocObserver.onClose(this);
await _stateController.close();
}
}
| bloc/packages/bloc/lib/src/bloc_base.dart/0 | {'file_path': 'bloc/packages/bloc/lib/src/bloc_base.dart', 'repo_id': 'bloc', 'token_count': 1662} |
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:meta/meta.dart';
part 'async_event.dart';
part 'async_state.dart';
class AsyncBloc extends Bloc<AsyncEvent, AsyncState> {
AsyncBloc() : super(AsyncState.initial()) {
on<AsyncEvent>(
(event, emit) async {
emit(state.copyWith(isLoading: true, isSuccess: false));
await Future<void>.delayed(Duration.zero);
emit(state.copyWith(isLoading: false, isSuccess: true));
},
transformer: (events, mapper) => events.asyncExpand(mapper),
);
}
}
| bloc/packages/bloc/test/blocs/async/async_bloc.dart/0 | {'file_path': 'bloc/packages/bloc/test/blocs/async/async_bloc.dart', 'repo_id': 'bloc', 'token_count': 228} |
import 'package:bloc/bloc.dart';
class SeededBloc extends Bloc<String, int> {
SeededBloc({required this.seed, required this.states}) : super(seed) {
on<String>((event, emit) {
for (final state in states) {
emit(state);
}
});
}
final List<int> states;
final int seed;
}
| bloc/packages/bloc/test/blocs/seeded/seeded_bloc.dart/0 | {'file_path': 'bloc/packages/bloc/test/blocs/seeded/seeded_bloc.dart', 'repo_id': 'bloc', 'token_count': 125} |
import 'package:bloc/bloc.dart';
import 'blocs.dart';
class ErrorCounterBlocError extends Error {}
class ErrorCounterBloc extends Bloc<CounterEvent, int> {
ErrorCounterBloc() : super(0) {
on<CounterEvent>((event, emit) {
switch (event) {
case CounterEvent.increment:
emit(state + 1);
throw ErrorCounterBlocError();
}
});
}
}
| bloc/packages/bloc_test/test/blocs/error_counter_bloc.dart/0 | {'file_path': 'bloc/packages/bloc_test/test/blocs/error_counter_bloc.dart', 'repo_id': 'bloc', 'token_count': 157} |
import 'package:bloc/bloc.dart';
class Repository {
void sideEffect() {}
}
class SideEffectCounterCubit extends Cubit<int> {
SideEffectCounterCubit(this.repository) : super(0);
final Repository repository;
void increment() {
repository.sideEffect();
emit(state + 1);
}
}
| bloc/packages/bloc_test/test/cubits/side_effect_counter_cubit.dart/0 | {'file_path': 'bloc/packages/bloc_test/test/cubits/side_effect_counter_cubit.dart', 'repo_id': 'bloc', 'token_count': 100} |
@Tags(['pull-request-only'])
import 'package:build_verify/build_verify.dart';
import 'package:test/test.dart';
void main() {
test('ensure_build', () {
expectBuildClean(packageRelativeDirectory: 'packages/bloc_tools');
});
}
| bloc/packages/bloc_tools/test/ensure_build_test.dart/0 | {'file_path': 'bloc/packages/bloc_tools/test/ensure_build_test.dart', 'repo_id': 'bloc', 'token_count': 85} |
import 'dart:typed_data';
import 'package:hive/hive.dart';
/// Abstract cipher can be implemented to customize encryption.
abstract class HydratedCipher implements HiveCipher {
/// Calculate a hash of the key. Make sure to use a secure hash.
@override
int calculateKeyCrc();
/// The maximum size the input can have after it has been encrypted.
@override
int maxEncryptedSize(Uint8List inp);
/// Encrypt the given bytes.
@override
int encrypt(
Uint8List inp,
int inpOff,
int inpLength,
Uint8List out,
int outOff,
);
/// Decrypt the given bytes.
@override
int decrypt(
Uint8List inp,
int inpOff,
int inpLength,
Uint8List out,
int outOff,
);
}
/// Default encryption algorithm. Uses AES256 CBC with PKCS7 padding.
class HydratedAesCipher extends HiveAesCipher implements HydratedCipher {
/// Create a cipher with the given [key].
HydratedAesCipher(List<int> key) : super(key);
}
| bloc/packages/hydrated_bloc/lib/src/hydrated_cipher.dart/0 | {'file_path': 'bloc/packages/hydrated_bloc/lib/src/hydrated_cipher.dart', 'repo_id': 'bloc', 'token_count': 330} |
import 'dart:io';
import 'package:hive/hive.dart';
// ignore: implementation_imports
import 'package:hive/src/hive_impl.dart';
import 'package:path/path.dart' as p;
import 'package:test/test.dart';
void main() {
group('Hive interference', () {
tearDown(() {
Hive.close();
(Hive as HiveImpl).homePath = null;
});
test('odd singleton interference', () async {
final cwd = Directory.current.absolute.path;
var impl1 = HiveImpl()..init(cwd);
var box1 = await impl1.openBox<dynamic>('impl1');
var impl2 = HiveImpl()..init(cwd);
var box2 = await impl2.openBox<dynamic>('impl2');
await impl1.close();
expect(box1.isOpen, false);
expect(box2.isOpen, true);
impl1 = HiveImpl()..init(cwd);
box1 = await impl1.openBox<dynamic>('impl1');
Hive.init(cwd);
await box1.deleteFromDisk();
await box2.close();
await Hive.deleteBoxFromDisk('impl2');
});
test('two hive impls beside same directory', () async {
final cwd = Directory.current.absolute.path;
final impl1 = Hive..init(cwd);
var box1 = await impl1.openBox<dynamic>('impl1');
final impl2 = HiveImpl()..init(cwd);
var box2 = await impl2.openBox<dynamic>('impl2');
await box1.put('instance', 'impl1');
await box2.put('instance', 'impl2');
await impl1.close();
await impl2.close();
box1 = await impl1.openBox<dynamic>('impl1');
box2 = await impl2.openBox<dynamic>('impl2');
expect(box1.get('instance'), 'impl1');
expect(box2.get('instance'), 'impl2');
await impl1.deleteFromDisk();
expect(box1.isOpen, false);
expect(box2.isOpen, true);
expect(box2.get('instance'), 'impl2');
await impl2.deleteFromDisk();
expect(box2.isOpen, false);
});
test('two hive impls reside distinct directories', () async {
final cwd1 = p.join(Directory.current.absolute.path, 'cwd1');
final cwd2 = p.join(Directory.current.absolute.path, 'cwd2');
final impl1 = Hive..init(cwd1);
var box1 = await impl1.openBox<dynamic>('impl1');
final impl2 = HiveImpl()..init(cwd2);
var box2 = await impl2.openBox<dynamic>('impl2');
await box1.put('instance', 'impl1');
await box2.put('instance', 'impl2');
await impl1.close();
await impl2.close();
box1 = await impl1.openBox<dynamic>('impl1');
box2 = await impl2.openBox<dynamic>('impl2');
expect(box1.get('instance'), 'impl1');
expect(box2.get('instance'), 'impl2');
await impl1.deleteFromDisk();
expect(box1.isOpen, false);
expect(box2.isOpen, true);
expect(box2.get('instance'), 'impl2');
await impl2.deleteFromDisk();
expect(box2.isOpen, false);
await Directory(cwd1).delete();
await Directory(cwd2).delete();
});
});
}
| bloc/packages/hydrated_bloc/test/hive_interference_test.dart/0 | {'file_path': 'bloc/packages/hydrated_bloc/test/hive_interference_test.dart', 'repo_id': 'bloc', 'token_count': 1199} |
/// An extension to the [bloc state management library](https://pub.dev/packages/bloc)
/// which adds support for undo and redo.
///
/// Get started at [bloclibrary.dev](https://bloclibrary.dev) 🚀
library replay_bloc;
export 'package:bloc/bloc.dart';
export 'src/replay_cubit.dart';
| bloc/packages/replay_bloc/lib/replay_bloc.dart/0 | {'file_path': 'bloc/packages/replay_bloc/lib/replay_bloc.dart', 'repo_id': 'bloc', 'token_count': 97} |
export 'add_todo_page.dart';
| bloc_todos/lib/add_todo/add_todo.dart/0 | {'file_path': 'bloc_todos/lib/add_todo/add_todo.dart', 'repo_id': 'bloc_todos', 'token_count': 13} |
import 'package:bloc_todos/add_todo/add_todo.dart';
import 'package:bloc_todos/filtered_todos/bloc/filtered_todos_bloc.dart';
import 'package:bloc_todos/home/home.dart';
import 'package:bloc_todos/stats/stats.dart';
import 'package:bloc_todos/todos/todos.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
class HomePage extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MultiBlocProvider(
providers: [
BlocProvider(create: (_) => HomeBloc()),
BlocProvider(
create: (context) => FilteredTodosBloc(
todos: context.bloc<TodosBloc>(),
),
),
],
child: Home(),
);
}
}
class Home extends StatelessWidget {
@override
Widget build(BuildContext context) {
return BlocBuilder<HomeBloc, HomeState>(
builder: (context, state) {
return GestureDetector(
onTap: () {
final focusNode = FocusScope.of(context);
if (!focusNode.hasPrimaryFocus) {
focusNode.unfocus();
}
context.bloc<TodosBloc>().add(const TodoSelected(null));
},
child: Scaffold(
appBar: AppBar(
title: const Text('Flutter Todos'),
actions: [
TodoToggleButton(visible: state.activeTab == HomeTab.todos),
TodoFilterButton(visible: state.activeTab == HomeTab.todos),
const ExtraActions(),
],
),
body: state.activeTab == HomeTab.stats
? const StatsPage()
: const TodosPage(),
floatingActionButton: FloatingActionButton(
onPressed: () => Navigator.of(context).push(AddTodoPage.route()),
child: const Icon(Icons.add),
tooltip: 'Add Todo',
),
bottomNavigationBar: BottomNavigation(
activeTab: state.activeTab,
onTabChanged: (index) {
context.bloc<HomeBloc>().add(HomeTabChanged(index));
},
),
),
);
},
);
}
}
| bloc_todos/lib/home/home_page.dart/0 | {'file_path': 'bloc_todos/lib/home/home_page.dart', 'repo_id': 'bloc_todos', 'token_count': 1080} |
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'todo.dart';
// **************************************************************************
// JsonSerializableGenerator
// **************************************************************************
Todo _$TodoFromJson(Map<String, dynamic> json) {
return Todo(
json['task'] as String,
complete: json['complete'] as bool,
note: json['note'] as String,
id: json['id'] as String,
);
}
Map<String, dynamic> _$TodoToJson(Todo instance) => <String, dynamic>{
'complete': instance.complete,
'id': instance.id,
'note': instance.note,
'task': instance.task,
};
| bloc_todos/lib/todos/models/todo.g.dart/0 | {'file_path': 'bloc_todos/lib/todos/models/todo.g.dart', 'repo_id': 'bloc_todos', 'token_count': 213} |
int calcHatPrice(int length) => ((length * 50) + 10);
| bob_box/game/lib/screens/util.dart/0 | {'file_path': 'bob_box/game/lib/screens/util.dart', 'repo_id': 'bob_box', 'token_count': 18} |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 39