blob: 2eeac9776844cd5b9ec98fcd247e85bb9203f6ca [file] [log] [blame]
import 'dart:convert';
import 'package:equatable/src/equatable_utils.dart';
import 'package:test/test.dart';
import 'package:equatable/equatable.dart';
import 'custom_list.dart';
class NonEquatable {}
class EmptyEquatable extends Equatable {
@override
List<Object> get props => [];
const EmptyEquatable();
}
class SimpleEquatable<T> extends Equatable {
final T data;
const SimpleEquatable(this.data);
@override
List<Object> get props => [data];
}
class MultipartEquatable<T> extends Equatable {
final T d1;
final T d2;
MultipartEquatable(this.d1, this.d2);
@override
List<Object> get props => [d1, d2];
}
class OtherEquatable extends Equatable {
final String data;
const OtherEquatable(this.data);
@override
List<Object> get props => [data];
}
enum Color { blonde, black, brown }
class ComplexEquatable extends Equatable {
final String name;
final int age;
final Color hairColor;
final List<String> children;
const ComplexEquatable({this.name, this.age, this.hairColor, this.children});
@override
List<Object> get props => [name, age, hairColor, children];
}
class EquatableData extends Equatable {
final String key;
final dynamic value;
const EquatableData({this.key, this.value});
@override
List<Object> get props => [key, value];
}
class Credentials extends Equatable {
final String username;
final String password;
const Credentials({this.username, this.password});
factory Credentials.fromJson(Map<String, dynamic> json) {
return Credentials(
username: json['username'] as String,
password: json['password'] as String,
);
}
Map<String, dynamic> toJson() {
final Map<String, dynamic> data = new Map<String, dynamic>();
data['username'] = this.username;
data['password'] = this.password;
return data;
}
@override
List<Object> get props => [username, password];
}
void main() {
group('Empty Equatable', () {
test('should correct toString', () {
final instance = EmptyEquatable();
expect(instance.toString(), 'EmptyEquatable');
});
test('should return true when instance is the same', () {
final instance = EmptyEquatable();
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = EmptyEquatable();
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
final instanceA = EmptyEquatable();
final instanceB = EmptyEquatable();
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = EmptyEquatable();
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
});
group('Simple Equatable (string)', () {
test('should correct toString', () {
final instance = SimpleEquatable('simple');
expect(instance.toString(), 'SimpleEquatable<String>');
});
test('should return true when instance is the same', () {
final instance = SimpleEquatable('simple');
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = SimpleEquatable('simple');
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return correct toString', () {
final instance = SimpleEquatable('simple');
expect(instance.toString(), 'SimpleEquatable<String>');
});
test('should return true when instances are different', () {
final instanceA = SimpleEquatable('simple');
final instanceB = SimpleEquatable('simple');
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = SimpleEquatable('simple');
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when compared to different equatable', () {
final instanceA = SimpleEquatable('simple');
final instanceB = OtherEquatable('simple');
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = SimpleEquatable('simple');
final instanceB = SimpleEquatable('Simple');
expect(instanceA == instanceB, false);
});
});
group('Simple Equatable (number)', () {
test('should correct toString', () {
final instance = SimpleEquatable(0);
expect(instance.toString(), 'SimpleEquatable<int>');
});
test('should return true when instance is the same', () {
final instance = SimpleEquatable(0);
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = SimpleEquatable(0);
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
final instanceA = SimpleEquatable(0);
final instanceB = SimpleEquatable(0);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = SimpleEquatable(0);
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = SimpleEquatable(0);
final instanceB = SimpleEquatable(1);
expect(instanceA == instanceB, false);
});
});
group('Simple Equatable (bool)', () {
test('should correct toString', () {
final instance = SimpleEquatable(true);
expect(instance.toString(), 'SimpleEquatable<bool>');
});
test('should return true when instance is the same', () {
final instance = SimpleEquatable(true);
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = SimpleEquatable(true);
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
final instanceA = SimpleEquatable(true);
final instanceB = SimpleEquatable(true);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = SimpleEquatable(true);
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = SimpleEquatable(true);
final instanceB = SimpleEquatable(false);
expect(instanceA == instanceB, false);
});
});
group('Simple Equatable (Equatable)', () {
test('should correct toString', () {
final instance = SimpleEquatable(EquatableData(
key: 'foo',
value: 'bar',
));
expect(instance.toString(), 'SimpleEquatable<EquatableData>');
});
test('should return true when instance is the same', () {
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',
));
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
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 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',
));
expect(instanceA == instanceB, false);
});
});
group('Multipart Equatable', () {
test('should correct toString', () {
final instance = MultipartEquatable("s1", "s2");
expect(instance.toString(), 'MultipartEquatable<String>');
});
test('should return true when instance is the same', () {
final instance = MultipartEquatable("s1", "s2");
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = MultipartEquatable("s1", "s2");
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return different hashCodes when property order has changed',
() {
final instance1 = MultipartEquatable("s1", "s2");
final instance2 = MultipartEquatable("s2", "s1");
expect(instance1.hashCode == instance2.hashCode, isFalse);
});
test('should return true when instances are different', () {
final instanceA = MultipartEquatable("s1", "s2");
final instanceB = MultipartEquatable("s1", "s2");
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = MultipartEquatable("s1", "s2");
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = MultipartEquatable("s1", "s2");
final instanceB = MultipartEquatable("s2", "s1");
expect(instanceA == instanceB, false);
final instanceC = MultipartEquatable("s1", "s1");
final instanceD = MultipartEquatable("s2", "s1");
expect(instanceC == instanceD, false);
});
});
group('Complex Equatable', () {
test('should correct toString', () {
final instance = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
expect(instance.toString(), 'ComplexEquatable');
});
test('should return true when instance is the same', () {
final instance = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
final instanceA = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
final instanceB = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return false when compared to non-equatable', () {
final instanceA = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
final instanceB = ComplexEquatable(
name: 'John',
age: 40,
hairColor: Color.brown,
children: ['Bobby'],
);
expect(instanceA == instanceB, false);
});
test('should return false when values only differ in list', () {
final instanceA = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
final instanceB = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bobby'],
);
expect(instanceA == instanceB, false);
});
test('should return false when values only differ in single property', () {
final instanceA = ComplexEquatable(
name: 'Joe',
age: 40,
hairColor: Color.black,
children: ['Bob'],
);
final instanceB = ComplexEquatable(
name: 'Joe',
age: 41,
hairColor: Color.black,
children: ['Bob'],
);
expect(instanceA == instanceB, false);
});
});
group('Json Equatable', () {
test('should correct toString', () {
final instance = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
expect(instance.toString(), 'Credentials');
});
test('should return true when instance is the same', () {
final instance = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
expect(instance == instance, true);
});
test('should return correct hashCode', () {
final instance = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
expect(
instance.hashCode,
instance.runtimeType.hashCode ^ mapPropsToHashCode(instance.props),
);
});
test('should return true when instances are different', () {
final instanceA = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
final instanceB = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
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(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
final instanceB = NonEquatable();
expect(instanceA == instanceB, false);
});
test('should return false when values are different', () {
final instanceA = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"admin"
}
""",
) as Map<String, dynamic>);
final instanceB = Credentials.fromJson(json.decode(
"""
{
"username":"Admin",
"password":"password"
}
""",
) as Map<String, dynamic>);
expect(instanceA == instanceB, false);
});
});
group('Collection Equatable', () {
group('Iterable Equatable', () {
test('should return when values are same', () {
final instanceA = SimpleEquatable<Iterable>(["A", "B"]);
final instanceB = SimpleEquatable<Iterable>(["A", "B"]);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<Iterable>(["A", "B"]);
final instanceB = SimpleEquatable<Iterable>(["a", "b"]);
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<Iterable>(["A", "B"]);
final instanceB = SimpleEquatable<Iterable>(["C", "D"]);
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
});
group('List Equatable', () {
test('should return when values are same', () {
final instanceA = SimpleEquatable<List>(["A", "B"]);
final instanceB = SimpleEquatable<List>(["A", "B"]);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<List>(["A", "B"]);
final instanceB = SimpleEquatable<List>(["a", "b"]);
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<List>(["A", "B"]);
final instanceB = SimpleEquatable<List>(["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<List>(CustomList(["A", "B"], true));
final instanceB = SimpleEquatable<List>(["A", "B"]);
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test(
'should return different hashCode when instance properties are different',
() {
final instanceA = SimpleEquatable<List>(["A", "B"]);
final instanceB = SimpleEquatable<List>(["B"]);
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test(
'should return different hashCode when instance properties are modified',
() {
final list = ["A", "B"];
final instanceA = SimpleEquatable<List>(list);
final hashCodeA = instanceA.hashCode;
list.removeLast();
final hashCodeB = instanceA.hashCode;
expect(hashCodeA != hashCodeB, true);
});
});
group('Map Equatable', () {
test('should return true when values are same', () {
final instanceA = SimpleEquatable<Map>({1: "A", 2: "B"});
final instanceB = SimpleEquatable<Map>({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<Map>({1: "A", 2: "B"});
final instanceB = SimpleEquatable<Map>({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<Map>({1: "A", 2: "B"});
final instanceB = SimpleEquatable<Map>({1: "C", 2: "D"});
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test(
'should return different hashCode when instance properties are different',
() {
final instanceA = SimpleEquatable<Map>({1: "A", 2: "B"});
final instanceB = SimpleEquatable<Map>({2: "B"});
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test(
'should return different hashCode when instance properties are modified',
() {
final map = {1: "A", 2: "B"};
final instanceA = SimpleEquatable<Map>(map);
final hashCodeA = instanceA.hashCode;
map.remove(1);
final hashCodeB = instanceA.hashCode;
expect(hashCodeA != hashCodeB, true);
});
});
group('Set Equatable', () {
test('should return when values are same', () {
final instanceA = SimpleEquatable<Set>(Set.from(["A", "B"]));
final instanceB = SimpleEquatable<Set>(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>(Set.from(["A", "B", "A"]));
final instanceB = SimpleEquatable<Set>(Set.from(["A", "B"]));
expect(instanceA == instanceB, true);
expect(instanceA.hashCode == instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<Set>(Set.from(["A", "B"]));
final instanceB = SimpleEquatable<Set>(Set.from(["a", "b"]));
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
test('should return when values are different', () {
final instanceA = SimpleEquatable<Set>(Set.from(["A", "B"]));
final instanceB = SimpleEquatable<Set>(Set.from(["C", "D"]));
expect(instanceA != instanceB, true);
expect(instanceA.hashCode != instanceB.hashCode, true);
});
});
});
}
// test that subclasses of `Equatable` can have const constructors
class ConstTest extends Equatable {
const ConstTest(this.a);
final int a;
@override
List<Object> get props => [a];
}