From ad6e389f0abce96afffe7d3d207fd0362970af5a Mon Sep 17 00:00:00 2001 From: Felix Angelov Date: Sat, 14 Oct 2023 18:19:12 -0500 Subject: [PATCH] refactor: update `analysis_options.yaml` (#169) --- analysis_options.yaml | 138 ++++++++++++++- example/main.dart | 6 +- example/pubspec.yaml | 2 +- lib/src/equatable.dart | 16 +- lib/src/equatable_config.dart | 3 +- lib/src/equatable_mixin.dart | 7 +- lib/src/equatable_utils.dart | 28 +-- test/custom_list.dart | 36 ++-- test/equatable_mixin_test.dart | 144 ++++++++++------ test/equatable_test.dart | 307 +++++++++++++++++---------------- 10 files changed, 426 insertions(+), 261 deletions(-) diff --git a/analysis_options.yaml b/analysis_options.yaml index e7fcb233..aded668f 100644 --- a/analysis_options.yaml +++ b/analysis_options.yaml @@ -1,81 +1,201 @@ analyzer: - strong-mode: - implicit-casts: false - implicit-dynamic: false + language: + strict-casts: true + strict-inference: true + strict-raw-types: true + errors: close_sinks: ignore + missing_required_param: error + missing_return: error + record_literal_one_positional_no_trailing_comma: error linter: rules: - - public_member_api_docs + - always_declare_return_types + - always_put_required_named_parameters_first + - always_use_package_imports - annotate_overrides + - avoid_bool_literals_in_conditional_expressions + - avoid_catching_errors + - avoid_double_and_int_checks + - avoid_dynamic_calls - avoid_empty_else + - avoid_equals_and_hash_code_on_mutable_classes + - avoid_escaping_inner_quotes + - avoid_field_initializers_in_const_classes + - avoid_final_parameters - avoid_function_literals_in_foreach_calls - avoid_init_to_null + - avoid_js_rounded_ints + - avoid_multiple_declarations_per_line - avoid_null_checks_in_equality_operators + - avoid_positional_boolean_parameters + - avoid_print + - avoid_private_typedef_functions + - avoid_redundant_argument_values - avoid_relative_lib_imports - avoid_renaming_method_parameters - avoid_return_types_on_setters - - avoid_returning_null + - avoid_returning_null_for_void + - avoid_returning_this + - avoid_setters_without_getters + - avoid_shadowing_type_parameters + - avoid_single_cascade_in_expression_statements + - avoid_slow_async_io + - avoid_type_to_string - avoid_types_as_parameter_names + - avoid_unnecessary_containers - avoid_unused_constructor_parameters + - avoid_void_async + - avoid_web_libraries_in_flutter - await_only_futures + - camel_case_extensions - camel_case_types - cancel_subscriptions - cascade_invocations + - cast_nullable_to_non_nullable + - collection_methods_unrelated_type + - combinators_ordering - comment_references + - conditional_uri_does_not_exist - constant_identifier_names - control_flow_in_finally + - curly_braces_in_flow_control_structures + - dangling_library_doc_comments + - depend_on_referenced_packages + - deprecated_consistency - directives_ordering - empty_catches - empty_constructor_bodies - empty_statements + - eol_at_end_of_file + - exhaustive_cases + - file_names + - flutter_style_todos - hash_and_equals - implementation_imports - - invariant_booleans - - iterable_contains_unrelated_type + - implicit_call_tearoffs + - implicit_reopen + - invalid_case_patterns + - join_return_with_assignment + - leading_newlines_in_multiline_strings + - library_annotations - library_names - library_prefixes - - list_remove_unrelated_type + - library_private_types_in_public_api - lines_longer_than_80_chars + - literal_only_boolean_expressions + - missing_whitespace_between_adjacent_strings - no_adjacent_strings_in_list + - no_default_cases - no_duplicate_case_values + - no_leading_underscores_for_library_prefixes + - no_leading_underscores_for_local_identifiers + - no_logic_in_create_state + - no_runtimeType_toString - non_constant_identifier_names + - noop_primitive_operations + - null_check_on_nullable_type_parameter - null_closures - omit_local_variable_types + - one_member_abstracts - only_throw_errors - overridden_fields - package_api_docs - package_names - package_prefixed_library_names - prefer_adjacent_string_concatenation + - prefer_asserts_in_initializer_lists + - prefer_asserts_with_message - prefer_collection_literals - prefer_conditional_assignment - prefer_const_constructors + - prefer_const_constructors_in_immutables + - prefer_const_declarations + - prefer_const_literals_to_create_immutables + - prefer_constructors_over_static_methods - prefer_contains - - prefer_equal_for_default_values - prefer_final_fields + - prefer_final_in_for_each + - prefer_final_locals + - prefer_for_elements_to_map_fromIterable + - prefer_function_declarations_over_variables + - prefer_generic_function_type_aliases + - prefer_if_elements_to_conditional_expressions + - prefer_if_null_operators - prefer_initializing_formals + - prefer_inlined_adds + - prefer_int_literals - prefer_interpolation_to_compose_strings - prefer_is_empty - prefer_is_not_empty + - prefer_is_not_operator + - prefer_iterable_whereType + - prefer_null_aware_method_calls + - prefer_null_aware_operators - prefer_single_quotes + - prefer_spread_collections - prefer_typing_uninitialized_variables + - prefer_void_to_null + - provide_deprecation_message + - public_member_api_docs - recursive_getters + - require_trailing_commas + - secure_pubspec_urls + - sized_box_for_whitespace + - sized_box_shrink_expand - slash_for_doc_comments + - sort_child_properties_last - sort_constructors_first + - sort_pub_dependencies + - sort_unnamed_constructors_first - test_types_in_equals - throw_in_finally + - tighten_type_of_initializing_formals + - type_annotate_public_apis - type_init_formals - unawaited_futures + - unnecessary_await_in_return - unnecessary_brace_in_string_interps + - unnecessary_breaks - unnecessary_const + - unnecessary_constructor_name - unnecessary_getters_setters - unnecessary_lambdas + - unnecessary_late + - unnecessary_library_directive - unnecessary_new - unnecessary_null_aware_assignments + - unnecessary_null_checks + - unnecessary_null_in_if_null_operators + - unnecessary_nullable_for_final_variable_declarations + - unnecessary_overrides + - unnecessary_parenthesis + - unnecessary_raw_strings - unnecessary_statements + - unnecessary_string_escapes + - unnecessary_string_interpolations - unnecessary_this + - unnecessary_to_list_in_spreads - unrelated_type_equality_checks + - use_build_context_synchronously + - use_colored_box + - use_enums + - use_full_hex_values_for_flutter_colors + - use_function_type_syntax_for_parameters + - use_if_null_to_convert_nulls_to_bools + - use_is_even_rather_than_modulo + - use_key_in_widget_constructors + - use_late_for_private_fields_and_variables + - use_named_constants + - use_raw_strings - use_rethrow_when_possible + - use_setters_to_change_properties + - use_string_buffers + - use_string_in_part_of_directives + - use_super_parameters + - use_test_throws_matchers + - use_to_and_as_if_applicable - valid_regexps + - void_checks diff --git a/example/main.dart b/example/main.dart index c55197f7..9522de40 100644 --- a/example/main.dart +++ b/example/main.dart @@ -1,3 +1,5 @@ +// ignore_for_file: avoid_print + import 'package:equatable/equatable.dart'; class Credentials extends Equatable { @@ -45,7 +47,7 @@ void main() { print(credentialsC == credentialsC); // true print(credentialsA == credentialsB); // false print(credentialsB == credentialsC); // true - print(credentialsA.toString()); // Credentials + print(credentialsA); // Credentials // Equatable Mixin final dateTimeA = EquatableDateTime(2019); @@ -57,5 +59,5 @@ void main() { print(dateTimeC == dateTimeC); // true print(dateTimeA == dateTimeB); // false print(dateTimeB == dateTimeC); // true - print(dateTimeA.toString()); // EquatableDateTime(2019, 1, 1, 0, 0, 0, 0, 0) + print(dateTimeA); // EquatableDateTime(2019, 1, 1, 0, 0, 0, 0, 0) } diff --git a/example/pubspec.yaml b/example/pubspec.yaml index bcdd28fd..de237dd2 100644 --- a/example/pubspec.yaml +++ b/example/pubspec.yaml @@ -1,7 +1,7 @@ name: example environment: - sdk: ">=2.12.0-0 <3.0.0" + sdk: ">=2.12.0 <3.0.0" dependencies: equatable: diff --git a/lib/src/equatable.dart b/lib/src/equatable.dart index 3f2f4d07..9cd2fcbd 100644 --- a/lib/src/equatable.dart +++ b/lib/src/equatable.dart @@ -1,8 +1,7 @@ +import 'package:equatable/src/equatable_config.dart'; +import 'package:equatable/src/equatable_utils.dart'; import 'package:meta/meta.dart'; -import './equatable_config.dart'; -import './equatable_utils.dart'; - /// {@template equatable} /// A base class to facilitate [operator ==] and [hashCode] overrides. /// @@ -43,11 +42,12 @@ abstract class Equatable { bool? get stringify => null; @override - bool operator ==(Object other) => - identical(this, other) || - other is Equatable && - runtimeType == other.runtimeType && - equals(props, other.props); + bool operator ==(Object other) { + return identical(this, other) || + other is Equatable && + runtimeType == other.runtimeType && + equals(props, other.props); + } @override int get hashCode => runtimeType.hashCode ^ mapPropsToHashCode(props); diff --git a/lib/src/equatable_config.dart b/lib/src/equatable_config.dart index dc07587e..2fc9a400 100644 --- a/lib/src/equatable_config.dart +++ b/lib/src/equatable_config.dart @@ -1,5 +1,5 @@ // ignore_for_file: avoid_classes_with_only_static_members -import 'equatable.dart'; +import 'package:equatable/src/equatable.dart'; /// The default configurion for all [Equatable] instances. /// @@ -20,6 +20,7 @@ class EquatableConfig { /// {@endtemplate} static bool get stringify { if (_stringify == null) { + // ignore: prefer_asserts_with_message assert(() { _stringify = true; return true; diff --git a/lib/src/equatable_mixin.dart b/lib/src/equatable_mixin.dart index a7cd52dd..e79d65c9 100644 --- a/lib/src/equatable_mixin.dart +++ b/lib/src/equatable_mixin.dart @@ -1,9 +1,8 @@ +import 'package:equatable/src/equatable.dart'; +import 'package:equatable/src/equatable_config.dart'; +import 'package:equatable/src/equatable_utils.dart'; import 'package:meta/meta.dart'; -import 'equatable.dart'; -import 'equatable_config.dart'; -import 'equatable_utils.dart'; - /// A mixin that helps implement equality /// without needing to explicitly override [operator ==] and [hashCode]. /// diff --git a/lib/src/equatable_utils.dart b/lib/src/equatable_utils.dart index d1d8a678..301d81fb 100644 --- a/lib/src/equatable_utils.dart +++ b/lib/src/equatable_utils.dart @@ -2,21 +2,22 @@ import 'package:collection/collection.dart'; import 'package:equatable/equatable.dart'; /// Returns a `hashCode` for [props]. -int mapPropsToHashCode(Iterable? props) => - _finish(props == null ? 0 : props.fold(0, _combine)); +int mapPropsToHashCode(Iterable? props) { + return _finish(props == null ? 0 : props.fold(0, _combine)); +} const DeepCollectionEquality _equality = DeepCollectionEquality(); /// Determines whether [list1] and [list2] are equal. -bool equals(List? list1, List? list2) { +bool equals(List? list1, List? list2) { if (identical(list1, list2)) return true; if (list1 == null || list2 == null) return false; final length = list1.length; if (length != list2.length) return false; for (var i = 0; i < length; i++) { - final dynamic unit1 = list1[i]; - final dynamic unit2 = list2[i]; + final unit1 = list1[i]; + final unit2 = list2[i]; if (_isEquatable(unit1) && _isEquatable(unit2)) { if (unit1 != unit2) return false; @@ -31,23 +32,23 @@ bool equals(List? list1, List? list2) { return true; } -bool _isEquatable(dynamic object) { +bool _isEquatable(Object? object) { return object is Equatable || object is EquatableMixin; } /// Jenkins Hash Functions /// https://en.wikipedia.org/wiki/Jenkins_hash_function -int _combine(int hash, dynamic object) { +int _combine(int hash, Object? object) { if (object is Map) { object.keys - .sorted((dynamic a, dynamic b) => a.hashCode - b.hashCode) - .forEach((dynamic key) { - hash = hash ^ _combine(hash, [key, object[key]]); + .sorted((Object? a, Object? b) => a.hashCode - b.hashCode) + .forEach((Object? key) { + hash = hash ^ _combine(hash, [key, (object! as Map)[key]]); }); return hash; } if (object is Set) { - object = object.sorted(((dynamic a, dynamic b) => a.hashCode - b.hashCode)); + object = object.sorted((Object? a, Object? b) => a.hashCode - b.hashCode); } if (object is Iterable) { for (final value in object) { @@ -68,5 +69,6 @@ int _finish(int hash) { } /// Returns a string for [props]. -String mapPropsToString(Type runtimeType, List props) => - '$runtimeType(${props.map((prop) => prop.toString()).join(', ')})'; +String mapPropsToString(Type runtimeType, List props) { + return '$runtimeType(${props.map((prop) => prop.toString()).join(', ')})'; +} diff --git a/test/custom_list.dart b/test/custom_list.dart index 4b138347..d6764213 100644 --- a/test/custom_list.dart +++ b/test/custom_list.dart @@ -26,7 +26,7 @@ class CustomList implements List { List operator +(List other) => _list + other; @override - bool any(bool test(E element)) => _list.any(test); + bool any(bool Function(E element) test) => _list.any(test); @override Map asMap() => _list.asMap(); @@ -41,27 +41,27 @@ class CustomList implements List { E elementAt(int index) => _list.elementAt(index); @override - bool every(bool test(E element)) => _list.every(test); + bool every(bool Function(E element) test) => _list.every(test); @override - Iterable expand(Iterable f(E e)) => _list.expand(f); + Iterable expand(Iterable Function(E e) f) => _list.expand(f); @override E get first => _list.first; @override - E firstWhere(bool test(E element), {E orElse()?}) => + E firstWhere(bool Function(E element) test, {E Function()? orElse}) => _list.firstWhere(test, orElse: orElse); @override - T fold(T initialValue, T combine(T previousValue, E element)) => + T fold(T initialValue, T Function(T previousValue, E element) combine) => _list.fold(initialValue, combine); @override Iterable followedBy(Iterable other) => _list.followedBy(other); @override - void forEach(void f(E element)) => _list.forEach(f); + void forEach(void Function(E element) f) => _list.forEach(f); @override Iterable getRange(int start, int end) => _list.getRange(start, end); @@ -70,7 +70,7 @@ class CustomList implements List { int indexOf(E element, [int start = 0]) => _list.indexOf(element, start); @override - int indexWhere(bool test(E element), [int start = 0]) => + int indexWhere(bool Function(E element) test, [int start = 0]) => _list.indexWhere(test, start); @override @@ -92,18 +92,18 @@ class CustomList implements List { int lastIndexOf(E element, [int? start]) => _list.lastIndexOf(element, start); @override - int lastIndexWhere(bool test(E element), [int? start]) => + int lastIndexWhere(bool Function(E element) test, [int? start]) => _list.lastIndexWhere(test, start); @override - E lastWhere(bool test(E element), {E orElse()?}) => + E lastWhere(bool Function(E element) test, {E Function()? orElse}) => _list.lastWhere(test, orElse: orElse); @override - Iterable map(T f(E e)) => _list.map(f); + Iterable map(T Function(E e) f) => _list.map(f); @override - E reduce(E combine(E value, E element)) => _list.reduce(combine); + E reduce(E Function(E value, E element) combine) => _list.reduce(combine); @override Iterable get reversed => _list.reversed; @@ -112,14 +112,14 @@ class CustomList implements List { E get single => _list.single; @override - E singleWhere(bool test(E element), {E orElse()?}) => + E singleWhere(bool Function(E element) test, {E Function()? orElse}) => _list.singleWhere(test, orElse: orElse); @override Iterable skip(int count) => _list.skip(count); @override - Iterable skipWhile(bool test(E value)) => _list.skipWhile(test); + Iterable skipWhile(bool Function(E value) test) => _list.skipWhile(test); @override List sublist(int start, [int? end]) => _list.sublist(start, end); @@ -128,7 +128,7 @@ class CustomList implements List { Iterable take(int count) => _list.take(count); @override - Iterable takeWhile(bool test(E value)) => _list.takeWhile(test); + Iterable takeWhile(bool Function(E value) test) => _list.takeWhile(test); @override List toList({bool growable = true}) => _list.toList(growable: growable); @@ -137,7 +137,7 @@ class CustomList implements List { Set toSet() => _list.toSet(); @override - Iterable where(bool test(E element)) => _list.where(test); + Iterable where(bool Function(E element) test) => _list.where(test); @override Iterable whereType() => _list.whereType(); @@ -181,7 +181,7 @@ class CustomList implements List { } @override - void sort([int compare(E a, E b)?]) { + void sort([int Function(E a, E b)? compare]) { _maybeCopyBeforeWrite(); _list.sort(compare); } @@ -235,13 +235,13 @@ class CustomList implements List { } @override - void removeWhere(bool test(E element)) { + void removeWhere(bool Function(E element) test) { _maybeCopyBeforeWrite(); _list.removeWhere(test); } @override - void retainWhere(bool test(E element)) { + void retainWhere(bool Function(E element) test) { _maybeCopyBeforeWrite(); _list.retainWhere(test); } diff --git a/test/equatable_mixin_test.dart b/test/equatable_mixin_test.dart index b04e272f..41b5bad8 100644 --- a/test/equatable_mixin_test.dart +++ b/test/equatable_mixin_test.dart @@ -297,28 +297,34 @@ void main() { group('Simple Equatable (Equatable)', () { test('should correct toString', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect( instance.toString(), 'SimpleEquatable(EquatableData(foo, bar))', ); }); test('should return true when instance is the same', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect(instance == instance, true); }); test('should return correct hashCode', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect( instance.hashCode, instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props), @@ -326,36 +332,46 @@ void main() { }); test('should return true when instances are different', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); - final instanceB = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); + final instanceB = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return false when compared to non-equatable', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); final instanceB = NonEquatable(); expect(instanceA == instanceB, false); }); test('should return false when values are different', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); - final instanceB = SimpleEquatable(EquatableData( - key: 'foo', - value: 'barz', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); + final instanceB = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'barz', + ), + ); expect(instanceA == instanceB, false); }); }); @@ -509,38 +525,44 @@ void main() { group('Json Equatable', () { test('should correct toString', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instance.toString(), 'Credentials(Admin, admin)'); }); test('should return true when instance is the same', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instance == instance, true); }); test('should return correct hashCode', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect( instance.hashCode, instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props), @@ -548,56 +570,66 @@ void main() { }); test('should return true when instances are different', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); - final instanceB = Credentials.fromJson(json.decode( - ''' + ) as Map, + ); + final instanceB = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return false when compared to non-equatable', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); final instanceB = NonEquatable(); expect(instanceA == instanceB, false); }); test('should return false when values are different', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); - final instanceB = Credentials.fromJson(json.decode( - ''' + ) as Map, + ); + final instanceB = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"password" } ''', - ) as Map); + ) as Map, + ); expect(instanceA == instanceB, false); }); }); diff --git a/test/equatable_test.dart b/test/equatable_test.dart index f899ac57..9814049f 100644 --- a/test/equatable_test.dart +++ b/test/equatable_test.dart @@ -1,6 +1,6 @@ -// ignore_for_file: prefer_const_constructors -// ignore_for_file: unrelated_type_equality_checks -// ignore_for_file: prefer_collection_literals +// ignore: lines_longer_than_80_chars +// ignore_for_file: prefer_const_constructors_in_immutables, prefer_const_constructors, unrelated_type_equality_checks, prefer_const_literals_to_create_immutables + import 'dart:convert'; import 'package:equatable/equatable.dart'; @@ -377,7 +377,7 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); expect(instance == instance, true); @@ -388,7 +388,7 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); expect( @@ -402,14 +402,14 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); final instanceB = SimpleEquatable( { SimpleEquatable('b'): 2, SimpleEquatable('a'): 1, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); expect(instanceA == instanceB, true); @@ -421,14 +421,14 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); final instanceB = SimpleEquatable( { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); expect(instanceA == instanceB, true); @@ -440,7 +440,7 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); final instanceB = NonEquatable(); @@ -452,14 +452,14 @@ void main() { { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 3 + SimpleEquatable('c'): 3, }, ); final instanceB = SimpleEquatable( { SimpleEquatable('a'): 1, SimpleEquatable('b'): 2, - SimpleEquatable('c'): 2 + SimpleEquatable('c'): 2, }, ); expect(instanceA == instanceB, false); @@ -468,28 +468,34 @@ void main() { group('Simple Equatable (Equatable)', () { test('should correct toString', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect( instance.toString(), 'SimpleEquatable(EquatableData(foo, bar))', ); }); test('should return true when instance is the same', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect(instance == instance, true); }); test('should return correct hashCode', () { - final instance = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instance = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect( instance.hashCode, instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props), @@ -497,36 +503,46 @@ void main() { }); test('should return true when instances are different', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); - final instanceB = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); + final instanceB = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return false when compared to non-equatable', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); final instanceB = NonEquatable(); expect(instanceA == instanceB, false); }); test('should return false when values are different', () { - final instanceA = SimpleEquatable(EquatableData( - key: 'foo', - value: 'bar', - )); - final instanceB = SimpleEquatable(EquatableData( - key: 'foo', - value: 'barz', - )); + final instanceA = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'bar', + ), + ); + final instanceB = SimpleEquatable( + EquatableData( + key: 'foo', + value: 'barz', + ), + ); expect(instanceA == instanceB, false); }); }); @@ -696,38 +712,44 @@ void main() { group('Json Equatable', () { test('should correct toString', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instance.toString(), 'Credentials(Admin, admin)'); }); test('should return true when instance is the same', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instance == instance, true); }); test('should return correct hashCode', () { - final instance = Credentials.fromJson(json.decode( - ''' + final instance = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect( instance.hashCode, instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props), @@ -735,56 +757,66 @@ void main() { }); test('should return true when instances are different', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); - final instanceB = Credentials.fromJson(json.decode( - ''' + ) as Map, + ); + final instanceB = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return false when compared to non-equatable', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); + ) as Map, + ); final instanceB = NonEquatable(); expect(instanceA == instanceB, false); }); test('should return false when values are different', () { - final instanceA = Credentials.fromJson(json.decode( - ''' + final instanceA = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"admin" } ''', - ) as Map); - final instanceB = Credentials.fromJson(json.decode( - ''' + ) as Map, + ); + final instanceB = Credentials.fromJson( + json.decode( + ''' { "username":"Admin", "password":"password" } ''', - ) as Map); + ) as Map, + ); expect(instanceA == instanceB, false); }); }); @@ -798,22 +830,22 @@ void main() { }); test('should return when values are same', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['A', 'B']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['A', 'B']); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['a', 'b']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['a', 'b']); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['C', 'D']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['C', 'D']); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); @@ -821,26 +853,26 @@ void main() { group('Nested Iterable Equatable', () { test('should return when values are same', () { - final instanceA = SimpleEquatable>>([ + final instanceA = SimpleEquatable([ ['A', 'B', 'C'], - ['D', 'E', 'F'] + ['D', 'E', 'F'], ]); - final instanceB = SimpleEquatable>>([ + final instanceB = SimpleEquatable([ ['A', 'B', 'C'], - ['D', 'E', 'F'] + ['D', 'E', 'F'], ]); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable>>([ + final instanceA = SimpleEquatable([ ['A', 'B', 'C'], - ['D', 'E', 'F'] + ['D', 'E', 'F'], ]); - final instanceB = SimpleEquatable>>([ + final instanceB = SimpleEquatable([ ['a', 'b', 'c'], - ['d', 'e', 'f'] + ['d', 'e', 'f'], ]); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); @@ -849,32 +881,32 @@ void main() { group('List Equatable', () { test('should return when values are same', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['A', 'B']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['A', 'B']); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['a', 'b']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['a', 'b']); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['C', 'D']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['C', 'D']); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should return when contents are same but different kind of List', () { - final instanceA = SimpleEquatable( + final instanceA = SimpleEquatable>( CustomList(['A', 'B'], growable: true), ); - final instanceB = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable>(['A', 'B']); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); @@ -882,8 +914,8 @@ void main() { test( 'should return different hashCode ' 'when instance properties are different', () { - final instanceA = SimpleEquatable(['A', 'B']); - final instanceB = SimpleEquatable(['B']); + final instanceA = SimpleEquatable(['A', 'B']); + final instanceB = SimpleEquatable(['B']); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); @@ -893,7 +925,7 @@ void main() { 'should return different hashCode ' 'when instance properties are modified', () { final list = ['A', 'B']; - final instanceA = SimpleEquatable(list); + final instanceA = SimpleEquatable(list); final hashCodeA = instanceA.hashCode; list.removeLast(); final hashCodeB = instanceA.hashCode; @@ -903,22 +935,22 @@ void main() { group('Map Equatable', () { test('should return true when values are same', () { - final instanceA = SimpleEquatable>({1: 'A', 2: 'B'}); - final instanceB = SimpleEquatable>({1: 'A', 2: 'B'}); + final instanceA = SimpleEquatable({1: 'A', 2: 'B'}); + final instanceB = SimpleEquatable({1: 'A', 2: 'B'}); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return false when values are different', () { - final instanceA = SimpleEquatable>({1: 'A', 2: 'B'}); - final instanceB = SimpleEquatable>({1: 'a', 2: 'b'}); + final instanceA = SimpleEquatable({1: 'A', 2: 'B'}); + final instanceB = SimpleEquatable({1: 'a', 2: 'b'}); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should return false when values are different', () { - final instanceA = SimpleEquatable>({1: 'A', 2: 'B'}); - final instanceB = SimpleEquatable>({1: 'C', 2: 'D'}); + final instanceA = SimpleEquatable({1: 'A', 2: 'B'}); + final instanceB = SimpleEquatable({1: 'C', 2: 'D'}); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); @@ -926,8 +958,8 @@ void main() { test( 'should return different hashCode ' 'when instance properties are different', () { - final instanceA = SimpleEquatable>({1: 'A', 2: 'B'}); - final instanceB = SimpleEquatable>({2: 'B'}); + final instanceA = SimpleEquatable({1: 'A', 2: 'B'}); + final instanceB = SimpleEquatable({2: 'B'}); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); @@ -937,7 +969,7 @@ void main() { 'should return different hashCode ' 'when instance properties are modified', () { final map = {1: 'A', 2: 'B'}; - final instanceA = SimpleEquatable(map); + final instanceA = SimpleEquatable(map); final hashCodeA = instanceA.hashCode; map.remove(1); final hashCodeB = instanceA.hashCode; @@ -947,67 +979,36 @@ void main() { group('Set Equatable', () { test('should return when values are same', () { - final instanceA = SimpleEquatable>( - Set.from(['A', 'B']), - ); - final instanceB = SimpleEquatable>( - Set.from(['A', 'B']), - ); - expect(instanceA == instanceB, true); - expect(instanceA.hashCode == instanceB.hashCode, true); - }); - - test('should return when values are same', () { - final instanceA = SimpleEquatable>( - Set.from(['A', 'B', 'A']), - ); - final instanceB = SimpleEquatable>( - Set.from(['A', 'B']), - ); + final instanceA = SimpleEquatable({'A', 'B'}); + final instanceB = SimpleEquatable({'A', 'B'}); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return when Set values are same but in different order', () { - final instanceA = SimpleEquatable>( - Set.from(['A', 'B']), - ); - final instanceB = SimpleEquatable>( - Set.from(['B', 'A']), - ); + final instanceA = SimpleEquatable({'A', 'B'}); + final instanceB = SimpleEquatable({'B', 'A'}); expect(instanceA == instanceB, true); expect(instanceA.hashCode == instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable>( - Set.from(['A', 'B']), - ); - final instanceB = SimpleEquatable>( - Set.from(['a', 'b']), - ); + final instanceA = SimpleEquatable({'A', 'B'}); + final instanceB = SimpleEquatable({'a', 'b'}); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should return when values are different', () { - final instanceA = SimpleEquatable>( - Set.from(['A', 'B']), - ); - final instanceB = SimpleEquatable>( - Set.from(['C', 'D']), - ); + final instanceA = SimpleEquatable({'A', 'B'}); + final instanceB = SimpleEquatable({'C', 'D'}); expect(instanceA != instanceB, true); expect(instanceA.hashCode != instanceB.hashCode, true); }); test('should support non-comparable types', () { - final instanceA = SimpleEquatable>( - Set.from([Object()]), - ); - final instanceB = SimpleEquatable>( - Set.from([Object()]), - ); + final instanceA = SimpleEquatable({Object()}); + final instanceB = SimpleEquatable({Object()}); expect(instanceA == instanceB, false); expect(instanceA.hashCode == instanceB.hashCode, false); }); @@ -1018,8 +1019,11 @@ void main() { test('with Complex stringify', () { final instanceA = ComplexStringify(); final instanceB = ComplexStringify(name: 'Bob', hairColor: Color.black); - final instanceC = - ComplexStringify(name: 'Joe', age: 50, hairColor: Color.blonde); + final instanceC = ComplexStringify( + name: 'Joe', + age: 50, + hairColor: Color.blonde, + ); expect(instanceA.toString(), 'ComplexStringify(null, null, null)'); expect(instanceB.toString(), 'ComplexStringify(Bob, null, Color.black)'); expect(instanceC.toString(), 'ComplexStringify(Joe, 50, Color.blonde)'); @@ -1044,10 +1048,15 @@ void main() { test('with ExplicitStringifyFalse stringify', () { final instanceA = ExplicitStringifyFalse(); - final instanceB = - ExplicitStringifyFalse(name: 'Bob', hairColor: Color.black); - final instanceC = - ExplicitStringifyFalse(name: 'Joe', age: 50, hairColor: Color.blonde); + final instanceB = ExplicitStringifyFalse( + name: 'Bob', + hairColor: Color.black, + ); + final instanceC = ExplicitStringifyFalse( + name: 'Joe', + age: 50, + hairColor: Color.blonde, + ); expect(instanceA.toString(), 'ExplicitStringifyFalse'); expect(instanceB.toString(), 'ExplicitStringifyFalse'); expect(instanceC.toString(), 'ExplicitStringifyFalse');