// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:convert' show jsonEncode;
import 'dart:core' hide Duration;

import 'package:fixnum/fixnum.dart';
import 'package:protobuf/protobuf.dart';
import 'package:test/test.dart';

import 'gen/entity.pb.dart';
import 'gen/enum_name.pb.dart';
import 'gen/google/protobuf/any.pb.dart';
import 'gen/google/protobuf/duration.pb.dart';
import 'gen/google/protobuf/empty.pb.dart';
import 'gen/google/protobuf/field_mask.pb.dart';
import 'gen/google/protobuf/struct.pb.dart';
import 'gen/google/protobuf/timestamp.pb.dart';
import 'gen/google/protobuf/unittest.pb.dart';
import 'gen/google/protobuf/unittest_well_known_types.pb.dart';
import 'gen/google/protobuf/wrappers.pb.dart';
import 'gen/map_field.pb.dart';
import 'gen/nested_any.pb.dart';
import 'gen/oneof.pb.dart';
import 'oneof_test.dart';
import 'src/test_util.dart';

final testAllTypesJson = {
  'optionalInt32': 101,
  'optionalInt64': '102',
  'optionalUint32': 103,
  'optionalUint64': '104',
  'optionalSint32': 105,
  'optionalSint64': '106',
  'optionalFixed32': 107,
  'optionalFixed64': '108',
  'optionalSfixed32': 109,
  'optionalSfixed64': '110',
  'optionalFloat': 111.0,
  'optionalDouble': 112.0,
  'optionalBool': true,
  'optionalString': '115',
  'optionalBytes': 'MTE2',
  'optionalgroup': {'a': 117},
  'optionalNestedMessage': {'bb': 118},
  'optionalForeignMessage': {'c': 119},
  'optionalImportMessage': {'d': 120},
  'optionalNestedEnum': 'BAZ',
  'optionalForeignEnum': 'FOREIGN_BAZ',
  'optionalImportEnum': 'IMPORT_BAZ',
  'optionalStringPiece': '124',
  'optionalCord': '125',
  'repeatedInt32': [201, 301],
  'repeatedInt64': ['202', '302'],
  'repeatedUint32': [203, 303],
  'repeatedUint64': ['204', '304'],
  'repeatedSint32': [205, 305],
  'repeatedSint64': ['206', '306'],
  'repeatedFixed32': [207, 307],
  'repeatedFixed64': ['208', '308'],
  'repeatedSfixed32': [209, 309],
  'repeatedSfixed64': ['210', '310'],
  'repeatedFloat': [211.0, 311.0],
  'repeatedDouble': [212.0, 312.0],
  'repeatedBool': [true, false],
  'repeatedString': ['215', '315'],
  'repeatedBytes': ['MjE2', 'MzE2'],
  'repeatedgroup': [
    {'a': 217},
    {'a': 317},
  ],
  'repeatedNestedMessage': [
    {'bb': 218},
    {'bb': 318},
  ],
  'repeatedForeignMessage': [
    {'c': 219},
    {'c': 319},
  ],
  'repeatedImportMessage': [
    {'d': 220},
    {'d': 320},
  ],
  'repeatedNestedEnum': ['BAR', 'BAZ'],
  'repeatedForeignEnum': ['FOREIGN_BAR', 'FOREIGN_BAZ'],
  'repeatedImportEnum': ['IMPORT_BAR', 'IMPORT_BAZ'],
  'repeatedStringPiece': ['224', '324'],
  'repeatedCord': ['225', '325'],
  'defaultInt32': 401,
  'defaultInt64': '402',
  'defaultUint32': 403,
  'defaultUint64': '404',
  'defaultSint32': 405,
  'defaultSint64': '406',
  'defaultFixed32': 407,
  'defaultFixed64': '408',
  'defaultSfixed32': 409,
  'defaultSfixed64': '410',
  'defaultFloat': 411.0,
  'defaultDouble': 412.0,
  'defaultBool': false,
  'defaultString': '415',
  'defaultBytes': 'NDE2',
  'defaultNestedEnum': 'FOO',
  'defaultForeignEnum': 'FOREIGN_FOO',
  'defaultImportEnum': 'IMPORT_FOO',
  'defaultStringPiece': '424',
  'defaultCord': '425',
};

