// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// reduced-test-set:
//   This file is run as part of a reduced test set in CI on Mac and Windows
//   machines.
@Tags(<String>['reduced-test-set'])
library;

import 'package:flutter/cupertino.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';

import '../widgets/semantics_tester.dart';

void main() {
  setUp(() {
    debugResetSemanticsIdCounter();
  });

  testWidgets('CupertinoCheckbox semantics', (WidgetTester tester) async {
    final SemanticsHandle handle = tester.ensureSemantics();

    await tester.pumpWidget(
      CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: false, onChanged: (bool? b) {})),
      ),
    );

    expect(
      tester.getSemantics(find.byType(Focus).last),
      matchesSemantics(
        hasCheckedState: true,
        hasEnabledState: true,
        isEnabled: true,
        hasTapAction: true,
        hasFocusAction: true,
        isFocusable: true,
      ),
    );

    await tester.pumpWidget(
      CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: true, onChanged: (bool? b) {})),
      ),
    );

    expect(
      tester.getSemantics(find.byType(Focus).last),
      matchesSemantics(
        hasCheckedState: true,
        hasEnabledState: true,
        isChecked: true,
        isEnabled: true,
        hasTapAction: true,
        hasFocusAction: true,
        isFocusable: true,
      ),
    );

    await tester.pumpWidget(
      const CupertinoApp(home: Center(child: CupertinoCheckbox(value: false, onChanged: null))),
    );

    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(
        hasCheckedState: true,
        hasEnabledState: true,
        // isFocusable is delayed by 1 frame.
        isFocusable: true,
        hasFocusAction: true,
      ),
    );

    await tester.pump();
    // isFocusable should be false now after the 1 frame delay.
    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(hasCheckedState: true, hasEnabledState: true),
    );

    await tester.pumpWidget(
      const CupertinoApp(home: Center(child: CupertinoCheckbox(value: true, onChanged: null))),
    );

    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(hasCheckedState: true, hasEnabledState: true, isChecked: true),
    );

    await tester.pumpWidget(
      const CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: null, tristate: true, onChanged: null)),
      ),
    );

    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(hasCheckedState: true, hasEnabledState: true, isCheckStateMixed: true),
    );

    await tester.pumpWidget(
      const CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: true, tristate: true, onChanged: null)),
      ),
    );

    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(hasCheckedState: true, hasEnabledState: true, isChecked: true),
    );

    await tester.pumpWidget(
      const CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: false, tristate: true, onChanged: null)),
      ),
    );

    expect(
      tester.getSemantics(find.byType(CupertinoCheckbox)),
      matchesSemantics(hasCheckedState: true, hasEnabledState: true),
    );

    handle.dispose();
  });

  testWidgets('Can wrap CupertinoCheckbox with Semantics', (WidgetTester tester) async {
    final SemanticsHandle handle = tester.ensureSemantics();

    await tester.pumpWidget(
      CupertinoApp(
        home: Semantics(
          label: 'foo',
          textDirection: TextDirection.ltr,
          child: CupertinoCheckbox(value: false, onChanged: (bool? b) {}),
        ),
      ),
    );

    expect(
      tester.getSemantics(find.byType(Focus).last),
      matchesSemantics(
        label: 'foo',
        textDirection: TextDirection.ltr,
        hasCheckedState: true,
        hasEnabledState: true,
        isEnabled: true,
        hasTapAction: true,
        hasFocusAction: true,
        isFocusable: true,
      ),
    );
    handle.dispose();
  });

  testWidgets('CupertinoCheckbox tristate: true', (WidgetTester tester) async {
    bool? checkBoxValue;

    await tester.pumpWidget(
      CupertinoApp(
        home: StatefulBuilder(
          builder: (BuildContext context, StateSetter setState) {
            return CupertinoCheckbox(
              tristate: true,
              value: checkBoxValue,
              onChanged: (bool? value) {
                setState(() {
                  checkBoxValue = value;
                });
              },
            );
          },
        ),
      ),
    );

    expect(tester.widget<CupertinoCheckbox>(find.byType(CupertinoCheckbox)).value, null);

    await tester.tap(find.byType(CupertinoCheckbox));
    await tester.pumpAndSettle();
    expect(checkBoxValue, false);

    await tester.tap(find.byType(CupertinoCheckbox));
    await tester.pumpAndSettle();
    expect(checkBoxValue, true);

    await tester.tap(find.byType(CupertinoCheckbox));
    await tester.pumpAndSettle();
    expect(checkBoxValue, null);

    checkBoxValue = true;
    await tester.pumpAndSettle();
    expect(checkBoxValue, true);

    checkBoxValue = null;
    await tester.pumpAndSettle();
    expect(checkBoxValue, null);
  });

  testWidgets('has semantics for tristate', (WidgetTester tester) async {
    final semantics = SemanticsTester(tester);
    await tester.pumpWidget(
      CupertinoApp(
        home: CupertinoCheckbox(tristate: true, value: null, onChanged: (bool? newValue) {}),
      ),
    );

    expect(
      semantics.nodesWith(
        flags: <SemanticsFlag>[
          SemanticsFlag.hasCheckedState,
          SemanticsFlag.hasEnabledState,
          SemanticsFlag.isEnabled,
          SemanticsFlag.isFocusable,
          SemanticsFlag.isCheckStateMixed,
        ],
        actions: <SemanticsAction>[SemanticsAction.focus, SemanticsAction.tap],
      ),
      hasLength(1),
    );

    await tester.pumpWidget(
      CupertinoApp(
        home: CupertinoCheckbox(tristate: true, value: true, onChanged: (bool? newValue) {}),
      ),
    );

    expect(
      semantics.nodesWith(
        flags: <SemanticsFlag>[
          SemanticsFlag.hasCheckedState,
          SemanticsFlag.hasEnabledState,
          SemanticsFlag.isEnabled,
          SemanticsFlag.isChecked,
          SemanticsFlag.isFocusable,
        ],
        actions: <SemanticsAction>[SemanticsAction.tap, SemanticsAction.focus],
      ),
      hasLength(1),
    );

    await tester.pumpWidget(
      CupertinoApp(
        home: CupertinoCheckbox(tristate: true, value: false, onChanged: (bool? newValue) {}),
      ),
    );

    expect(
      semantics.nodesWith(
        flags: <SemanticsFlag>[
          SemanticsFlag.hasCheckedState,
          SemanticsFlag.hasEnabledState,
          SemanticsFlag.isEnabled,
          SemanticsFlag.isFocusable,
        ],
        actions: <SemanticsAction>[SemanticsAction.tap, SemanticsAction.focus],
      ),
      hasLength(1),
    );

    semantics.dispose();
  });

  testWidgets('has semantic events', (WidgetTester tester) async {
    dynamic semanticEvent;
    bool? checkboxValue = false;
    tester.binding.defaultBinaryMessenger.setMockDecodedMessageHandler<dynamic>(
      SystemChannels.accessibility,
      (dynamic message) async {
        semanticEvent = message;
      },
    );
    final semanticsTester = SemanticsTester(tester);

    await tester.pumpWidget(
      CupertinoApp(
        home: StatefulBuilder(
          builder: (BuildContext context, StateSetter setState) {
            return CupertinoCheckbox(
              value: checkboxValue,
              onChanged: (bool? value) {
                setState(() {
                  checkboxValue = value;
                });
              },
            );
          },
        ),
      ),
    );

    await tester.tap(find.byType(CupertinoCheckbox));
    final RenderObject object = tester.firstRenderObject(find.byType(CupertinoCheckbox));

    expect(checkboxValue, true);
    expect(semanticEvent, <String, dynamic>{
      'type': 'tap',
      'nodeId': object.debugSemantics!.id,
      'data': <String, dynamic>{},
    });
    expect(object.debugSemantics!.getSemanticsData().hasAction(SemanticsAction.tap), true);

    tester.binding.defaultBinaryMessenger.setMockDecodedMessageHandler<dynamic>(
      SystemChannels.accessibility,
      null,
    );
    semanticsTester.dispose();
  });

  testWidgets('Checkbox can configure a semantic label', (WidgetTester tester) async {
    final SemanticsHandle handle = tester.ensureSemantics();

    await tester.pumpWidget(
      CupertinoApp(
        home: Center(
          child: CupertinoCheckbox(
            value: false,
            onChanged: (bool? b) {},
            semanticLabel: 'checkbox',
          ),
        ),
      ),
    );
    expect(
      tester.getSemantics(find.byType(Focus).last),
      matchesSemantics(
        hasCheckedState: true,
        hasEnabledState: true,
        isEnabled: true,
        hasTapAction: true,
        hasFocusAction: true,
        isFocusable: true,
        label: 'checkbox',
      ),
    );

    // If wrapped with semantics, both the parent semantic label and the
    // checkbox's semantic label are used in annotation.
    await tester.pumpWidget(
      CupertinoApp(
        home: Semantics(
          label: 'foo',
          textDirection: TextDirection.ltr,
          child: CupertinoCheckbox(
            value: false,
            onChanged: (bool? b) {},
            semanticLabel: 'checkbox',
          ),
        ),
      ),
    );
    expect(
      tester.getSemantics(find.byType(Focus).last),
      matchesSemantics(
        label: 'foo\ncheckbox',
        textDirection: TextDirection.ltr,
        hasCheckedState: true,
        hasEnabledState: true,
        isEnabled: true,
        hasTapAction: true,
        hasFocusAction: true,
        isFocusable: true,
      ),
    );
    handle.dispose();
  });

  testWidgets('Checkbox can be toggled by keyboard shortcuts', (WidgetTester tester) async {
    tester.binding.focusManager.highlightStrategy = FocusHighlightStrategy.alwaysTraditional;
    bool? value = true;
    Widget buildApp({bool enabled = true}) {
      return CupertinoApp(
        home: Center(
          child: StatefulBuilder(
            builder: (BuildContext context, StateSetter setState) {
              return CupertinoCheckbox(
                value: value,
                onChanged: enabled
                    ? (bool? newValue) {
                        setState(() {
                          value = newValue;
                        });
                      }
                    : null,
                autofocus: true,
              );
            },
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp());
    await tester.pumpAndSettle();
    await tester.sendKeyEvent(LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    // On web, switches don't respond to the enter key.
    expect(value, kIsWeb ? isTrue : isFalse);
    await tester.sendKeyEvent(LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    expect(value, isTrue);
    await tester.sendKeyEvent(LogicalKeyboardKey.space);
    await tester.pumpAndSettle();
    expect(value, isFalse);
    await tester.sendKeyEvent(LogicalKeyboardKey.space);
    await tester.pumpAndSettle();
    expect(value, isTrue);
  });

  testWidgets('Checkbox respects shape and side on mobile', (WidgetTester tester) async {
    const roundedRectangleBorder = RoundedRectangleBorder(
      borderRadius: BorderRadius.all(Radius.circular(5)),
    );

    const side = BorderSide(width: 4, color: Color(0xfff44336));

    Widget buildApp() {
      return CupertinoApp(
        home: Center(
          child: StatefulBuilder(
            builder: (BuildContext context, StateSetter setState) {
              return CupertinoCheckbox(
                value: false,
                onChanged: (bool? newValue) {},
                shape: roundedRectangleBorder,
                side: side,
              );
            },
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp());
    await tester.pumpAndSettle();

    expect(
      tester.widget<CupertinoCheckbox>(find.byType(CupertinoCheckbox)).shape,
      roundedRectangleBorder,
    );
    expect(tester.widget<CupertinoCheckbox>(find.byType(CupertinoCheckbox)).side, side);
    expect(
      find.byType(CupertinoCheckbox),
      paints..drrect(
        color: const Color(0xfff44336),
        outer: RRect.fromLTRBR(15.0, 15.0, 29.0, 29.0, const Radius.circular(5)),
        inner: RRect.fromLTRBR(19.0, 19.0, 25.0, 25.0, const Radius.circular(1)),
      ),
    );
  }, variant: TargetPlatformVariant.mobile());

  testWidgets('Checkbox respects shape and side on desktop', (WidgetTester tester) async {
    const roundedRectangleBorder = RoundedRectangleBorder(
      borderRadius: BorderRadius.all(Radius.circular(5)),
    );

    const side = BorderSide(width: 4, color: Color(0xfff44336));

    Widget buildApp() {
      return CupertinoApp(
        home: Center(
          child: StatefulBuilder(
            builder: (BuildContext context, StateSetter setState) {
              return CupertinoCheckbox(
                value: false,
                onChanged: (bool? newValue) {},
                shape: roundedRectangleBorder,
                side: side,
              );
            },
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp());
    await tester.pumpAndSettle();

    expect(
      tester.widget<CupertinoCheckbox>(find.byType(CupertinoCheckbox)).shape,
      roundedRectangleBorder,
    );
    expect(tester.widget<CupertinoCheckbox>(find.byType(CupertinoCheckbox)).side, side);
    expect(
      find.byType(CupertinoCheckbox),
      paints..drrect(
        color: const Color(0xfff44336),
        outer: RRect.fromLTRBR(0.0, 0.0, 14.0, 14.0, const Radius.circular(5)),
        inner: RRect.fromLTRBR(4.0, 4.0, 10.0, 10.0, const Radius.circular(1)),
      ),
    );
  }, variant: TargetPlatformVariant.desktop());

  testWidgets('Checkbox respects tap target size', (WidgetTester tester) async {
    Widget buildApp() {
      return CupertinoApp(
        home: Center(
          child: StatefulBuilder(
            builder: (BuildContext context, StateSetter setState) {
              return CupertinoCheckbox(
                value: false,
                onChanged: (bool? newValue) {},
                tapTargetSize: const Size.square(20.0),
              );
            },
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp());
    await tester.pumpAndSettle();

    expect(
      find.byType(CupertinoCheckbox),
      paints..drrect(
        outer: RRect.fromLTRBR(3.0, 3.0, 17.0, 17.0, const Radius.circular(4)),
        inner: RRect.fromLTRBR(4.0, 4.0, 16.0, 16.0, const Radius.circular(3)),
      ),
    );
  });

  testWidgets('Checkbox configures mouse cursor', (WidgetTester tester) async {
    Widget buildApp({MouseCursor? mouseCursor, bool enabled = true, bool value = true}) {
      return CupertinoApp(
        home: Center(
          child: CupertinoCheckbox(
            value: value,
            onChanged: enabled ? (bool? value) {} : null,
            mouseCursor: mouseCursor,
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp(value: false));
    final TestGesture gesture = await tester.createGesture(
      kind: PointerDeviceKind.mouse,
      pointer: 1,
    );
    addTearDown(gesture.removePointer);
    await gesture.addPointer(location: tester.getCenter(find.byType(CupertinoCheckbox)));
    await tester.pump();
    await gesture.moveTo(tester.getCenter(find.byType(CupertinoCheckbox)));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      kIsWeb ? SystemMouseCursors.click : SystemMouseCursors.basic,
    );

    // Test disabled checkbox.
    await tester.pumpWidget(buildApp(enabled: false, value: false));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.basic,
    );

    // Test mouse cursor can be configured.
    await tester.pumpWidget(buildApp(mouseCursor: SystemMouseCursors.grab));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.grab,
    );
  });

  testWidgets('Mouse cursor resolves in selected/focused/disabled states', (
    WidgetTester tester,
  ) async {
    tester.binding.focusManager.highlightStrategy = FocusHighlightStrategy.alwaysTraditional;
    final focusNode = FocusNode(debugLabel: 'Checkbox');
    addTearDown(focusNode.dispose);

    Widget buildCheckbox({required bool value, required bool enabled}) {
      return CupertinoApp(
        home: Center(
          child: CupertinoCheckbox(
            value: value,
            onChanged: enabled ? (bool? value) {} : null,
            mouseCursor: const _CheckboxMouseCursor(),
            focusNode: focusNode,
          ),
        ),
      );
    }

    // Test unselected case.
    await tester.pumpWidget(buildCheckbox(value: false, enabled: true));
    final TestGesture gesture1 = await tester.createGesture(
      kind: PointerDeviceKind.mouse,
      pointer: 1,
    );
    addTearDown(gesture1.removePointer);
    await gesture1.addPointer(location: tester.getCenter(find.byType(CupertinoCheckbox)));
    await tester.pump();
    await gesture1.moveTo(tester.getCenter(find.byType(CupertinoCheckbox)));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.basic,
    );

    // Test selected case.
    await tester.pumpWidget(buildCheckbox(value: true, enabled: true));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.click,
    );

    // Test focused case.
    await tester.pumpWidget(buildCheckbox(value: true, enabled: true));
    focusNode.requestFocus();
    await tester.pump();
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.grab,
    );

    // Test disabled case.
    await tester.pumpWidget(buildCheckbox(value: true, enabled: false));
    expect(
      RendererBinding.instance.mouseTracker.debugDeviceActiveCursor(1),
      SystemMouseCursors.forbidden,
    );
  });

  testWidgets('Checkbox default colors, and size in light mode', (WidgetTester tester) async {
    Widget buildCheckbox({bool value = true}) {
      return CupertinoApp(
        home: Center(
          child: RepaintBoundary(
            child: CupertinoCheckbox(value: value, onChanged: (bool? newValue) {}),
          ),
        ),
      );
    }

    await tester.pumpWidget(buildCheckbox());
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.light_theme.selected.png'),
    );
    await tester.pumpWidget(buildCheckbox(value: false));
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.light_theme.unselected.png'),
    );
  });

  testWidgets('Checkbox default colors, and size in dark mode', (WidgetTester tester) async {
    Widget buildCheckbox({bool value = true}) {
      return CupertinoApp(
        theme: const CupertinoThemeData(brightness: Brightness.dark),
        home: Center(
          child: RepaintBoundary(
            child: CupertinoCheckbox(value: value, onChanged: (bool? newValue) {}),
          ),
        ),
      );
    }

    await tester.pumpWidget(buildCheckbox());
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.dark_theme.selected.png'),
    );
    await tester.pumpWidget(buildCheckbox(value: false));
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.dark_theme.unselected.png'),
    );
  });

  testWidgets('Disabled checkbox default colors, and size in light mode', (
    WidgetTester tester,
  ) async {
    Widget buildCheckbox({bool value = true}) {
      return CupertinoApp(
        home: Center(
          child: RepaintBoundary(child: CupertinoCheckbox(value: value, onChanged: null)),
        ),
      );
    }

    await tester.pumpWidget(buildCheckbox());
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.disabled_light_theme.selected.png'),
    );
    await tester.pumpWidget(buildCheckbox(value: false));
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.disabled_light_theme.unselected.png'),
    );
  });

  testWidgets('Disabled checkbox default colors, and size in dark mode', (
    WidgetTester tester,
  ) async {
    Widget buildCheckbox({bool value = true}) {
      return CupertinoApp(
        theme: const CupertinoThemeData(brightness: Brightness.dark),
        home: Center(
          child: RepaintBoundary(child: CupertinoCheckbox(value: value, onChanged: null)),
        ),
      );
    }

    await tester.pumpWidget(buildCheckbox());
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.disabled_dark_theme.selected.png'),
    );
    await tester.pumpWidget(buildCheckbox(value: false));
    await expectLater(
      find.byType(CupertinoCheckbox),
      matchesGoldenFile('checkbox.disabled_dark_theme.unselected.png'),
    );
  });

  testWidgets('Checkbox fill color resolves in enabled/disabled states', (
    WidgetTester tester,
  ) async {
    const activeEnabledFillColor = Color(0xFF000001);
    const activeDisabledFillColor = Color(0xFF000002);

    Color getFillColor(Set<WidgetState> states) {
      if (states.contains(WidgetState.disabled)) {
        return activeDisabledFillColor;
      }
      return activeEnabledFillColor;
    }

    final WidgetStateProperty<Color> fillColor = WidgetStateColor.resolveWith(getFillColor);

    Widget buildApp({required bool enabled}) {
      return CupertinoApp(
        home: CupertinoCheckbox(
          value: true,
          fillColor: fillColor,
          onChanged: enabled ? (bool? value) {} : null,
        ),
      );
    }

    RenderBox getCheckboxRenderer() {
      return tester.renderObject<RenderBox>(find.byType(CupertinoCheckbox));
    }

    await tester.pumpWidget(buildApp(enabled: true));
    await tester.pumpAndSettle();
    expect(getCheckboxRenderer(), paints..path(color: activeEnabledFillColor));

    await tester.pumpWidget(buildApp(enabled: false));
    await tester.pumpAndSettle();
    expect(getCheckboxRenderer(), paints..path(color: activeDisabledFillColor));
  });

  testWidgets('Checkbox fill color take precedence over active/inactive colors', (
    WidgetTester tester,
  ) async {
    const activeEnabledFillColor = Color(0xFF000001);
    const activeDisabledFillColor = Color(0xFF000002);
    const activeColor = Color(0xFF000003);
    const inactiveColor = Color(0xFF000004);

    Color getFillColor(Set<WidgetState> states) {
      if (states.contains(WidgetState.disabled)) {
        return activeDisabledFillColor;
      }
      return activeEnabledFillColor;
    }

    final WidgetStateProperty<Color> fillColor = WidgetStateColor.resolveWith(getFillColor);

    Widget buildApp({required bool enabled}) {
      return CupertinoApp(
        home: CupertinoCheckbox(
          value: true,
          fillColor: fillColor,
          activeColor: activeColor,
          inactiveColor: inactiveColor,
          onChanged: enabled ? (bool? value) {} : null,
        ),
      );
    }

    RenderBox getCheckboxRenderer() {
      return tester.renderObject<RenderBox>(find.byType(CupertinoCheckbox));
    }

    await tester.pumpWidget(buildApp(enabled: true));
    await tester.pumpAndSettle();
    expect(getCheckboxRenderer(), paints..path(color: activeEnabledFillColor));

    await tester.pumpWidget(buildApp(enabled: false));
    await tester.pumpAndSettle();
    expect(getCheckboxRenderer(), paints..path(color: activeDisabledFillColor));
  });

  testWidgets('Checkbox fill color resolves in hovered/focused states', (
    WidgetTester tester,
  ) async {
    final focusNode = FocusNode(debugLabel: 'checkbox');
    addTearDown(focusNode.dispose);

    tester.binding.focusManager.highlightStrategy = FocusHighlightStrategy.alwaysTraditional;
    const hoveredFillColor = Color(0xFF000001);
    const focusedFillColor = Color(0xFF000002);
    const transparentColor = Color(0x00000000);

    Color getFillColor(Set<WidgetState> states) {
      if (states.contains(WidgetState.hovered)) {
        return hoveredFillColor;
      }
      if (states.contains(WidgetState.focused)) {
        return focusedFillColor;
      }
      return transparentColor;
    }

    final WidgetStateProperty<Color> fillColor = WidgetStateColor.resolveWith(getFillColor);

    Widget buildApp({required bool enabled}) {
      return CupertinoApp(
        home: CupertinoCheckbox(
          focusNode: focusNode,
          value: enabled,
          fillColor: fillColor,
          onChanged: enabled ? (bool? value) {} : null,
        ),
      );
    }

    RenderBox getCheckboxRenderer() {
      return tester.renderObject<RenderBox>(find.byType(CupertinoCheckbox));
    }

    await tester.pumpWidget(buildApp(enabled: true));
    focusNode.requestFocus();
    await tester.pumpAndSettle();
    expect(focusNode.hasPrimaryFocus, isTrue);
    expect(getCheckboxRenderer(), paints..path(color: focusedFillColor));

    // Start hovering.
    final TestGesture gesture = await tester.createGesture(kind: PointerDeviceKind.mouse);
    await gesture.addPointer();
    addTearDown(gesture.removePointer);
    await gesture.moveTo(tester.getCenter(find.byType(CupertinoCheckbox)));
    await tester.pumpAndSettle();

    expect(getCheckboxRenderer(), paints..path(color: hoveredFillColor));
  });

  testWidgets('Checkbox configures focus color', (WidgetTester tester) async {
    const defaultCheckColor = Color(0xffffffff);
    const defaultActiveFillColor = Color(0xff007aff);
    final Color defaultFocusColor =
        HSLColor.fromColor(CupertinoColors.activeBlue.withOpacity(kCupertinoFocusColorOpacity))
            .withLightness(kCupertinoFocusColorBrightness)
            .withSaturation(kCupertinoFocusColorSaturation)
            .toColor();
    const testFocusColor = Color(0xffaabbcc);
    tester.binding.focusManager.highlightStrategy = FocusHighlightStrategy.alwaysTraditional;
    final node = FocusNode();
    addTearDown(node.dispose);

    Widget buildApp({Color? focusColor, bool autofocus = false, FocusNode? focusNode}) {
      return CupertinoApp(
        home: Center(
          child: StatefulBuilder(
            builder: (BuildContext context, StateSetter setState) {
              return CupertinoCheckbox(
                value: true,
                onChanged: (bool? newValue) {},
                autofocus: autofocus,
                focusNode: focusNode,
                focusColor: focusColor,
              );
            },
          ),
        ),
      );
    }

    await tester.pumpWidget(buildApp(focusNode: node, autofocus: true));
    await tester.pump();
    expect(node.hasPrimaryFocus, isTrue);
    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultActiveFillColor)
        ..rrect()
        ..path(color: defaultCheckColor)
        ..path(color: defaultFocusColor, strokeWidth: 3.5, style: PaintingStyle.stroke),
      reason: 'Checkbox shows the correct focus color',
    );

    await tester.pumpWidget(buildApp(focusColor: testFocusColor, focusNode: node, autofocus: true));
    await tester.pump();
    expect(node.hasPrimaryFocus, isTrue);
    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultActiveFillColor)
        ..rrect()
        ..path(color: defaultCheckColor)
        ..path(color: testFocusColor, strokeWidth: 3.5, style: PaintingStyle.stroke),
      reason: 'Checkbox can configure a focus color',
    );
  });

  testWidgets('Checkbox is darkened when pressed in light mode', (WidgetTester tester) async {
    const defaultCheckColor = Color(0xffffffff);
    const defaultActiveFillColor = Color(0xff007aff);
    const defaultInactiveFillColor = Color(0xffffffff);
    const pressedDarkShadow = Color(0x26ffffff);

    await tester.pumpWidget(
      CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: false, onChanged: (_) {})),
      ),
    );

    final TestGesture gesture1 = await tester.startGesture(
      tester.getCenter(find.byType(CupertinoCheckbox)),
    );
    await tester.pump();

    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultInactiveFillColor)
        ..drrect()
        ..path(color: pressedDarkShadow),
      reason: 'Inactive pressed checkbox is slightly darkened',
    );

    await tester.pumpWidget(
      CupertinoApp(
        home: Center(child: CupertinoCheckbox(value: true, onChanged: (_) {})),
      ),
    );

    final TestGesture gesture2 = await tester.startGesture(
      tester.getCenter(find.byType(CupertinoCheckbox)),
    );
    await tester.pump();

    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultActiveFillColor)
        ..rrect()
        ..path(color: defaultCheckColor)
        ..path(color: pressedDarkShadow),
      reason: 'Active pressed checkbox is slightly darkened',
    );

    // Finish gestures to release resources.
    await gesture1.up();
    await gesture2.up();
    await tester.pump();
  });

  testWidgets('Checkbox is lightened when pressed in dark mode', (WidgetTester tester) async {
    const checkColor = Color(0xffdee8f8);
    const defaultActiveFillColor = Color(0xff3264d7);
    const defaultInactiveFillColor = Color(0xff000000);
    const pressedLightShadow = Color(0x26ffffff);

    await tester.pumpWidget(
      CupertinoApp(
        theme: const CupertinoThemeData(brightness: Brightness.dark),
        home: Center(child: CupertinoCheckbox(value: false, onChanged: (_) {})),
      ),
    );

    final TestGesture gesture1 = await tester.startGesture(
      tester.getCenter(find.byType(CupertinoCheckbox)),
    );
    await tester.pump();

    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultInactiveFillColor)
        ..drrect()
        ..path(color: pressedLightShadow),
      reason: 'Inactive pressed checkbox is slightly lightened',
    );

    await tester.pumpWidget(
      CupertinoApp(
        theme: const CupertinoThemeData(brightness: Brightness.dark),
        home: Center(child: CupertinoCheckbox(value: true, onChanged: (_) {})),
      ),
    );

    final TestGesture gesture2 = await tester.startGesture(
      tester.getCenter(find.byType(CupertinoCheckbox)),
    );
    await tester.pump();

    expect(
      find.byType(CupertinoCheckbox),
      paints
        ..path(color: defaultActiveFillColor)
        ..rrect()
        ..path(color: checkColor)
        ..path(color: pressedLightShadow),
      reason: 'Active pressed checkbox is slightly lightened',
    );

    // Finish gestures to release resources.
    await gesture1.up();
    await gesture2.up();
    await tester.pump();
  });

  testWidgets('CupertinoCheckbox does not crash at zero area', (WidgetTester tester) async {
    await tester.pumpWidget(
      CupertinoApp(
        home: Center(
          child: SizedBox.shrink(child: CupertinoCheckbox(value: true, onChanged: (_) {})),
        ),
      ),
    );
    expect(tester.getSize(find.byType(CupertinoCheckbox)), Size.zero);
  });
}

class _CheckboxMouseCursor extends WidgetStateMouseCursor {
  const _CheckboxMouseCursor();

  @override
  MouseCursor resolve(Set<WidgetState> states) {
    return const WidgetStateProperty<MouseCursor>.fromMap(<WidgetStatesConstraint, MouseCursor>{
      WidgetState.disabled: SystemMouseCursors.forbidden,
      WidgetState.focused: SystemMouseCursors.grab,
      WidgetState.selected: SystemMouseCursors.click,
      WidgetState.any: SystemMouseCursors.basic,
    }).resolve(states);
  }

  @override
  String get debugDescription => '_CheckboxMouseCursor()';
}