public void GenerateObjectPatch()
        {
            var initial = new TestPerson()
            {
                FirstName = "John",
                LastName  = "Doe",
                IsAdult   = true,
            };

            using var scope = DraftExtensions.CreateDraft(initial, out TestPerson draft);

            draft.FirstName  = "Jane";
            draft.LastName   = null;
            draft.FirstChild = new TestPerson()
            {
                FirstName = "Baby",
                LastName  = "Doe",
            };

            var patchGenerator = new ObjectPatchGenerator();
            var patches        = new JsonPatchDocument();
            var inversePatches = new JsonPatchDocument();

            patchGenerator.Generate((IDraft)draft, "/", patches, inversePatches);

            // inverse order of inverse patches.
            inversePatches.Operations.Reverse();

            JsonAssert.Equal(
                @"
            [
              {
                'value': 'Jane',
                'path': '/FirstName',
                'op': 'replace'
              },
              {
                'path': '/LastName',
                'op': 'remove'
              },
              {
                'value': {
                  'FirstName': 'Baby',
                  'LastName': 'Doe',
                  'IsAdult': false,
                  'FirstChild': null,
                  'SecondChild': null,
                  'Cars': null
                },
                'path': '/FirstChild',
                'op': 'add'
              }
            ]
            ", JsonConvert.SerializeObject(patches));

            JsonAssert.Equal(
                @"
            [
              {
                'path': '/FirstChild',
                'op': 'remove'
              },
              {
                'value': 'Doe',
                'path': '/LastName',
                'op': 'add'
              },
              {
                'value': 'John',
                'path': '/FirstName',
                'op': 'replace'
              }
            ]
            ", JsonConvert.SerializeObject(inversePatches));
        }
        public void GenerateDictionaryPatch()
        {
            var initial = new PhoneBook()
            {
                Entries = new Dictionary <string, TestPerson>()
                {
                    ["0800JOHNDOE"] = new TestPerson()
                    {
                        FirstName = "John",
                        LastName  = "Doe",
                        IsAdult   = true,
                    },
                    ["0800JANEDOE"] = new TestPerson()
                    {
                        FirstName = "Jane",
                        LastName  = "Doe",
                        IsAdult   = true,
                    },
                },
            };

            using var scope = DraftExtensions.CreateDraft(initial, out PhoneBook draft);

            var patchGenerator = new DictionaryPatchGenerator();
            var patches        = new JsonPatchDocument();
            var inversePatches = new JsonPatchDocument();

            draft.Entries.Remove("0800JANEDOE");
            draft.Entries.Add("0800BABYDOE", new TestPerson()
            {
                FirstName = "Baby",
                LastName  = "Doe",
            });

            patchGenerator.Generate((IDraft)draft.Entries, "/Entries", patches, inversePatches);

            // inverse order of inverse patches.
            inversePatches.Operations.Reverse();

            JsonAssert.Equal(
                @"
            [
              {
                'path': '/Entries/0800JANEDOE',
                'op': 'remove'
              },
              {
                'value': {
                  'Cars': null,
                  'FirstName': 'Baby',
                  'LastName': 'Doe',
                  'IsAdult': false,
                  'FirstChild': null,
                  'SecondChild': null
                },
                'path': '/Entries/0800BABYDOE',
                'op': 'add'
              }
            ]
            ", JsonConvert.SerializeObject(patches));

            JsonAssert.Equal(
                @"
            [
              {
                'path': '/Entries/0800BABYDOE',
                'op': 'remove'
              },
              {
                'value': {
                  'FirstName': 'Jane',
                  'LastName': 'Doe',
                  'IsAdult': true,
                  'FirstChild': null,
                  'SecondChild': null,
                  'Cars': null
                },
                'path': '/Entries/0800JANEDOE',
                'op': 'add'
              }
            ]
            ", JsonConvert.SerializeObject(inversePatches));
        }
        public void GenerateComplexCollectionPatch()
        {
            var initial = new TestPerson()
            {
                FirstName = "John",
                LastName  = "Doe",
                IsAdult   = true,
                Cars      = new List <Car>()
                {
                    new Car
                    {
                        Make  = "Ferrari",
                        Model = "250 LM",
                    },
                    new Car
                    {
                        Make  = "Shelby",
                        Model = "Daytona Cobra Coupe",
                    },
                    new Car()
                    {
                        Make  = "Rolls Royce",
                        Model = "10 HP",
                    },
                    new Car()
                    {
                        Make  = "Mercedes-Benz",
                        Model = "38/250 SSK",
                    },
                },
            };

            using var scope = DraftExtensions.CreateDraft(initial, out TestPerson draft);

            var patchGenerator = new CollectionPatchGenerator(new DynamicLargestCommonSubsequence());
            var patches        = new JsonPatchDocument();
            var inversePatches = new JsonPatchDocument();

            draft.Cars.RemoveAt(3);
            draft.Cars.RemoveAt(0);
            draft.Cars.Add(new Car()
            {
                Make  = "Bugatti",
                Model = "Type 57 SC Atalante",
            });

            patchGenerator.Generate((IDraft)draft.Cars, "/Cars", patches, inversePatches);

            // inverse order of inverse patches.
            inversePatches.Operations.Reverse();

            JsonAssert.Equal(
                @"
            [
              {
                'path': '/Cars/3',
                'op': 'remove'
              },
              {
                'path': '/Cars/0',
                'op': 'remove'
              },
              {
                'value': {
                  'Make': 'Bugatti',
                  'Model': 'Type 57 SC Atalante',
                  'Crashed': false
                },
                'path': '/Cars/-',
                'op': 'add'
              }
            ]
            ", JsonConvert.SerializeObject(patches));

            JsonAssert.Equal(
                @"
            [
              {
                'path': '/Cars/2',
                'op': 'remove'
              },
              {
                'value': {
                  'Make': 'Ferrari',
                  'Model': '250 LM',
                  'Crashed': false
                },
                'path': '/Cars/0',
                'op': 'add'
              },
              {
                'value': {
                  'Make': 'Mercedes-Benz',
                  'Model': '38/250 SSK',
                  'Crashed': false
                },
                'path': '/Cars/-',
                'op': 'add'
              }            ]
            ", JsonConvert.SerializeObject(inversePatches));
        }