599 lines
16 KiB
Dart
599 lines
16 KiB
Dart
import 'dart:ui';
|
|
|
|
import 'package:fl_chart/fl_chart.dart';
|
|
import 'package:fl_chart/src/utils/lerp.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
|
|
import '../chart/data_pool.dart';
|
|
import '../matchers.dart';
|
|
|
|
void main() {
|
|
const tolerance = 0.001;
|
|
|
|
test('test lerpList', () {
|
|
final list1 = <double>[1, 1, 2];
|
|
final list2 = <double>[1, 2, 3, 5];
|
|
expect(lerpList(list1, list2, 0, lerp: lerpDouble), [1.0, 1.0, 2.0, 5.0]);
|
|
expect(lerpList(list1, list2, 0.5, lerp: lerpDouble), [1.0, 1.5, 2.5, 5.0]);
|
|
expect(lerpList(list1, list1, 0.5, lerp: lerpDouble), list1);
|
|
});
|
|
|
|
test('test lerpColorList', () {
|
|
const list1 = <Color>[
|
|
MockData.color1,
|
|
MockData.color1,
|
|
MockData.color2,
|
|
];
|
|
const list2 = <Color>[
|
|
MockData.color1,
|
|
MockData.color2,
|
|
MockData.color3,
|
|
MockData.color5,
|
|
];
|
|
expect(lerpColorList(list1, list2, 0), [
|
|
isSameColorAs(MockData.color1),
|
|
isSameColorAs(MockData.color1),
|
|
isSameColorAs(MockData.color2),
|
|
isSameColorAs(MockData.color5),
|
|
]);
|
|
expect(lerpColorList(list1, list2, 1), list2);
|
|
expect(lerpColorList(list1, list2, 0.5), [
|
|
isSameColorAs(MockData.color1),
|
|
isSameColorAs(const Color(0x19191919)),
|
|
isSameColorAs(const Color(0x2a2a2a2a)),
|
|
isSameColorAs(MockData.color5),
|
|
]);
|
|
});
|
|
|
|
test('test lerpColor', () {
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color1, 0.5),
|
|
isSameColorAs(MockData.color1),
|
|
);
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color1, 0),
|
|
isSameColorAs(MockData.color1),
|
|
);
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color1, 1),
|
|
isSameColorAs(MockData.color1),
|
|
);
|
|
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color2, 0),
|
|
isSameColorAs(MockData.color1),
|
|
);
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color2, 0.3),
|
|
isSameColorAs(const Color(0x16161616)),
|
|
);
|
|
expect(
|
|
lerpColor(MockData.color1, MockData.color2, 1),
|
|
isSameColorAs(MockData.color2),
|
|
);
|
|
});
|
|
|
|
test('test lerpDoubleAllowInfinity', () {
|
|
expect(lerpDoubleAllowInfinity(12, 12, 0), 12);
|
|
expect(lerpDoubleAllowInfinity(12, 12, 0.2), 12);
|
|
expect(lerpDoubleAllowInfinity(12, 12, 0.5), 12);
|
|
expect(lerpDoubleAllowInfinity(12, 12, 1), 12);
|
|
|
|
expect(lerpDoubleAllowInfinity(12, double.infinity, 1), double.infinity);
|
|
expect(lerpDoubleAllowInfinity(12, double.infinity, 0), double.infinity);
|
|
expect(lerpDoubleAllowInfinity(12, double.infinity, 0.4), double.infinity);
|
|
|
|
expect(lerpDoubleAllowInfinity(double.infinity, 12, 1), 12);
|
|
expect(lerpDoubleAllowInfinity(double.infinity, 12, 0), 12);
|
|
expect(lerpDoubleAllowInfinity(double.infinity, 12, 0.4), 12);
|
|
|
|
expect(lerpDoubleAllowInfinity(0, 10, 0.4), 4);
|
|
expect(lerpDoubleAllowInfinity(0, 10, 0.2), 2);
|
|
expect(lerpDoubleAllowInfinity(0, 10, 0.8), 8);
|
|
});
|
|
|
|
test('test lerpDoubleList', () {
|
|
const list1 = <double>[
|
|
0,
|
|
0,
|
|
0,
|
|
];
|
|
const list2 = <double>[
|
|
10,
|
|
100,
|
|
1000,
|
|
10000,
|
|
];
|
|
expect(lerpDoubleList(list1, list2, 0), const [
|
|
0,
|
|
0,
|
|
0,
|
|
10000,
|
|
]);
|
|
expect(lerpDoubleList(list1, list2, 0.5), [
|
|
5,
|
|
50,
|
|
500,
|
|
10000,
|
|
]);
|
|
expect(lerpDoubleList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpIntList', () {
|
|
const list1 = <int>[
|
|
0,
|
|
0,
|
|
0,
|
|
];
|
|
const list2 = <int>[
|
|
10,
|
|
100,
|
|
1000,
|
|
10000,
|
|
];
|
|
expect(lerpIntList(list1, list2, 0), const [
|
|
0,
|
|
0,
|
|
0,
|
|
10000,
|
|
]);
|
|
expect(lerpIntList(list1, list2, 0.5), [
|
|
5,
|
|
50,
|
|
500,
|
|
10000,
|
|
]);
|
|
expect(lerpIntList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpInt', () {
|
|
expect(lerpInt(0, 10, 1), 10);
|
|
expect(lerpInt(0, 10, 0.34), 3);
|
|
expect(lerpInt(0, 10, 0.38), 4);
|
|
});
|
|
|
|
test('test lerpNonNullDouble', () {
|
|
expect(lerpNonNullDouble(0, 10, 1), 10);
|
|
expect(lerpNonNullDouble(0, 10, 0.34), closeTo(3.4, tolerance));
|
|
expect(lerpNonNullDouble(0, 10, 0.38), closeTo(3.8, tolerance));
|
|
});
|
|
|
|
test('test lerpFlSpotList', () {
|
|
final list1 = [
|
|
MockData.flSpot0,
|
|
MockData.flSpot0,
|
|
MockData.flSpot0,
|
|
];
|
|
final list2 = [
|
|
MockData.flSpot1,
|
|
MockData.flSpot2,
|
|
MockData.flSpot3,
|
|
MockData.flSpot4,
|
|
];
|
|
expect(lerpFlSpotList(list1, list2, 0), [
|
|
MockData.flSpot0,
|
|
MockData.flSpot0,
|
|
MockData.flSpot0,
|
|
MockData.flSpot4,
|
|
]);
|
|
expect(lerpFlSpotList(list1, list2, 0.5), [
|
|
const FlSpot(0.5, 0.5),
|
|
MockData.flSpot1,
|
|
const FlSpot(1.5, 1.5),
|
|
MockData.flSpot4,
|
|
]);
|
|
expect(lerpFlSpotList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpHorizontalLineList', () {
|
|
final list1 = [
|
|
MockData.horizontalLine0,
|
|
MockData.horizontalLine0,
|
|
MockData.horizontalLine0,
|
|
];
|
|
final list2 = [
|
|
MockData.horizontalLine1,
|
|
MockData.horizontalLine2,
|
|
MockData.horizontalLine3,
|
|
MockData.horizontalLine4,
|
|
];
|
|
expect(lerpHorizontalLineList(list1, list2, 0), [
|
|
MockData.horizontalLine0,
|
|
MockData.horizontalLine0,
|
|
MockData.horizontalLine0,
|
|
MockData.horizontalLine4,
|
|
]);
|
|
expect(lerpHorizontalLineList(list1, list2, 0.5), [
|
|
matchesHorizontalLine(
|
|
HorizontalLine(y: 0.5, color: const Color(0x08080808)),
|
|
),
|
|
matchesHorizontalLine(MockData.horizontalLine1),
|
|
matchesHorizontalLine(
|
|
HorizontalLine(y: 1.5, color: const Color(0x19191919)),
|
|
),
|
|
matchesHorizontalLine(MockData.horizontalLine4),
|
|
]);
|
|
expect(lerpHorizontalLineList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpVerticalLineList', () {
|
|
final list1 = [
|
|
MockData.verticalLine0,
|
|
MockData.verticalLine0,
|
|
MockData.verticalLine0,
|
|
];
|
|
final list2 = [
|
|
MockData.verticalLine1,
|
|
MockData.verticalLine2,
|
|
MockData.verticalLine3,
|
|
MockData.verticalLine4,
|
|
];
|
|
expect(lerpVerticalLineList(list1, list2, 0), [
|
|
MockData.verticalLine0,
|
|
MockData.verticalLine0,
|
|
MockData.verticalLine0,
|
|
MockData.verticalLine4,
|
|
]);
|
|
expect(lerpVerticalLineList(list1, list2, 0.5), [
|
|
matchesVerticalLine(
|
|
VerticalLine(x: 0.5, color: const Color(0x08080808)),
|
|
),
|
|
matchesVerticalLine(MockData.verticalLine1),
|
|
matchesVerticalLine(
|
|
VerticalLine(x: 1.5, color: const Color(0x19191919)),
|
|
),
|
|
matchesVerticalLine(MockData.verticalLine4),
|
|
]);
|
|
expect(lerpVerticalLineList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpHorizontalRangeAnnotationList', () {
|
|
final list1 = [
|
|
MockData.horizontalRangeAnnotation0,
|
|
MockData.horizontalRangeAnnotation0,
|
|
MockData.horizontalRangeAnnotation0,
|
|
];
|
|
final list2 = [
|
|
MockData.horizontalRangeAnnotation1,
|
|
MockData.horizontalRangeAnnotation2,
|
|
MockData.horizontalRangeAnnotation3,
|
|
MockData.horizontalRangeAnnotation4,
|
|
];
|
|
expect(lerpHorizontalRangeAnnotationList(list1, list2, 0), [
|
|
MockData.horizontalRangeAnnotation0,
|
|
MockData.horizontalRangeAnnotation0,
|
|
MockData.horizontalRangeAnnotation0,
|
|
MockData.horizontalRangeAnnotation4,
|
|
]);
|
|
expect(lerpHorizontalRangeAnnotationList(list1, list2, 0.5), [
|
|
matchesHorizontalRangeAnnotation(
|
|
HorizontalRangeAnnotation(
|
|
y1: 0.5,
|
|
y2: 1.5,
|
|
color: const Color(0x08080808),
|
|
),
|
|
),
|
|
matchesHorizontalRangeAnnotation(MockData.horizontalRangeAnnotation1),
|
|
matchesHorizontalRangeAnnotation(
|
|
HorizontalRangeAnnotation(
|
|
y1: 1.5,
|
|
y2: 2.5,
|
|
color: const Color(0x19191919),
|
|
),
|
|
),
|
|
matchesHorizontalRangeAnnotation(MockData.horizontalRangeAnnotation4),
|
|
]);
|
|
expect(lerpHorizontalRangeAnnotationList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpVerticalRangeAnnotationList', () {
|
|
final list1 = [
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
];
|
|
final list2 = [
|
|
MockData.verticalRangeAnnotation1,
|
|
MockData.verticalRangeAnnotation2,
|
|
MockData.verticalRangeAnnotation3,
|
|
MockData.verticalRangeAnnotation4,
|
|
];
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 0), [
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation4,
|
|
]);
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 0.5), [
|
|
matchesVerticalRangeAnnotation(
|
|
VerticalRangeAnnotation(
|
|
x1: 0.5,
|
|
x2: 1.5,
|
|
color: const Color(0x08080808),
|
|
),
|
|
),
|
|
matchesVerticalRangeAnnotation(MockData.verticalRangeAnnotation1),
|
|
matchesVerticalRangeAnnotation(
|
|
VerticalRangeAnnotation(
|
|
x1: 1.5,
|
|
x2: 2.5,
|
|
color: const Color(0x19191919),
|
|
),
|
|
),
|
|
matchesVerticalRangeAnnotation(MockData.verticalRangeAnnotation4),
|
|
]);
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpBetweenBarsDataList', () {
|
|
final list1 = [
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
];
|
|
final list2 = [
|
|
MockData.verticalRangeAnnotation1,
|
|
MockData.verticalRangeAnnotation2,
|
|
MockData.verticalRangeAnnotation3,
|
|
MockData.verticalRangeAnnotation4,
|
|
];
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 0), [
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation0,
|
|
MockData.verticalRangeAnnotation4,
|
|
]);
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 0.5), [
|
|
matchesVerticalRangeAnnotation(
|
|
VerticalRangeAnnotation(
|
|
x1: 0.5,
|
|
x2: 1.5,
|
|
color: const Color(0x08080808),
|
|
),
|
|
),
|
|
matchesVerticalRangeAnnotation(MockData.verticalRangeAnnotation1),
|
|
matchesVerticalRangeAnnotation(
|
|
VerticalRangeAnnotation(
|
|
x1: 1.5,
|
|
x2: 2.5,
|
|
color: const Color(0x19191919),
|
|
),
|
|
),
|
|
matchesVerticalRangeAnnotation(MockData.verticalRangeAnnotation4),
|
|
]);
|
|
expect(lerpVerticalRangeAnnotationList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpRadarEntryList', () {
|
|
final list1 = [
|
|
MockData.radarEntry0,
|
|
MockData.radarEntry0,
|
|
MockData.radarEntry0,
|
|
];
|
|
final list2 = [
|
|
MockData.radarEntry1,
|
|
MockData.radarEntry2,
|
|
MockData.radarEntry3,
|
|
MockData.radarEntry4,
|
|
];
|
|
expect(lerpRadarEntryList(list1, list2, 0), [
|
|
MockData.radarEntry0,
|
|
MockData.radarEntry0,
|
|
MockData.radarEntry0,
|
|
MockData.radarEntry4,
|
|
]);
|
|
expect(lerpRadarEntryList(list1, list2, 0.5), [
|
|
const RadarEntry(value: 0.5),
|
|
MockData.radarEntry1,
|
|
const RadarEntry(value: 1.5),
|
|
MockData.radarEntry4,
|
|
]);
|
|
expect(lerpRadarEntryList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpScatterSpotList', () {
|
|
final list1 = [
|
|
MockData.scatterSpot0,
|
|
MockData.scatterSpot0,
|
|
MockData.scatterSpot0,
|
|
];
|
|
final list2 = [
|
|
MockData.scatterSpot1,
|
|
MockData.scatterSpot2,
|
|
MockData.scatterSpot3,
|
|
MockData.scatterSpot4,
|
|
];
|
|
expect(lerpScatterSpotList(list1, list2, 0), [
|
|
MockData.scatterSpot0,
|
|
MockData.scatterSpot0,
|
|
MockData.scatterSpot0,
|
|
MockData.scatterSpot4,
|
|
]);
|
|
expect(lerpScatterSpotList(list1, list2, 0.5), [
|
|
matchesScatterSpotWithCirclePainter(
|
|
ScatterSpot(
|
|
0.5,
|
|
0.5,
|
|
dotPainter: FlDotCirclePainter(color: const Color(0x08080808)),
|
|
),
|
|
),
|
|
matchesScatterSpotWithCirclePainter(MockData.scatterSpot1),
|
|
matchesScatterSpotWithCirclePainter(
|
|
ScatterSpot(
|
|
1.5,
|
|
1.5,
|
|
dotPainter: FlDotCirclePainter(color: const Color(0x19191919)),
|
|
),
|
|
),
|
|
matchesScatterSpotWithCirclePainter(MockData.scatterSpot4),
|
|
]);
|
|
expect(lerpScatterSpotList(list1, list2, 1), list2);
|
|
});
|
|
|
|
test('test lerpGradient', () {
|
|
final colors = [
|
|
MockData.color0,
|
|
MockData.color1,
|
|
MockData.color2,
|
|
MockData.color3,
|
|
];
|
|
expect(
|
|
lerpGradient(colors, [], 0),
|
|
isSameColorAs(const Color(0x00000000)),
|
|
);
|
|
expect(
|
|
lerpGradient(colors, [], 0.2),
|
|
isSameColorAs(const Color(0x00000000)),
|
|
);
|
|
expect(
|
|
lerpGradient(colors, [], 0.4),
|
|
isSameColorAs(const Color(0x0a0a0a0a)),
|
|
);
|
|
expect(
|
|
lerpGradient(colors, [], 0.6),
|
|
isSameColorAs(const Color(0x17171717)),
|
|
);
|
|
expect(
|
|
lerpGradient(colors, [], 0.8),
|
|
isSameColorAs(const Color(0x25252525)),
|
|
);
|
|
expect(
|
|
lerpGradient(colors, [], 1),
|
|
isSameColorAs(const Color(0x33333333)),
|
|
);
|
|
});
|
|
|
|
test('lerpLineChartBarDataList uses `LineChartBarData.lerp`', () {
|
|
final list1 = [
|
|
MockData.lineChartBarData1,
|
|
MockData.lineChartBarData1,
|
|
MockData.lineChartBarData1,
|
|
];
|
|
final list2 = [
|
|
MockData.lineChartBarData2,
|
|
MockData.lineChartBarData2,
|
|
MockData.lineChartBarData2,
|
|
MockData.lineChartBarData2,
|
|
];
|
|
|
|
expect(
|
|
lerpLineChartBarDataList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: LineChartBarData.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpBetweenBarsDataList uses `BetweenBarsData.lerp`', () {
|
|
final list1 = [
|
|
betweenBarsData1,
|
|
betweenBarsData1,
|
|
betweenBarsData1,
|
|
];
|
|
final list2 = [
|
|
betweenBarsData2,
|
|
betweenBarsData2,
|
|
betweenBarsData2,
|
|
betweenBarsData2,
|
|
];
|
|
|
|
expect(
|
|
lerpBetweenBarsDataList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: BetweenBarsData.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpBarChartGroupDataList uses `BarChartGroupData.lerp`', () {
|
|
final list1 = [
|
|
barChartGroupData1,
|
|
barChartGroupData1,
|
|
barChartGroupData1,
|
|
];
|
|
final list2 = [
|
|
barChartGroupData2,
|
|
barChartGroupData2,
|
|
barChartGroupData2,
|
|
barChartGroupData2,
|
|
];
|
|
|
|
expect(
|
|
lerpBarChartGroupDataList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: BarChartGroupData.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpBarChartRodDataList uses `BarChartRodData.lerp`', () {
|
|
final list1 = [
|
|
barChartRodData1,
|
|
barChartRodData1,
|
|
barChartRodData1,
|
|
];
|
|
final list2 = [
|
|
barChartRodData2,
|
|
barChartRodData2,
|
|
barChartRodData2,
|
|
barChartRodData2,
|
|
];
|
|
|
|
expect(
|
|
lerpBarChartRodDataList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: BarChartRodData.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpPieChartSectionDataList uses `PieChartSectionData.lerp`', () {
|
|
final list1 = [
|
|
MockData.pieChartSectionData1,
|
|
MockData.pieChartSectionData1,
|
|
MockData.pieChartSectionData1,
|
|
];
|
|
final list2 = [
|
|
MockData.pieChartSectionData2,
|
|
MockData.pieChartSectionData2,
|
|
MockData.pieChartSectionData2,
|
|
MockData.pieChartSectionData2,
|
|
];
|
|
|
|
expect(
|
|
lerpPieChartSectionDataList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: PieChartSectionData.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpBarChartRodStackList uses `BarChartRodStackItem.lerp`', () {
|
|
final list1 = [
|
|
barChartRodStackItem1,
|
|
barChartRodStackItem1,
|
|
barChartRodStackItem1,
|
|
];
|
|
final list2 = [
|
|
barChartRodStackItem2,
|
|
barChartRodStackItem2,
|
|
barChartRodStackItem2,
|
|
barChartRodStackItem2,
|
|
];
|
|
|
|
expect(
|
|
lerpBarChartRodStackList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: BarChartRodStackItem.lerp),
|
|
);
|
|
});
|
|
|
|
test('lerpRadarDataSetList uses `RadarDataSet.lerp`', () {
|
|
final list1 = [
|
|
MockData.radarDataSet1,
|
|
MockData.radarDataSet1,
|
|
MockData.radarDataSet1,
|
|
];
|
|
final list2 = [
|
|
MockData.radarDataSet2,
|
|
MockData.radarDataSet2,
|
|
MockData.radarDataSet2,
|
|
MockData.radarDataSet2,
|
|
];
|
|
|
|
expect(
|
|
lerpRadarDataSetList(list1, list2, 1),
|
|
lerpList(list1, list2, 1, lerp: RadarDataSet.lerp),
|
|
);
|
|
});
|
|
}
|