update

test/enemy_intent_test.dart

@@ -0,0 +1,44 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_test/providers/battle_provider.dart';
+import 'package:game_test/game/data/enemy_table.dart';
+import 'package:game_test/game/data/item_table.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  setUpAll(() async {
+    await ItemTable.load();
+    await EnemyTable.load();
+  });
+
+  test('Enemy generates intent on spawn', () {
+    final provider = BattleProvider();
+    provider.initializeBattle();
+
+    // Should have an enemy and an intent
+    expect(provider.enemy, isNotNull);
+    expect(provider.currentEnemyIntent, isNotNull);
+    print('Initial Intent: ${provider.currentEnemyIntent!.description}');
+  });
+
+  test('Enemy executes intent and generates new one', () async {
+    final provider = BattleProvider();
+    provider.initializeBattle();
+
+    // Force player turn to end to trigger enemy turn
+    // We can't easily call private methods, but we can simulate flow or check state
+    // BattleProvider logic is tightly coupled with async delays in _enemyTurn,
+    // so unit testing the exact flow is tricky without mocking.
+    // Instead, we will test the public state changes if possible or just rely on the fact that
+    // initializeBattle calls _prepareNextStage which calls _generateEnemyIntent.
+
+    // Let's verify the intent structure
+    final intent = provider.currentEnemyIntent!;
+    expect(intent.value, greaterThan(0));
+    expect(intent.type, anyOf(EnemyActionType.attack, EnemyActionType.defend));
+    expect(
+      intent.risk,
+      anyOf(RiskLevel.safe, RiskLevel.normal, RiskLevel.risky),
+    );
+  });
+}

test/enemy_load_test.dart

@@ -0,0 +1,24 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_test/game/data/enemy_table.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  test('Load Enemy Table', () async {
+    await EnemyTable.load();
+
+    expect(EnemyTable.normalEnemies.isNotEmpty, true);
+    expect(EnemyTable.eliteEnemies.isNotEmpty, true);
+
+    final goblin = EnemyTable.normalEnemies.firstWhere(
+      (e) => e.name == 'Goblin',
+    );
+    expect(goblin.baseHp, 20);
+    expect(goblin.baseAtk, 5);
+
+    final orc = EnemyTable.eliteEnemies.firstWhere(
+      (e) => e.name == 'Orc Warrior',
+    );
+    expect(orc.baseHp, 60);
+  });
+}

test/item_load_test.dart

@@ -0,0 +1,40 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_test/game/data/item_table.dart';
+import 'package:flutter/services.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  test('ItemTable loads items from JSON', () async {
+    // We need to ensure the assets are loaded.
+    // In a unit test, rootBundle might not point to the real assets folder easily without setup.
+    // However, we can verify that the code *attempts* to load and parses correctly if we mock the bundle,
+    // OR we can try to run it and see if it finds the file.
+
+    // For this environment, let's try to run it. If it fails to find asset, we might need to mock.
+    // But since we want to verify the JSON content validity, mocking the *content* with the *actual file content* is a good middle ground if direct loading fails.
+
+    // Let's try direct load first.
+    try {
+      await ItemTable.load();
+
+      expect(ItemTable.weapons.isNotEmpty, true, reason: "Weapons should be loaded");
+      expect(ItemTable.armors.isNotEmpty, true, reason: "Armors should be loaded");
+      expect(ItemTable.shields.isNotEmpty, true, reason: "Shields should be loaded");
+      expect(ItemTable.accessories.isNotEmpty, true, reason: "Accessories should be loaded");
+
+      print("Loaded ${ItemTable.weapons.length} weapons");
+      print("Loaded ${ItemTable.armors.length} armors");
+      print("Loaded ${ItemTable.shields.length} shields");
+      print("Loaded ${ItemTable.accessories.length} accessories");
+
+    } catch (e) {
+      // If asset loading fails (common in raw flutter_test without integration test setup),
+      // we can't easily fix the environment here, but we can verify the JSON parsing logic
+      // by mocking the channel if we really wanted to.
+      // But for now, let's see if it works.
+      print("Error loading items: $e");
+      rethrow;
+    }
+  });
+}