Add test "Partially covered, finds tappable area"

lib/src/act/act.dart

@@ -80,24 +80,32 @@ class Act {
         final renderBox = _getRenderBoxOrThrow(selector);
         _validateViewBounds(renderBox, selector: selector);
 
-        final centerPosition =
-            renderBox.localToGlobal(renderBox.size.center(Offset.zero));
+        final tappedPosition = _findPokablePosition(
+          widgetSelector: selector,
+          snapshot: snapshot,
+        );
+
+        if (tappedPosition == null) {
+          throw TestFailure(
+            "Widget '${selector.toStringBreadcrumb()}' is not interactable.",
+          );
+        }
 
         // Before tapping the widget, we need to make sure that the widget is not
         // covered by another widget, or outside the viewport.
         _pokeRenderObject(
-          position: centerPosition,
+          position: tappedPosition,
           target: renderBox,
           snapshot: snapshot,
         );
 
         final binding = TestWidgetsFlutterBinding.instance;
 
         // Finally, tap the widget by sending a down and up event.
-        final downEvent = PointerDownEvent(position: centerPosition);
+        final downEvent = PointerDownEvent(position: tappedPosition);
         binding.handlePointerEvent(downEvent);
 
-        final upEvent = PointerUpEvent(position: centerPosition);
+        final upEvent = PointerUpEvent(position: tappedPosition);
         binding.handlePointerEvent(upEvent);
 
         await binding.pump();
@@ -325,22 +333,30 @@ class Act {
       renderBox.size.topRight(Offset.zero),
       renderBox.size.bottomRight(Offset.zero),
     ];
-
+    int iterations = 0;
+    final firstPosition = renderBox.localToGlobal(initialPosition);
     for (final localPosition in mostLikelyHitRegions) {
+      if (iterations == 1) {
+        // ignore: avoid_print
+        print(
+          "Widget failed hit test at its center ($firstPosition). Trying to find passing region within the widget's boundaries.",
+        );
+      }
       final Offset globalPosition = renderBox.localToGlobal(localPosition);
       if (_canBePoked(
         position: globalPosition,
         target: renderBox,
         snapshot: snapshot,
       )) {
-        if (globalPosition != initialPosition) {
+        if (globalPosition != firstPosition) {
           // ignore: avoid_print
           print(
-            'Warning: The widget is not interactable at the center but was interactable at $globalPosition',
+            'Found hit testable position of widget at $globalPosition',
           );
         }
         return globalPosition;
       }
+      iterations++;
     }
 
     // No luck with the most likely hit regions, let's try a grid pattern
@@ -361,10 +377,10 @@ class Act {
           target: renderBox,
           snapshot: snapshot,
         )) {
-          if (globalPosition != initialPosition) {
+          if (globalPosition != firstPosition) {
             // ignore: avoid_print
             print(
-              'Warning: The widget is not interactable at the center but was interactable at $globalPosition',
+              'Found hit testable position of widget at $globalPosition.',
             );
           }
           return globalPosition;

test/act/find_tappable_area_test.dart

@@ -0,0 +1,27 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:spot/spot.dart';
+
+import '../widgets/custom_tappable_area_widget.dart';
+
+void main() {
+  testWidgets('Partially covered, finds tappable area', (tester) async {
+    bool gotTapped = false;
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Center(
+          child: CustomTappableAreaWidget(
+            tappablePosition: const MapEntry(15, 15),
+            onTap: (tapped) {
+              gotTapped = tapped;
+            },
+          ),
+        ),
+      ),
+    );
+    final WidgetSelector<WidgetToPoke> button = spot<WidgetToPoke>()
+      ..existsOnce();
+    await act.tap(button);
+    expect(gotTapped, isTrue);
+  });
+}

test/widgets/custom_tappable_area_widget.dart

@@ -3,40 +3,85 @@ import 'package:flutter/material.dart';
 class CustomTappableAreaWidget extends StatelessWidget {
   const CustomTappableAreaWidget({
     super.key,
-    required this.tapOffset,
+    MapEntry<int, int>? tappablePosition,
     required this.onTap,
-    this.areaSize = 50.0,
-  });
+    Size? boardSize,
+    MapEntry<int, int>? cubeCount,
+  })  : _boardSize = boardSize ?? const Size(400, 400),
+        _tappablePosition = tappablePosition ?? const MapEntry(1, 1),
+        _cubeCount = cubeCount ?? const MapEntry<int, int>(16, 16);
+
+  final Size _boardSize;
 
-  final Offset tapOffset;
-  final double areaSize;
-  final VoidCallback onTap;
+  final MapEntry<int, int> _cubeCount;
+  final MapEntry<int, int>? _tappablePosition;
+  final void Function(bool) onTap;
+
+  double get _totalWidth => _boardSize.width;
+  double get _totalHeight => _boardSize.height;
+  double get _cubeWidth => _totalWidth / _cubeCount.key;
+  double get _cubeHeight => _totalWidth / _cubeCount.value;
 
   @override
   Widget build(BuildContext context) {
-    return Stack(
-      children: <Widget>[
-        const IgnorePointer(
-          child: ColoredBox(
-            color: Colors.transparent,
-          ),
-        ),
-        Positioned(
-          left: tapOffset.dx - areaSize / 2,
-          top: tapOffset.dy - areaSize / 2,
-          child: GestureDetector(
-            onTap: onTap,
-            child: Container(
-              width: areaSize,
-              height: areaSize,
-              decoration: BoxDecoration(
-                color: Colors.blue.withOpacity(0.5),
-                shape: BoxShape.circle,
-              ),
+    return ConstrainedBox(
+      constraints: BoxConstraints(
+        maxWidth: _totalWidth,
+        maxHeight: _totalHeight,
+      ),
+      child: Stack(
+        children: [
+          GestureDetector(
+            onTap: () {
+              onTap.call(true);
+            },
+            child: WidgetToPoke(
+              width: _totalWidth,
+              height: _totalHeight,
             ),
           ),
-        ),
-      ],
+          Column(
+            children: List.generate(_cubeCount.value, (row) {
+              return Row(
+                children: List.generate(_cubeCount.key, (col) {
+                  final bool isTappable = _tappablePosition?.key == row &&
+                      _tappablePosition?.value == col;
+                  return IgnorePointer(
+                    ignoring: isTappable,
+                    child: Container(
+                      width: _cubeWidth,
+                      height: _cubeHeight,
+                      color: isTappable
+                          ? Colors.transparent
+                          : ((row + col).isEven ? Colors.white : Colors.black),
+                    ),
+                  );
+                }),
+              );
+            }),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class WidgetToPoke extends StatelessWidget {
+  const WidgetToPoke({
+    super.key,
+    required this.width,
+    required this.height,
+  });
+
+  final double width;
+  final double height;
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      width: width,
+      height: height,
+      color: Colors.green,
     );
   }
 }