void main() {
  test('toProto3Json works', () {
    final proto =
        TopEntity()
          ..id = Int64(1)
          ..stringValue = 'foo'
          ..strings.addAll(['test', 'repeated', 'field'])
          ..anyValue = Any.pack(
            SubEntity()
              ..id = Int64(4)
              ..anyValue = Any.pack(SubSubEntity()..id = Int64(5)),
          )
          ..sub =
              (SubEntity()
                ..id = Int64(2)
                ..subSub = (SubSubEntity()..id = Int64(3)));
    final typeRegistry = TypeRegistry([SubEntity(), SubSubEntity()]);
    final json = proto.toProto3Json(typeRegistry: typeRegistry);
    expect(
      proto ==
          (TopEntity()..mergeFromProto3Json(json, typeRegistry: typeRegistry)),
      true,
    );
  });

  group('encode', () {
    test('testOutput', () {
      expect(getAllSet().toProto3Json(), testAllTypesJson);
    });

    test('testFrozenOutput', () {
      expect(getAllSet().freeze().toProto3Json(), testAllTypesJson);
    });

    test('testUnsignedOutput', () {
      final message = TestAllTypes();
      // These values are selected because they are large enough to set the sign bit.
      message.optionalUint64 = Int64.parseHex('f0000000ffff0000');
      message.optionalFixed64 = Int64.parseHex('f0000000ffff0001');

      expect(message.toProto3Json(), {
        'optionalUint64': '17293822573397606400',
        'optionalFixed64': '-1152921500311945215',
      });
    });

    test('doubles', () {
      void testValue(double value, Object expected) {
        final message =
            TestAllTypes()
              ..defaultFloat = value
              ..defaultDouble = value;
        expect(
          (message.toProto3Json() as Map)['defaultDouble'],
          equals(expected),
        );
      }

      testValue(-0.0, -0.0);
      testValue(0.0, 0);
      testValue(1.0, 1);
      testValue(-1.0, -1);
      testValue(double.nan, 'NaN');
      testValue(double.infinity, 'Infinity');
      testValue(double.negativeInfinity, '-Infinity');
    });

    test('map value', () {
      final message =
          TestMap()
            ..int32ToInt32Field[32] = 32
            ..int32ToStringField[0] = 'foo'
            ..int32ToStringField[1] = 'bar'
            ..int32ToBytesField[-1] = [1, 2, 3]
            ..int32ToEnumField[1] = TestMap_EnumValue.BAZ
            ..int32ToMessageField[21] =
                (TestMap_MessageValue()
                  ..value = 2
                  ..secondValue = 3)
            ..stringToInt32Field['key'] = -1
            ..uint32ToInt32Field[0] = 0
            ..int64ToInt32Field[Int64.ZERO] = 0
            ..int64ToInt32Field[Int64.ONE] = 1
            ..int64ToInt32Field[-Int64.ONE] = -1
            ..int64ToInt32Field[Int64.MIN_VALUE] = -2
            ..int64ToInt32Field[Int64.MAX_VALUE] = 2
            ..uint64ToInt32Field[Int64.MIN_VALUE] = -2;
      expect(message.toProto3Json(), {
        'int32ToInt32Field': {'32': 32},
        'int32ToStringField': {'0': 'foo', '1': 'bar'},
        'int32ToBytesField': {'-1': 'AQID'},
        'int32ToEnumField': {'1': 'BAZ'},
        'int32ToMessageField': {
          '21': {'value': 2, 'secondValue': 3},
        },
        'stringToInt32Field': {'key': -1},
        'uint32ToInt32Field': {'0': 0},
        'int64ToInt32Field': {
          '0': 0,
          '1': 1,
          '-1': -1,
          '-9223372036854775808': -2,
          '9223372036854775807': 2,
        },
        'uint64ToInt32Field': {'9223372036854775808': -2},
      });
    });

    test('Timestamp', () {
      expect(
        Timestamp.fromDateTime(
          DateTime.utc(1969, 7, 20, 20, 17, 40),
        ).toProto3Json(),
        '1969-07-20T20:17:40Z',
      );
      expect(
        Timestamp.fromDateTime(DateTime.utc(9)).toProto3Json(),
        '0009-01-01T00:00:00Z',
      );
      expect(
        Timestamp.fromDateTime(DateTime.utc(420)).toProto3Json(),
        '0420-01-01T00:00:00Z',
      );
      expect(
        () => Timestamp.fromDateTime(DateTime.utc(42001)).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        () => Timestamp.fromDateTime(DateTime.utc(-1)).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        Timestamp.fromDateTime(
          DateTime.utc(9999, 12, 31, 23, 59, 59),
        ).toProto3Json(),
        '9999-12-31T23:59:59Z',
      );

      expect(
        (Timestamp()..nanos = 1).toProto3Json(),
        '1970-01-01T00:00:00.000000001Z',
      );
      expect(
        (Timestamp()..nanos = 8200000).toProto3Json(),
        '1970-01-01T00:00:00.008200Z',
      );
      expect(
        () => (Timestamp()..nanos = -8200000).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        () => (Timestamp()..nanos = -8200000).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        () => (Timestamp()..nanos = 1000000000).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
    });

    test('Duration', () {
      expect(
        (Duration()
              ..seconds = Int64(0)
              ..nanos = 0)
            .toProto3Json(),
        '0s',
      );
      expect(
        (Duration()
              ..seconds = Int64(10)
              ..nanos = 0)
            .toProto3Json(),
        '10s',
      );
      expect(
        (Duration()
              ..seconds = Int64(10)
              ..nanos = 1)
            .toProto3Json(),
        '10.000000001s',
      );
      expect(
        (Duration()
              ..seconds = Int64(10)
              ..nanos = 10)
            .toProto3Json(),
        '10.00000001s',
      );
      expect(
        (Duration()
              ..seconds = -Int64(1)
              ..nanos = -99000)
            .toProto3Json(),
        '-1.000099s',
      );
    });

    test('Any', () {
      expect(
        Any.pack(
          TestAllTypes()..optionalFixed64 = Int64(100),
        ).toProto3Json(typeRegistry: TypeRegistry([TestAllTypes()])),
        {
          '@type': 'type.googleapis.com/protobuf_unittest.TestAllTypes',
          'optionalFixed64': '100',
        },
      );
      expect(
        Any.pack(
          Timestamp.fromDateTime(DateTime.utc(1969, 7, 20, 20, 17)),
        ).toProto3Json(typeRegistry: TypeRegistry([Timestamp()])),
        {
          '@type': 'type.googleapis.com/google.protobuf.Timestamp',
          'value': '1969-07-20T20:17:00Z',
        },
      );
      expect(
        () =>
            Any.pack(
              Timestamp.fromDateTime(DateTime(1969, 7, 20, 20, 17)),
            ).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
    });

    test('Nested Any', () {
      final packedOne = Any.pack(AnyMessage1()..value = '1');
      final packedTwo = Any.pack(
        AnyMessage2()
          ..value = '2'
          ..anyField2 = packedOne,
      );
      expect(
        packedTwo.toProto3Json(
          typeRegistry: TypeRegistry([AnyMessage1(), AnyMessage2()]),
        ),
        {
          'anyField2': {
            'value': '1',
            '@type': 'type.googleapis.com/nested_any.AnyMessage1',
          },
          'value': '2',
          '@type': 'type.googleapis.com/nested_any.AnyMessage2',
        },
      );
    });

    test('struct', () {
      final s =
          Struct()
            ..fields['null'] = (Value()..nullValue = NullValue.NULL_VALUE)
            ..fields['number'] = (Value()..numberValue = 22.3)
            ..fields['string'] = (Value()..stringValue = 'foo')
            ..fields['bool'] = (Value()..boolValue = false)
            ..fields['struct'] =
                (Value()
                  ..structValue =
                      (Struct()..fields['a'] = (Value()..numberValue = 0.0)))
            ..fields['list'] =
                (Value()
                  ..listValue =
                      (ListValue()
                        ..values.addAll([
                          Value()..structValue = Struct(),
                          Value()..listValue = ListValue(),
                          Value()..stringValue = 'why',
                        ])));
      expect(s.toProto3Json(), {
        'null': null,
        'number': 22.3,
        'string': 'foo',
        'bool': false,
        'struct': {'a': 0},
        'list': [{}, [], 'why'],
      });
      expect(
        () => Value().toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
    });

    test('empty', () {
      expect(Empty().toProto3Json(), {});
    });

    test('wrapper types', () {
      final t =
          TestWellKnownTypes()
            ..doubleField = (DoubleValue()..value = 10.01)
            ..floatField = (FloatValue()..value = 3.0)
            ..int64Field = (Int64Value()..value = Int64.MIN_VALUE)
            ..uint64Field = (UInt64Value()..value = Int64.MIN_VALUE)
            ..int32Field = (Int32Value()..value = 101)
            ..uint32Field = (UInt32Value()..value = 102)
            ..boolField = (BoolValue()..value = false)
            ..stringField = (StringValue()..value = 'Pop')
            ..bytesField = (BytesValue()..value = [8, 9, 10]);
      expect(t.toProto3Json(), {
        'doubleField': 10.01,
        'floatField': 3,
        'int64Field': '-9223372036854775808',
        'uint64Field': '9223372036854775808',
        'int32Field': 101,
        'uint32Field': 102,
        'boolField': false,
        'stringField': 'Pop',
        'bytesField': 'CAkK',
      });
    });

    test('field mask', () {
      expect(FieldMask().toProto3Json(), '');
      expect(
        (FieldMask()..paths.addAll(['foo_bar_baz'])).toProto3Json(),
        'fooBarBaz',
      );
      expect(
        (FieldMask()..paths.addAll(['foo_bar', 'zop'])).toProto3Json(),
        'fooBar,zop',
      );
      expect(
        () => (FieldMask()..paths.add('foo_3_bar')).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        () => (FieldMask()..paths.add('foo__bar')).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
      expect(
        () => (FieldMask()..paths.add('fooBar')).toProto3Json(),
        throwsA(TypeMatcher<ArgumentError>()),
      );
    });
  });

  group('decode', () {
    Matcher parseFailure(List<String> expectedPath) => throwsA(
      predicate((e) {
        if (e is FormatException) {
          final pathExpression =
              RegExp(r'root(\["[^"]*"]*\])*').firstMatch(e.message)![0]!;
          final actualPath =
              RegExp(
                r'\["([^"]*)"\]',
              ).allMatches(pathExpression).map((match) => match[1]).toList();
          if (actualPath.length != expectedPath.length) return false;
          for (var i = 0; i < actualPath.length; i++) {
            if (actualPath[i] != expectedPath[i]) return false;
          }
          return true;
        }
        return false;
      }),
    );

    test('Nulls', () {
      final decoded =
          TestAllTypes()..mergeFromProto3Json({'defaultString': null});
      expect(decoded, TestAllTypes());
    });
    test('decode TestAllTypes', () {
      final decoded = TestAllTypes()..mergeFromProto3Json(testAllTypesJson);
      expect(decoded, getAllSet());
    });
    test('Type expectations', () {
      expect(
        () => TestAllTypes()..mergeFromProto3Json({1: 1}),
        parseFailure([]),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalBool': 1}),
        parseFailure(['optionalBool']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalBytes': 1}),
        parseFailure(['optionalBytes']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalBytes': '()'}),
        parseFailure(['optionalBytes']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalInt32': '()'}),
        parseFailure(['optionalInt32']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalInt32': 20.4}),
        parseFailure(['optionalInt32']),
      );
      expect(
        TestAllTypes()..mergeFromProto3Json({'optionalInt32': '28'}),
        TestAllTypes()..optionalInt32 = 28,
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalInt64': '()'}),
        parseFailure(['optionalInt64']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalInt64': 20.4}),
        parseFailure(['optionalInt64']),
      );
      expect(
        TestAllTypes()..mergeFromProto3Json({'optionalInt64': '28'}),
        TestAllTypes()..optionalInt64 = Int64(28),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalDouble': 'a'}),
        parseFailure(['optionalDouble']),
      );
      expect(
        TestAllTypes()..mergeFromProto3Json({'optionalDouble': 28}),
        TestAllTypes()..optionalDouble = 28.0,
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalDouble': 'a'}),
        parseFailure(['optionalDouble']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalString': 11}),
        parseFailure(['optionalString']),
      );
      expect(
        () =>
            TestAllTypes()..mergeFromProto3Json({'optionalEnum': 'wrongValue'}),
        parseFailure(['optionalEnum']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalEnum': []}),
        parseFailure(['optionalEnum']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'optionalNestedEnum': 100}),
        parseFailure(['optionalNestedEnum']),
      );
      expect(
        TestAllTypes()..mergeFromProto3Json({'optionalNestedEnum': 1}),
        TestAllTypes()
          ..optionalNestedEnum = TestAllTypes_NestedEnum.valueOf(1)!,
      );
      expect(
        TestAllTypes()..mergeFromProto3Json({'repeatedBool': null}),
        TestAllTypes(),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json({'repeatedBool': 100}),
        parseFailure(['repeatedBool']),
      );
      expect(
        () =>
            TestAllTypes()..mergeFromProto3Json({
              'repeatedBool': [true, false, 1],
            }),
        parseFailure(['repeatedBool', '2']),
      );
      expect(
        () => TestAllTypes()..mergeFromProto3Json(Object()),
        parseFailure([]),
      );
    });

    test('merging behavior', () {
      final t =
          TestAllTypes()
            ..optionalForeignMessage = ForeignMessage()
            ..repeatedForeignMessage.add(ForeignMessage()..c = 1);
      final f = t.optionalForeignMessage;
      expect(
        t..mergeFromProto3Json({
          'repeatedForeignMessage': [
            {'c': 2},
          ],
          'optionalForeignMessage': {'c': 2},
        }),
        TestAllTypes()
          ..optionalForeignMessage = (ForeignMessage()..c = 2)
          ..repeatedForeignMessage.addAll([
            ForeignMessage()..c = 1,
            ForeignMessage()..c = 2,
          ]),
      );
      expect(f, ForeignMessage()..c = 2);
    });

    test('names_with_underscores', () {
      expect(
        TestAllTypes()..mergeFromProto3Json({
          'optional_foreign_message': {'c': 1},
        }),
        TestAllTypes()..optionalForeignMessage = (ForeignMessage()..c = 1),
      );
      expect(
        () =>
            TestAllTypes()..mergeFromProto3Json({
              'optional_foreign_message': {'c': 1},
            }, supportNamesWithUnderscores: false),
        parseFailure(['optional_foreign_message']),
      );
    });
    test('permissive enums', () {
      final sparseB = SparseEnumMessage()..sparseEnum = TestSparseEnum.SPARSE_B;
      expect(
        SparseEnumMessage()..mergeFromProto3Json({'sparseEnum': 'SPARSE_B'}),
        sparseB,
      );
      expect(
        () =>
            SparseEnumMessage()
              ..mergeFromProto3Json({'sparseEnum': 'sparse_b'}),
        parseFailure(['sparseEnum']),
      );
      expect(
        () =>
            SparseEnumMessage()
              ..mergeFromProto3Json({'sparseEnum': 'SPARSE-B'}),
        parseFailure(['sparseEnum']),
      );
      expect(
        () =>
            SparseEnumMessage()
              ..mergeFromProto3Json({'sparseEnum': 'sPaRsE_b'}),
        parseFailure(['sparseEnum']),
      );
      expect(
        () =>
            SparseEnumMessage()..mergeFromProto3Json({'sparseEnum': 'sparseB'}),
        parseFailure(['sparseEnum']),
      );
      expect(
        () =>
            SparseEnumMessage()..mergeFromProto3Json({'sparseEnum': 'spaRSEB'}),
        parseFailure(['sparseEnum']),
      );

      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'x'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'X'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'x_'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'X_'}),
        parseFailure(['a']),
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_x'}),
        AMessage()..a = A.x_,
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': '_X'}),
        parseFailure(['a']),
      );

      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'y'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'Y'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'y_'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'Y_'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': '_y'}),
        parseFailure(['a']),
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_Y'}),
        AMessage()..a = A.Y_,
      );

      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'z'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'Z'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'z_'}),
        parseFailure(['a']),
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'Z_'}),
        AMessage()..a = A.Z_,
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': '_z'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': '_Z'}),
        parseFailure(['a']),
      );

      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'a_a'}),
        parseFailure(['a']),
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'A_A'}),
        AMessage()..a = A.A_A,
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'aA'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'AA'}),
        parseFailure(['a']),
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'b_b'}),
        AMessage()..a = A.b_b,
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'B_B'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'bB'}),
        parseFailure(['a']),
      );
      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'BB'}),
        parseFailure(['a']),
      );

      expect(
        () => AMessage()..mergeFromProto3Json({'a': 'CAMEL_CASE'}),
        parseFailure(['a']),
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'camelCase'}),
        AMessage()..a = A.camelCase,
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'x'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'X'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'x_'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'X_'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_x'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_X'}, permissiveEnums: true),
        AMessage()..a = A.x_,
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'y'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'Y'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'y_'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'Y_'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_y'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_Y'}, permissiveEnums: true),
        AMessage()..a = A.Y_,
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'z'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'Z'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'z_'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'Z_'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_z'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': '_Z'}, permissiveEnums: true),
        AMessage()..a = A.Z_,
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'a_a'}, permissiveEnums: true),
        AMessage()..a = A.A_A,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'A_A'}, permissiveEnums: true),
        AMessage()..a = A.A_A,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'aA'}, permissiveEnums: true),
        AMessage()..a = A.A_A,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'AA'}, permissiveEnums: true),
        AMessage()..a = A.A_A,
      );

      expect(
        AMessage()..mergeFromProto3Json({'a': 'b_b'}, permissiveEnums: true),
        AMessage()..a = A.b_b,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'B_B'}, permissiveEnums: true),
        AMessage()..a = A.b_b,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'bB'}, permissiveEnums: true),
        AMessage()..a = A.b_b,
      );
      expect(
        AMessage()..mergeFromProto3Json({'a': 'BB'}, permissiveEnums: true),
        AMessage()..a = A.b_b,
      );

      expect(
        AMessage()
          ..mergeFromProto3Json({'a': 'CAMEL_CASE'}, permissiveEnums: true),
        AMessage()..a = A.camelCase,
      );
      expect(
        AMessage()
          ..mergeFromProto3Json({'a': 'camelCase'}, permissiveEnums: true),
        AMessage()..a = A.camelCase,
      );

      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'sparse_b',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'SPARSE-B',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'S-P-A-R-S-E-B',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'sPaRsE_b',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'sparseB',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        SparseEnumMessage()..mergeFromProto3Json({
          'sparseEnum': 'spaRSEB',
        }, permissiveEnums: true),
        sparseB,
      );
      expect(
        () =>
            Any()..mergeFromProto3Json({
              '@type':
                  'type.googleapis.com/protobuf_unittest.SparseEnumMessage',
              'sparseEnum': 'SPARSEB',
            }, typeRegistry: TypeRegistry([SparseEnumMessage()])),
        parseFailure(['sparseEnum']),
      );
      expect(
        Any()..mergeFromProto3Json(
          {
            '@type': 'type.googleapis.com/protobuf_unittest.SparseEnumMessage',
            'sparseEnum': 'SPARSEB',
          },
          typeRegistry: TypeRegistry([SparseEnumMessage()]),
          permissiveEnums: true,
        ),
        Any.pack(sparseB),
        reason: 'Parsing options are passed through Any messages',
      );
    });

    test('map value', () {
      final expected =
          TestMap()
            ..int32ToInt32Field[32] = 32
            ..int32ToStringField[0] = 'foo'
            ..int32ToStringField[1] = 'bar'
            ..int32ToBytesField[-1] = [1, 2, 3]
            ..int32ToEnumField[1] = TestMap_EnumValue.BAZ
            ..int32ToMessageField[21] =
                (TestMap_MessageValue()
                  ..value = 2
                  ..secondValue = 3)
            ..stringToInt32Field['key'] = -1
            ..uint32ToInt32Field[0] = 0
            ..int64ToInt32Field[Int64.ZERO] = 0
            ..int64ToInt32Field[Int64.ONE] = 1
            ..int64ToInt32Field[-Int64.ONE] = -1
            ..int64ToInt32Field[Int64.MIN_VALUE] = -2
            ..int64ToInt32Field[Int64.MAX_VALUE] = 2
            ..uint64ToInt32Field[Int64.MIN_VALUE] = -2;
      expect(
        TestMap()..mergeFromProto3Json({
          'int32ToInt32Field': {'32': 32},
          'int32ToStringField': {'0': 'foo', '1': 'bar'},
          'int32ToBytesField': {'-1': 'AQID'},
          'int32ToEnumField': {'1': 'BAZ'},
          'int32ToMessageField': {
            '21': {'value': 2, 'secondValue': 3},
          },
          'stringToInt32Field': {'key': -1},
          'uint32ToInt32Field': {'0': 0},
          'int64ToInt32Field': {
            '0': 0,
            '1': 1,
            '-1': -1,
            '-9223372036854775808': -2,
            '9223372036854775807': 2,
          },
          'uint64ToInt32Field': {'9223372036854775808': -2},
        }),
        expected,
      );
      expect(() => TestMap()..mergeFromProto3Json([]), parseFailure([]));
      expect(
        () =>
            TestMap()..mergeFromProto3Json({
              'int32ToInt32Field': {'32': 'a'},
            }),
        parseFailure(['int32ToInt32Field', '32']),
      );
      expect(
        () =>
            TestMap()..mergeFromProto3Json({
              'int32ToInt32Field': {'2147483648': 1},
            }),
        parseFailure(['int32ToInt32Field', '2147483648']),
      );
      expect(
        () =>
            TestMap()..mergeFromProto3Json({
              'uint32ToInt32Field': {'-32': 21},
            }),
        parseFailure(['uint32ToInt32Field', '-32']),
      );
      expect(
        () =>
            TestMap()..mergeFromProto3Json({
              'uint32ToInt32Field': {'4294967296': 21},
            }),
        parseFailure(['uint32ToInt32Field', '4294967296']),
      );
      expect(
        TestMap()..mergeFromProto3Json({
          'int32ToInt32Field': <dynamic, dynamic>{'2': 21},
        }),
        TestMap()..int32ToInt32Field[2] = 21,
      );
    });
    test('ints', () {
      expect(
        (TestAllTypes()
              ..mergeFromProto3Json({'optionalUint64': '17293822573397606400'}))
            .optionalUint64,
        Int64.parseHex('f0000000ffff0000'),
      );

      // TODO(sigurdm): This should throw.
      expect(
        TestAllTypes()..mergeFromProto3Json({'optionalUint64': '-1'}),
        TestAllTypes()
          ..optionalUint64 = Int64.fromBytes([
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
          ]),
      );

      void expectRoundTrip(String typeName, int value) {
        final t = TestAllTypes()..mergeFromProto3Json({typeName: value});
        expect(t.getField(t.getTagNumber(typeName)!), value);
        final t2 =
            TestAllTypes()..mergeFromProto3Json({typeName: value.toString()});
        expect(t2.getField(t2.getTagNumber(typeName)!), value);
      }

      void expectFailure(String typeName, int value) {
        expect(
          () => TestAllTypes()..mergeFromProto3Json({typeName: -2147483649}),
          parseFailure([typeName]),
        );
      }

      void expectSigned32(String typeName) {
        expectRoundTrip(typeName, 1);
        expectRoundTrip(typeName, 0);
        expectRoundTrip(typeName, 2147483647);
        expectRoundTrip(typeName, -2147483648);
        expectFailure(typeName, 2147483648);
        expectFailure(typeName, -2147483649);
      }

      void expectUnsigned32(String typeName) {
        expectRoundTrip(typeName, 1);
        expectRoundTrip(typeName, 0);
        expectRoundTrip(typeName, 0xFFFFFFFF);
        expectFailure(typeName, 0xFFFFFFFF + 1);
        expectFailure(typeName, -1);
      }

      expectUnsigned32('optionalFixed32');
      expectUnsigned32('optionalUint32');
      expectSigned32('optionalInt32');
      expectSigned32('optionalSfixed32');
      expectSigned32('optionalSint32');
    });

    test('unknown fields', () {
      expect(
        () =>
            TestAllTypes()
              ..mergeFromProto3Json({'myOwnInventedField': 'blahblahblah'}),
        throwsA(const TypeMatcher<FormatException>()),
      );
      expect(
        () =>
            TestAllTypes()..mergeFromProto3Json({
              'myOwnInventedField': 'blahblahblah',
            }, ignoreUnknownFields: false),
        throwsA(const TypeMatcher<FormatException>()),
      );
      final t =
          TestAllTypes()..mergeFromProto3Json({
            'myOwnInventedField': 'blahblahblah',
          }, ignoreUnknownFields: true);
      expect(t, TestAllTypes());
      expect(t.unknownFields.isEmpty, isTrue);
    });

    test('Any', () {
      final m1 =
          Any()..mergeFromProto3Json({
            '@type': 'type.googleapis.com/protobuf_unittest.TestAllTypes',
            'optionalFixed64': '100',
          }, typeRegistry: TypeRegistry([TestAllTypes()]));

      expect(m1.unpackInto(TestAllTypes()).optionalFixed64, Int64(100));

      final m2 =
          Any()..mergeFromProto3Json({
            '@type': 'type.googleapis.com/google.protobuf.Timestamp',
            'value': '1969-07-20T19:17:00Z',
          }, typeRegistry: TypeRegistry([Timestamp()]));

      expect(
        m2.unpackInto(Timestamp()).toDateTime().millisecondsSinceEpoch,
        DateTime.utc(1969, 7, 20, 19, 17).millisecondsSinceEpoch,
      );

      expect(
        () =>
            Any()..mergeFromProto3Json({
              '@type': 'type.googleapis.com/google.protobuf.Timestamp',
              'value': '1969-07-20T19:17:00Z',
            }),
        parseFailure([]),
      );

      expect(
        () =>
            Any()..mergeFromProto3Json({
              '@type': 11,
              'value': '1969-07-20T19:17:00Z',
            }),
        parseFailure([]),
      );

      final m3 =
          Any()..mergeFromProto3Json({
            '@type': 'type.googleapis.com/google.protobuf.Any',
            'value': {
              '@type': 'type.googleapis.com/google.protobuf.Timestamp',
              'value': '1969-07-20T19:17:00Z',
            },
          }, typeRegistry: TypeRegistry([Timestamp(), Any()]));

      expect(
        m3
            .unpackInto(Any())
            .unpackInto(Timestamp())
            .toDateTime()
            .millisecondsSinceEpoch,
        DateTime.utc(1969, 7, 20, 19, 17).millisecondsSinceEpoch,
      );

      // TODO(sigurdm): We would ideally like the error path to be
      // ['value', 'value'].
      expect(
        () =>
            Any()..mergeFromProto3Json({
              '@type': 'type.googleapis.com/google.protobuf.Any',
              'value': {
                '@type': 'type.googleapis.com/google.protobuf.Timestamp',
                'value': '1969',
              },
            }, typeRegistry: TypeRegistry([Timestamp(), Any()])),
        parseFailure([]),
      );

      expect(() => Any()..mergeFromProto3Json('@type'), parseFailure([]));

      expect(() => Any()..mergeFromProto3Json(11), parseFailure([]));

      expect(() => Any()..mergeFromProto3Json(['@type']), parseFailure([]));

      expect(
        () =>
            Any()..mergeFromProto3Json({
              '@type': 'type.googleapis.com/google.protobuf.Timestamp',
              'value': '1969-07-20T19:17:00Z',
            }),
        parseFailure([]),
      );
    });

    test('Nested Any', () {
      final m1 =
          Any()..mergeFromProto3Json({
            'anyField2': {
              'value': '1',
              '@type': 'type.googleapis.com/nested_any.AnyMessage1',
            },
            'value': '2',
            '@type': 'type.googleapis.com/nested_any.AnyMessage2',
          }, typeRegistry: TypeRegistry([AnyMessage1(), AnyMessage2()]));

      expect(
        m1.unpackInto(AnyMessage2()).anyField2.unpackInto(AnyMessage1()).value,
        '1',
      );
    });

    test('Duration', () {
      expect(
        Duration()..mergeFromProto3Json('0s'),
        Duration()
          ..seconds = Int64(0)
          ..nanos = 0,
      );
      expect(
        Duration()..mergeFromProto3Json('10s'),
        Duration()
          ..seconds = Int64(10)
          ..nanos = 0,
      );
      expect(
        Duration()..mergeFromProto3Json('10.000000001s'),
        Duration()
          ..seconds = Int64(10)
          ..nanos = 1,
      );
      expect(
        Duration()..mergeFromProto3Json('10.00000001s'),
        Duration()
          ..seconds = Int64(10)
          ..nanos = 10,
      );
      expect(
        Duration()..mergeFromProto3Json('-1.000099s'),
        Duration()
          ..seconds = -Int64(1)
          ..nanos = -99000,
      );

      expect(
        Duration()..mergeFromProto3Json('0.s'),
        Duration()
          ..seconds = Int64(0)
          ..nanos = 0,
      );
      expect(
        Duration()..mergeFromProto3Json('.0s'),
        Duration()
          ..seconds = Int64(0)
          ..nanos = 0,
      );
      expect(
        Duration()..mergeFromProto3Json('.5s'),
        Duration()
          ..seconds = Int64(0)
          ..nanos = 500000000,
      );
      expect(
        Duration()..mergeFromProto3Json('5.s'),
        Duration()
          ..seconds = Int64(5)
          ..nanos = 0,
      );
      expect(
        Duration()..mergeFromProto3Json('.s'),
        Duration()
          ..seconds = Int64(0)
          ..nanos = 0,
      );
      expect(() => Duration()..mergeFromProto3Json('0.5'), parseFailure([]));
      expect(() => Duration()..mergeFromProto3Json(100), parseFailure([]));
    });

    test('Timestamp', () {
      expect(
        Timestamp()..mergeFromProto3Json('1969-07-20T20:17:00Z'),
        Timestamp.fromDateTime(DateTime.utc(1969, 7, 20, 20, 17)),
      );
      expect(
        Timestamp()..mergeFromProto3Json('1970-01-01T00:00:00.000000001Z'),
        Timestamp()
          ..seconds = Int64(0)
          ..nanos = 1,
      );
      expect(
        Timestamp()..mergeFromProto3Json('1970-01-01T00:00:00.008200Z'),
        Timestamp.fromDateTime(DateTime.utc(1970))..nanos = 8200000,
      );
      expect(
        Timestamp()..mergeFromProto3Json('1970-01-01T18:50:00-04:00'),
        Timestamp()
          ..seconds = Int64(82200)
          ..nanos = 0,
      );
      expect(
        Timestamp()..mergeFromProto3Json('1970-01-01T18:50:00+04:00'),
        Timestamp()
          ..seconds = Int64(53400)
          ..nanos = 0,
      );
      expect(
        Timestamp()..mergeFromProto3Json('1970-01-01T18:50:00.0001+04:00'),
        Timestamp()
          ..seconds = Int64(53400)
          ..nanos = 100000,
      );
      expect(
        () =>
            Timestamp()..mergeFromProto3Json('1970-01-01T00:00:00.0000000001Z'),
        parseFailure([]),
      );
      expect(() => Timestamp()..mergeFromProto3Json(1970), parseFailure([]));
      expect(
        () => Timestamp()..mergeFromProto3Json('1970-01-01T18:50:00.'),
        parseFailure([]),
      );
    });

    test('wrapper types', () {
      expect(
        TestWellKnownTypes()..mergeFromProto3Json({
          'doubleField': 10.01,
          'floatField': 3,
          'int64Field': '-9223372036854775808',
          'uint64Field': '9223372036854775808',
          'int32Field': 101,
          'uint32Field': 102,
          'boolField': false,
          'stringField': 'Pop',
          'bytesField': 'CAkK',
        }),
        TestWellKnownTypes()
          ..doubleField = (DoubleValue()..value = 10.01)
          ..floatField = (FloatValue()..value = 3.0)
          ..int64Field = (Int64Value()..value = Int64.MIN_VALUE)
          ..uint64Field = (UInt64Value()..value = Int64.MIN_VALUE)
          ..int32Field = (Int32Value()..value = 101)
          ..uint32Field = (UInt32Value()..value = 102)
          ..boolField = (BoolValue()..value = false)
          ..stringField = (StringValue()..value = 'Pop')
          ..bytesField = (BytesValue()..value = [8, 9, 10]),
      );

      expect(
        TestWellKnownTypes()..mergeFromProto3Json({
          'doubleField': '10.01',
          'floatField': '3',
          'int64Field': -854775808,
          'uint64Field': 854775808,
          'int32Field': '101',
          'uint32Field': '102',
          'boolField': false,
        }),
        TestWellKnownTypes()
          ..doubleField = (DoubleValue()..value = 10.01)
          ..floatField = (FloatValue()..value = 3.0)
          ..int64Field = (Int64Value()..value = Int64(-854775808))
          ..uint64Field = (UInt64Value()..value = Int64(854775808))
          ..int32Field = (Int32Value()..value = 101)
          ..uint32Field = (UInt32Value()..value = 102)
          ..boolField = (BoolValue()..value = false),
        reason: 'alternative representations should be accepted',
      );

      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'doubleField': 'a'}),
        parseFailure(['doubleField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'doubleField': {}}),
        parseFailure(['doubleField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'floatField': 'a'}),
        parseFailure(['floatField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'floatField': {}}),
        parseFailure(['floatField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'int64Field': 'a'}),
        parseFailure(['int64Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'int64Field': {}}),
        parseFailure(['int64Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'int64Field': 10.4}),
        parseFailure(['int64Field']),
      );

      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'uint64Field': 'a'}),
        parseFailure(['uint64Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'uint64Field': 10.4}),
        parseFailure(['uint64Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'int32Field': 'a'}),
        parseFailure(['int32Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'int32Field': 10.4}),
        parseFailure(['int32Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'uint32Field': 'a'}),
        parseFailure(['uint32Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'uint32Field': 10.4}),
        parseFailure(['uint32Field']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'boolField': 'false'}),
        parseFailure(['boolField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'stringField': 22}),
        parseFailure(['stringField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'bytesField': 22}),
        parseFailure(['bytesField']),
      );
      expect(
        () => TestWellKnownTypes()..mergeFromProto3Json({'bytesField': '()'}),
        parseFailure(['bytesField']),
      );

      expect(
        TestWellKnownTypes()..mergeFromProto3Json({
          'doubleField': null,
          'floatField': null,
          'int64Field': null,
          'uint64Field': null,
          'int32Field': null,
          'uint32Field': null,
          'boolField': null,
          'stringField': null,
          'bytesField': null,
        }),
        TestWellKnownTypes(),
        reason:
            'having fields of wrapper types set to null will return an '
            'empty wrapper (with unset .value field)',
      );
    });

    test('struct', () {
      final f = {
        'null': null,
        'number': 22.3,
        'string': 'foo',
        'bool': false,
        'struct': {'a': 0},
        'list': [{}, [], 'why'],
      };

      final s =
          Struct()
            ..fields['null'] = (Value()..nullValue = NullValue.NULL_VALUE)
            ..fields['number'] = (Value()..numberValue = 22.3)
            ..fields['string'] = (Value()..stringValue = 'foo')
            ..fields['bool'] = (Value()..boolValue = false)
            ..fields['struct'] =
                (Value()
                  ..structValue =
                      (Struct()..fields['a'] = (Value()..numberValue = 0.0)))
            ..fields['list'] =
                (Value()
                  ..listValue =
                      (ListValue()
                        ..values.addAll([
                          Value()..structValue = Struct(),
                          Value()..listValue = ListValue(),
                          Value()..stringValue = 'why',
                        ])));
      expect(Struct()..mergeFromProto3Json(f), s);

      expect(
        Struct()..mergeFromProto3Json(<dynamic, dynamic>{'a': 12}),
        (Struct()..fields['a'] = (Value()..numberValue = 12.0)),
        reason: 'Allow key type to be `dynamic`',
      );

      expect(
        () => Struct()..mergeFromProto3Json({1: 2}),
        parseFailure([]),
        reason: 'Non-string key in JSON object literal',
      );

      expect(
        () => Struct()..mergeFromProto3Json([]),
        parseFailure([]),
        reason: 'Non object literal',
      );

      expect(
        () => Struct()..mergeFromProto3Json([]),
        parseFailure([]),
        reason: 'Non-string key in JSON object literal',
      );

      expect(
        () => Value()..mergeFromProto3Json(Object()),
        parseFailure([]),
        reason: 'Non JSON value',
      );

      expect(
        () => ListValue()..mergeFromProto3Json({}),
        parseFailure([]),
        reason: 'Non-list',
      );
    });

    test('field mask', () {
      expect(
        TestWellKnownTypes()
          ..mergeFromProto3Json({'fieldMaskField': 'foo,barBaz'}),
        TestWellKnownTypes()
          ..fieldMaskField = (FieldMask()..paths.addAll(['foo', 'bar_baz'])),
      );
      expect(
        () => FieldMask()..mergeFromProto3Json('foo,bar_bar'),
        parseFailure([]),
      );

      expect(FieldMask()..mergeFromProto3Json(''), FieldMask());
      expect(() => FieldMask()..mergeFromProto3Json(12), parseFailure([]));
    });

    test('one-of', () {
      expectFirstSet(Foo()..mergeFromProto3Json({'first': 'oneof'}));
      expectSecondSet(Foo()..mergeFromProto3Json({'second': 1}));
      expectOneofNotSet(Foo()..mergeFromProto3Json({}));
    });
  });

  group('Convert Double', () {
    test('With Decimal', () {
      final json = {'optionalDouble': 1.2};
      final proto = TestAllTypes()..optionalDouble = 1.2;
      expect(TestAllTypes()..mergeFromProto3Json(json), proto);
      expect(proto.toProto3Json(), json);
    });

    test('Whole Number', () {
      final json = {'optionalDouble': 5};
      final proto = TestAllTypes()..optionalDouble = 5.0;
      expect(TestAllTypes()..mergeFromProto3Json(json), proto);
      expect(proto.toProto3Json(), json);
      expect(jsonEncode(proto.toProto3Json()), '{"optionalDouble":5}');
    });

    test('Infinity', () {
      final json = {'optionalDouble': 'Infinity'};
      final proto = TestAllTypes()..optionalDouble = double.infinity;
      expect(TestAllTypes()..mergeFromProto3Json(json), proto);
      expect(proto.toProto3Json(), json);
    });

    test('Negative Infinity', () {
      final json = {'optionalDouble': '-Infinity'};
      final proto = TestAllTypes()..optionalDouble = double.negativeInfinity;
      expect(TestAllTypes()..mergeFromProto3Json(json), proto);
      expect(proto.toProto3Json(), json);
    });
  });
}