internal static async Task VerifyAssetAsync(
            ISolutionChecksumService service,
            Solution solution,
            ProjectChecksumObject projectId)
        {
            var info = await VerifyAssetSerializationAsync <ProjectChecksumObjectInfo>(
                service, projectId.Info, WellKnownChecksumObjects.ProjectChecksumObjectInfo,
                (v, k, s) => new Asset <ProjectChecksumObjectInfo>(v, k, s.SerializeProjectSnapshotInfo)).ConfigureAwait(false);

            var project = solution.GetProject(info.Id);

            await VerifyAssetSerializationAsync <CompilationOptions>(
                service, projectId.CompilationOptions, WellKnownChecksumObjects.CompilationOptions,
                (v, k, s) => new LanguageSpecificAsset <CompilationOptions>(project.Language, v, k, s.SerializeCompilationOptions));

            await VerifyAssetSerializationAsync <ParseOptions>(
                service, projectId.ParseOptions, WellKnownChecksumObjects.ParseOptions,
                (v, k, s) => new LanguageSpecificAsset <ParseOptions>(project.Language, v, k, s.SerializeParseOptions));

            foreach (var checksum in projectId.Documents)
            {
                var documentId = (DocumentChecksumObject)service.GetChecksumObject(checksum, CancellationToken.None);
                await VerifyAssetAsync(service, solution, documentId).ConfigureAwait(false);
            }

            foreach (var projectReference in projectId.ProjectReferences)
            {
                await VerifyAssetSerializationAsync <ProjectReference>(
                    service, projectReference, WellKnownChecksumObjects.ProjectReference,
                    (v, k, s) => new Asset <ProjectReference>(v, k, s.SerializeProjectReference));
            }

            foreach (var metadataReference in projectId.MetadataReferences)
            {
                await VerifyAssetSerializationAsync <MetadataReference>(
                    service, metadataReference, WellKnownChecksumObjects.MetadataReference,
                    (v, k, s) => new MetadataReferenceAsset(s, v, s.HostSerializationService.CreateChecksum(v, CancellationToken.None), k));
            }

            foreach (var analyzerReference in projectId.AnalyzerReferences)
            {
                await VerifyAssetSerializationAsync <AnalyzerReference>(
                    service, analyzerReference, WellKnownChecksumObjects.AnalyzerReference,
                    (v, k, s) => new AnalyzerReferenceAsset(s, v, s.HostSerializationService.CreateChecksum(v, CancellationToken.None), k));
            }

            foreach (var checksum in projectId.AdditionalDocuments)
            {
                var documentId = (DocumentChecksumObject)service.GetChecksumObject(checksum, CancellationToken.None);
                await VerifyAssetAsync(service, solution, documentId).ConfigureAwait(false);
            }
        }
        internal static void SnapshotEqual(ISolutionChecksumService service, ProjectChecksumObject projectId1, ProjectChecksumObject projectId2)
        {
            ChecksumObjectEqual(projectId1, projectId2);

            Assert.Equal(projectId1.Info, projectId2.Info);
            Assert.Equal(projectId1.CompilationOptions, projectId2.CompilationOptions);
            Assert.Equal(projectId1.ParseOptions, projectId2.ParseOptions);

            CollectionEqual(projectId1.Documents.ToDocumentObjects(service), projectId2.Documents.ToDocumentObjects(service));

            CollectionEqual(projectId1.ProjectReferences, projectId2.ProjectReferences);
            CollectionEqual(projectId1.MetadataReferences, projectId2.MetadataReferences);
            CollectionEqual(projectId1.AnalyzerReferences, projectId2.AnalyzerReferences);

            CollectionEqual(projectId1.AdditionalDocuments.ToDocumentObjects(service), projectId2.AdditionalDocuments.ToDocumentObjects(service));
        }
        internal static void VerifySnapshotInService(
            ISolutionChecksumService snapshotService,
            ProjectChecksumObject projectId,
            int expectedDocumentCount,
            int expectedProjectReferenceCount,
            int expectedMetadataReferenceCount,
            int expectedAnalyzerReferenceCount,
            int expectedAdditionalDocumentCount)
        {
            VerifyChecksumObjectInService(snapshotService, projectId);
            VerifyChecksumInService(snapshotService, projectId.Info, WellKnownChecksumObjects.ProjectChecksumObjectInfo);
            VerifyChecksumInService(snapshotService, projectId.CompilationOptions, WellKnownChecksumObjects.CompilationOptions);
            VerifyChecksumInService(snapshotService, projectId.ParseOptions, WellKnownChecksumObjects.ParseOptions);

            VerifyCollectionInService(snapshotService, projectId.Documents.ToDocumentObjects(snapshotService), expectedDocumentCount);

            VerifyCollectionInService(snapshotService, projectId.ProjectReferences, expectedProjectReferenceCount, WellKnownChecksumObjects.ProjectReference);
            VerifyCollectionInService(snapshotService, projectId.MetadataReferences, expectedMetadataReferenceCount, WellKnownChecksumObjects.MetadataReference);
            VerifyCollectionInService(snapshotService, projectId.AnalyzerReferences, expectedAnalyzerReferenceCount, WellKnownChecksumObjects.AnalyzerReference);

            VerifyCollectionInService(snapshotService, projectId.AdditionalDocuments.ToDocumentObjects(snapshotService), expectedAdditionalDocumentCount);
        }