// Copyright 2013 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.

// This file is hand-formatted.

import 'dart:convert';
import 'dart:typed_data';

import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:rfw/formats.dart' show parseDataFile, parseLibraryFile;
import 'package:rfw/rfw.dart';

void main() {
  testWidgets('list lookup', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent(<String, Object?>{
      'list': <Object?>[ 0, 1, 2, 3, 4 ],
    });
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(find.byType(RemoteWidget), findsOneWidget);
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(find.byType(ErrorWidget), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = Column(
        children: [
          ...for v in data.list: Text(text: v, textDirection: "ltr"),
        ],
      );
    '''));
    await tester.pump();
    expect(find.byType(Text), findsNWidgets(5));
  });

  testWidgets('data updates', (WidgetTester tester) async {
    int buildCount = 0;
    int? lastValue;
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), LocalWidgetLibrary(<String, LocalWidgetBuilder>{
        'Test': (BuildContext context, DataSource source) {
          buildCount += 1;
          lastValue = source.v<int>(<Object>['value']);
          return const SizedBox.shrink();
        },
      }));
    final DynamicContent data = DynamicContent(<String, Object?>{
      'list': <Object?>[
        <String, Object?>{ 'a': 0 },
        <String, Object?>{ 'a': 1 },
        <String, Object?>{ 'a': 2 },
      ],
    });
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(buildCount, 0);
    expect(lastValue, isNull);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = Test(value: data.list.1.a);
    '''));
    await tester.pump();
    expect(buildCount, 1);
    expect(lastValue, 1);

    data.update('list', <Object?>[
      <String, Object?>{ 'a': 0 },
      <String, Object?>{ 'a': 3 },
      <String, Object?>{ 'a': 2 },
    ]);
    await tester.pump();
    expect(buildCount, 2);
    expect(lastValue, 3);

    data.update('list', <Object?>[
      <String, Object?>{ 'a': 1 },
      <String, Object?>{ 'a': 3 },
    ]);
    await tester.pump();
    expect(buildCount, 2);
    expect(lastValue, 3);

    data.update('list', <Object?>[
      <String, Object?>{ 'a': 1 },
      <String, Object?>{ },
    ]);
    await tester.pump();
    expect(buildCount, 3);
    expect(lastValue, null);

    data.update('list', <Object?>[
      <String, Object?>{ 'a': 1 },
    ]);
    await tester.pump();
    expect(buildCount, 3);
    expect(lastValue, null);
  });

  testWidgets('$RemoteFlutterWidgetsException', (WidgetTester tester) async {
    expect(const RemoteFlutterWidgetsException('test').toString(), 'test');
  });

  testWidgets('deepClone', (WidgetTester tester) async {
    final Map<String, Object> map = <String, Object>{
      'outer': <String, Object>{
        'inner': true,
      }
    };
    expect(identical(deepClone(map), map), isFalse);
    expect(deepClone(map), equals(map));
  });

  testWidgets('updateText, updateBinary, clearLibraries', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(find.byType(RemoteWidget), findsOneWidget);
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(find.byType(ErrorWidget), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = ColoredBox(color: 0xFF000000);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));

    runtime.update(const LibraryName(<String>['test']), decodeLibraryBlob(encodeLibraryBlob(parseLibraryFile('''
      import core;
      widget root = ColoredBox(color: 0xFF000001);
    '''))));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000001));

    runtime.clearLibraries();
    await tester.pump();
    expect(find.byType(RemoteWidget), findsOneWidget);
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(find.byType(ErrorWidget), findsOneWidget);
  });

  testWidgets('Runtime cached build', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['core']), 'Placeholder'),
      ),
    );

    expect(find.byType(Placeholder), findsOneWidget);
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['core']), 'SizedBoxShrink'),
      ),
    );
    expect(find.byType(Placeholder), findsNothing);
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['core']), 'Placeholder'),
      ),
    );
    expect(find.byType(Placeholder), findsOneWidget);
  });

  testWidgets('Import loops', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['a']), parseLibraryFile('''
        import b;
      '''))
      ..update(const LibraryName(<String>['b']), parseLibraryFile('''
        import a;
      '''));
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), 'Library a indirectly depends on itself via b which depends on a.');
  });

  testWidgets('Import loops', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['a']), parseLibraryFile('''
        import a;
      '''));
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), 'Library a depends on itself.');
  });

  testWidgets('Missing libraries in import', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['a']), parseLibraryFile('''
        import b;
      '''));
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(tester.widget<ErrorWidget>(find.byType(ErrorWidget)).message, 'Could not find remote widget named widget in a, possibly because some dependencies were missing: b');
  });

  testWidgets('Missing libraries in specified widget', (WidgetTester tester) async {
    final Runtime runtime = Runtime();
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(tester.widget<ErrorWidget>(find.byType(ErrorWidget)).message, 'Could not find remote widget named widget in a, possibly because some dependencies were missing: a');
  });

  testWidgets('Missing libraries in import via dependency', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['a']), parseLibraryFile('''
        import b;
        widget widget = test();
      '''));
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(tester.widget<ErrorWidget>(find.byType(ErrorWidget)).message, 'Could not find remote widget named test in a, possibly because some dependencies were missing: b');
  });

  testWidgets('Missing widget', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['a']), parseLibraryFile(''));
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['a']), 'widget'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(tester.widget<ErrorWidget>(find.byType(ErrorWidget)).message, 'Could not find remote widget named widget in a.');
  });

  testWidgets('Runtime', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { level: 0 } = inner(level: state.level);
      widget inner { level: 1 } = ColoredBox(color: args.level);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000000));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { level: 0 } = inner(level: state.level);
      widget inner { level: 1 } = ColoredBox(color: state.level);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));
  });

  testWidgets('Runtime', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { level: 0 } = switch state.level {
        0: ColoredBox(color: 2),
      };
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000002));
  });

  testWidgets('Runtime', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { level: 0 } = GestureDetector(
        onTap: set state.level = 1,
        child: ColoredBox(color: state.level),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000000));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));
  });

  testWidgets('DynamicContent', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = ColoredBox(color: data.color.value);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));

    data.update('color', json.decode('{"value":1}'));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));

    data.update('color', parseDataFile('{value:2}'));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000002));

    data.update('color', decodeDataBlob(Uint8List.fromList(<int>[
      0xFE, 0x52, 0x57, 0x44, // signature
      0x07, // data is a map
      0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ...which has one key
      0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ...which has five letters
      0x76, 0x61, 0x6c, 0x75, 0x65, // ...which are "value"
      0x02, // and the value is an integer
      0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ...which is the number 2
    ])));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000002));
  });

  testWidgets('DynamicContent', (WidgetTester tester) async {
    final DynamicContent data = DynamicContent(<String, Object?>{'hello': 'world'});
    expect(data.toString(), 'DynamicContent({hello: world})');
  });

  testWidgets('binding loop variables', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent(<String, Object?>{
      'list': <Object?>[
        <String, Object?>{
          'a': <String, Object?>{ 'b': 0xEE },
          'c': <Object?>[ 0xDD ],
        },
      ],
    });
    final List<String> eventLog = <String>[];
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
        onEvent: (String eventName, DynamicMap eventArguments) {
          eventLog.add('$eventName $eventArguments');
        },
      ),
    );
    expect(find.byType(RemoteWidget), findsOneWidget);
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));
    expect(find.byType(ErrorWidget), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify = ColoredBox(color: args.value.0.q.0);
      widget root = verify(
        value: [
          ...for v in data.list: {
            q: [ v.a.b ],
          },
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000EE));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify = ColoredBox(color: args.value.0.q.0);
      widget root = verify(
        value: [
          ...for v in data.list: {
            q: [ ...for w in v.c: w ],
          },
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000DD));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify = ColoredBox(color: args.value.0.q);
      widget root = verify(
        value: [
          ...for v in data.list: {
            q: switch v.a.b {
              0xEE: 0xCC,
              default: 0xFF,
            },
          },
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000CC));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify { state: true } = ColoredBox(color: args.value.c.0);
      widget remote = SizedBox(child: args.corn.0);
      widget root = remote(
        corn: [
          ...for v in data.list:
            verify(value: v),
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000DD));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify { state: true } = ColoredBox(color: args.value);
      widget remote = SizedBox(child: args.corn.0);
      widget root = remote(
        corn: [
          ...for v in data.list:
            verify(value: switch v.c.0 {
              0: 0xFF000000,
              0xDD: 0xFF0D0D0D,
              default: v,
            }),
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF0D0D0D));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify { state: true } = switch args.value.c.0 {
        0xDD: ColoredBox(color: 0xFF0D0D0D),
        default: ColoredBox(color: args.value),
      };
      widget remote = SizedBox(child: args.corn.0);
      widget root = remote(
        corn: [
          ...for v in data.list:
            verify(value: v),
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF0D0D0D));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify { state: true } = GestureDetector(
        onTap: event 'test' { test: args.value.a.b },
        child: ColoredBox(),
      );
      widget remote = SizedBox(child: args.corn.0);
      widget root = remote(
        corn: [
          ...for v in data.list:
            verify(value: v),
        ],
      );
    '''));
    expect(eventLog, isEmpty);
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(eventLog, <String>['test {test: ${0xEE}}']);
    eventLog.clear();

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget verify { state: 0x00 } = GestureDetector(
        onTap: set state.state = args.value.a.b,
        child: ColoredBox(color: switch state.state {
          0x00: 0xFF000001,
          0xEE: 0xFF000002,
        }),
      );
      widget remote = SizedBox(child: args.corn.0);
      widget root = remote(
        corn: [
          ...for v in data.list:
            verify(value: v),
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000001));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000002));

  });

  testWidgets('list lookup of esoteric values', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = test(list: ['A'], loop: [...for b in ["B", "C"]: b]);
      widget test = Text(
        textDirection: "ltr",
        text: [
          '>',
          ...for a in args.list: a,
          ...for b in args.loop: b,
          '<',
        ],
      );
    '''));
    await tester.pump();
    expect(find.text('>ABC<'), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = Text(
        textDirection: "ltr",
        text: [
          '>',
          ...for a in root(): a,
          '<',
        ],
      );
    '''));
    await tester.pump();
    expect(find.text('><'), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = test(list: [test()]);
      widget test = Text(
        textDirection: "ltr",
        text: [
          '>',
          ...for a in args.list: a,
          '<',
        ],
      );
    '''));
    await tester.pump();
    expect(find.text('><'), findsOneWidget);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { list: [ 0x01 ] } = GestureDetector(
        onTap: set state.list = [ 0x02, 0x03 ],
        child: Column(
          children: [
            ...for v in state.list:
              SizedBox(height: 10.0, width: 10.0, child: ColoredBox(color: v)),
          ],
        ),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.firstWidget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000002));
    expect(find.byType(ColoredBox), findsNWidgets(2));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = Column(
        children: [
          ...for v in switch 0 {
            0: [ColoredBox(color: 0x00000001)],
            default: [ColoredBox(color: 0xFFFF0000)],
          }: v,
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = Column(
        children: [
          ...for v in {
            a: [ColoredBox(color: 0x00000001)],
            b: [ColoredBox(color: 0xFFFF0000)],
          }: v,
        ],
      );
    '''));
    await tester.pump();
    expect(find.byType(ColoredBox), findsNothing);

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = test(
        list: [...for w in [ColoredBox(color: 0xFF00FF00)]: w],
      );
      widget test = Column(
        children: [
          ...for v in args.list: v,
        ],
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF00FF00));
  });

  testWidgets('data lookup', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent(<String, Object?>{
      'map': <String, Object?>{ 'list': <Object?>[ 0xAB ] },
    });
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = test(list: data.map.list);
      widget test = ColoredBox(color: args.list.0);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000AB));
  });

  testWidgets('args lookup', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = test1(map: { 'list': [ 0xAC ] });
      widget test1 = test2(list: args.map.list);
      widget test2 = ColoredBox(color: args.list.0);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000AC));
  });

  testWidgets('state lookup', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { map: { 'list': [ 0xAD ] } } = test(list: state.map.list);
      widget test = ColoredBox(color: args.list.0);
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x000000AD));
  });

  testWidgets('switch', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = ColoredBox(color: switch data.a.b {
        0: 0x11111111,
        default: 0x22222222,
      });
    '''));
    data.update('a', parseDataFile('{ b: 1 }'));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x22222222));
    data.update('a', parseDataFile('{ b: 0 }'));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x11111111));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = switch true {};
    '''));
    await tester.pump();
    expect(tester.takeException().toString(), 'Switch in test:root did not resolve to a widget (got <missing>).');
  });

  testWidgets('events with arguments', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    final List<String> eventLog = <String>[];
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
        onEvent: (String eventName, DynamicMap eventArguments) {
          eventLog.add('$eventName $eventArguments');
        },
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = GestureDetector(
        onTap: event 'tap' {
          list: [...for a in [0,1]: a],
        },
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));
    expect(eventLog, isEmpty);
    await tester.tap(find.byType(ColoredBox));
    expect(eventLog, <String>['tap {list: [0, 1]}']);
    eventLog.clear();

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root = GestureDetector(
        onTap: [ event 'tap' { a: 1 }, event 'tap' { a: 2 }, event 'final tap' { } ],
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));
    expect(eventLog, isEmpty);
    await tester.tap(find.byType(ColoredBox));
    expect(eventLog, <String>['tap {a: 1}', 'tap {a: 2}', 'final tap {}']);
    eventLog.clear();
  });

  testWidgets('_CurriedWidget toStrings', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget stateless = ColoredBox(color: 0xAA);
      widget stateful { test: false } = ColoredBox(color: 0xBB);
      widget switchy = switch true { default: ColoredBox(color: 0xCC) };
    '''));
    expect(
      (runtime.build(
        tester.element(find.byType(Container)),
        const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'stateless'),
        data,
        (String eventName, DynamicMap eventArguments) {},
      ) as dynamic).curriedWidget.toString(),
      'core:ColoredBox {} {color: 170}',
    );
    expect(
      (runtime.build(
        tester.element(find.byType(Container)),
        const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'stateful'),
        data,
        (String eventName, DynamicMap eventArguments) {},
      ) as dynamic).curriedWidget.toString(),
      'test:stateful {test: false} {} = core:ColoredBox {} {color: 187}',
    );
    expect(
      (runtime.build(
        tester.element(find.byType(Container)),
        const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'switchy'),
        data,
        (String eventName, DynamicMap eventArguments) {},
      ) as dynamic).curriedWidget.toString(),
      'test:switchy {} {} = switch true {null: core:ColoredBox {} {color: 204}}',
    );
  });

  testWidgets('state setting', (WidgetTester tester) async {
    final Runtime runtime = Runtime()
      ..update(const LibraryName(<String>['core']), createCoreWidgets());
    final DynamicContent data = DynamicContent();
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['test']), 'root'),
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: 0 } = GestureDetector(
        onTap: set state.b = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), 'b does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: 0 } = GestureDetector(
        onTap: set state.0 = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), '0 does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: [] } = GestureDetector(
        onTap: set state.a.b = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), 'a.b does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: [] } = GestureDetector(
        onTap: set state.a.0 = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), 'a.0 does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: true } = GestureDetector(
        onTap: set state.a.0 = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), 'a.0 does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: true } = GestureDetector(
        onTap: set state.a.b = 0,
        child: ColoredBox(),
      );
    '''));
    await tester.pump();
    await tester.tap(find.byType(ColoredBox));
    expect(tester.takeException().toString(), 'a.b does not identify existing state.');

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: { b: 0 } } = GestureDetector(
        onTap: set state.a = 15,
        child: ColoredBox(color: state.a),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x0000000F));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: [ 0 ] } = GestureDetector(
        onTap: set state.a = 10,
        child: ColoredBox(color: state.a),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xFF000000));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x0000000A));

    runtime.update(const LibraryName(<String>['test']), parseLibraryFile('''
      import core;
      widget root { a: [ [ 1 ] ] } = GestureDetector(
        onTap: set state.a.0.0 = 11,
        child: ColoredBox(color: state.a.0.0),
      );
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x00000001));
    await tester.tap(find.byType(ColoredBox));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0x0000000B));
  });

  testWidgets('DataSource', (WidgetTester tester) async {
    final Runtime runtime = Runtime();
    final DynamicContent data = DynamicContent();
    final List<String> eventLog = <String>[];
    await tester.pumpWidget(
      RemoteWidget(
        runtime: runtime,
        data: data,
        widget: const FullyQualifiedWidgetName(LibraryName(<String>['remote']), 'test'),
        onEvent: (String name, DynamicMap arguments) {
          eventLog.add('$name $arguments');
        },
      ),
    );
    expect(tester.takeException().toString(), contains('Could not find remote widget named'));

    runtime.update(const LibraryName(<String>['local']), LocalWidgetLibrary(<String, LocalWidgetBuilder>{
      'Test': (BuildContext context, DataSource source) {
        expect(source.isList(<Object>['a']), isFalse);
        expect(source.isList(<Object>['b']), isTrue);
        expect(source.length(<Object>['b']), 1);
        expect(source.child(<Object>['missing']), isA<ErrorWidget>());
        expect(tester.takeException().toString(), 'Not a widget at [missing] (got <missing>) for local:Test.');
        expect(source.childList(<Object>['a']), <Matcher>[isA<ErrorWidget>()]);
        expect(tester.takeException().toString(), 'Not a widget list at [a] (got 0) for local:Test.');
        expect(source.childList(<Object>['b']), <Matcher>[isA<ErrorWidget>()]);
        expect(tester.takeException().toString(), 'Not a widget at [b] (got 1) for local:Test.');
        expect(eventLog, isEmpty);
        source.voidHandler(<Object>['callback'], <String, Object?>{ 'extra': 4, 'b': 3 })!();
        expect(eventLog, <String>['e {a: 1, b: 3, extra: 4}']);
        return const ColoredBox(color: Color(0xAABBCCDD));
      },
    }));
    runtime.update(const LibraryName(<String>['remote']), parseLibraryFile('''
      import local;
      widget test = Test(a: 0, b: [1], callback: event 'e' { a: 1, b: 2 });
    '''));
    await tester.pump();
    expect(tester.widget<ColoredBox>(find.byType(ColoredBox)).color, const Color(0xAABBCCDD));
    bool tested = false;
    tester.element(find.byType(ColoredBox)).visitAncestorElements((Element node) {
      expect(node.toString(), equalsIgnoringHashCodes('_Widget(state: _WidgetState#00000(name: "local:Test"))'));
      tested = true;
      return false;
    });
    expect(tested, isTrue);
  });
}