Cover the popup layout and file copy fixes with tests

Both were changed in this branch but had no coverage: the layout delegate
now handles a child larger than its viewport, where clamp used to be given
an upper bound below its lower one, and safeCopy reports a missing source
instead of creating an empty file in its place.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: MOMO0302-02

test/common/file_test.dart

@@ -0,0 +1,54 @@
+import 'dart:io';
+
+import 'package:fl_clash/common/file.dart';
+import 'package:path/path.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('FileExt.safeCopy', () {
+    late Directory dir;
+
+    setUp(() {
+      dir = Directory.systemTemp.createTempSync('fl_clash_file_test');
+    });
+
+    tearDown(() {
+      if (dir.existsSync()) {
+        dir.deleteSync(recursive: true);
+      }
+    });
+
+    test('copies an existing file and reports success', () async {
+      final source = File(join(dir.path, 'source.txt'))
+        ..writeAsStringSync('payload');
+      final targetPath = join(dir.path, 'nested', 'target.txt');
+
+      expect(await source.safeCopy(targetPath), isTrue);
+      expect(File(targetPath).readAsStringSync(), 'payload');
+    });
+
+    test('overwrites an existing target', () async {
+      final source = File(join(dir.path, 'source.txt'))
+        ..writeAsStringSync('new');
+      final targetPath = join(dir.path, 'target.txt');
+      File(targetPath).writeAsStringSync('old');
+
+      expect(await source.safeCopy(targetPath), isTrue);
+      expect(File(targetPath).readAsStringSync(), 'new');
+    });
+
+    // It used to create the *source* instead, leaving an empty file behind
+    // and reporting nothing, so a backup missing a profile restored silently.
+    test(
+      'reports failure and creates nothing when the source is missing',
+      () async {
+        final source = File(join(dir.path, 'missing.txt'));
+        final targetPath = join(dir.path, 'target.txt');
+
+        expect(await source.safeCopy(targetPath), isFalse);
+        expect(source.existsSync(), isFalse);
+        expect(File(targetPath).existsSync(), isFalse);
+      },
+    );
+  });
+}

test/widgets/popup_test.dart

@@ -0,0 +1,85 @@
+import 'package:fl_clash/widgets/popup.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('OverflowAwareLayoutDelegate', () {
+    Offset position({
+      required Offset offset,
+      required Size size,
+      required Size childSize,
+    }) {
+      return OverflowAwareLayoutDelegate(
+        offset: offset,
+      ).getPositionForChild(size, childSize);
+    }
+
+    test('places the child to the left of the anchor', () {
+      expect(
+        position(
+          offset: const Offset(300, 200),
+          size: const Size(800, 600),
+          childSize: const Size(100, 50),
+        ),
+        const Offset(200, 200),
+      );
+    });
+
+    test('keeps the child inside the right and bottom edges', () {
+      expect(
+        position(
+          offset: const Offset(790, 590),
+          size: const Size(800, 600),
+          childSize: const Size(100, 50),
+        ),
+        const Offset(684, 534),
+      );
+    });
+
+    test('never returns a negative position', () {
+      expect(
+        position(
+          offset: Offset.zero,
+          size: const Size(800, 600),
+          childSize: const Size(100, 50),
+        ),
+        Offset.zero,
+      );
+    });
+
+    // A child larger than the viewport puts clamp's upper bound below its
+    // lower one, which throws instead of laying out.
+    test('does not throw when the child is wider than the viewport', () {
+      expect(
+        position(
+          offset: const Offset(100, 100),
+          size: const Size(200, 600),
+          childSize: const Size(400, 50),
+        ),
+        const Offset(0, 100),
+      );
+    });
+
+    test('does not throw when the child is taller than the viewport', () {
+      expect(
+        position(
+          offset: const Offset(100, 100),
+          size: const Size(800, 100),
+          childSize: const Size(100, 400),
+        ),
+        const Offset(0, 0),
+      );
+    });
+
+    test('does not throw when the child exactly fills the viewport', () {
+      expect(
+        position(
+          offset: const Offset(50, 50),
+          size: const Size(200, 200),
+          childSize: const Size(200, 200),
+        ),
+        Offset.zero,
+      );
+    });
+  });
+}