示例#1
0
        private void Test(TpiStream tpiStream)
        {
            Assert.Equal(tpiStream.TypeRecordCount, tpiStream.references.Count);
            Assert.NotEmpty(tpiStream.HashValues);
            if (tpiStream.HashAdjusters != null)
            {
                Assert.NotEmpty(tpiStream.HashAdjusters.Dictionary);
            }

            // Verify that type offsets are correct in references array
            foreach (TypeIndexOffset offset in tpiStream.TypeIndexOffsets)
            {
                var reference = tpiStream.references[(int)offset.Type.ArrayIndex];
                Assert.Equal(offset.Offset, reference.DataOffset - RecordPrefix.Size);
            }

            // Verify that all types can be read
            for (int i = 0; i < tpiStream.references.Count; i++)
            {
                Assert.NotNull(tpiStream[TypeIndex.FromArrayIndex(i)]);
            }

            // Check that getting types by kind works correctly
            TypeLeafKind[] kinds = tpiStream.references.Select(r => r.Kind).Distinct().ToArray();

            foreach (TypeLeafKind kind in kinds)
            {
                Assert.Equal(tpiStream.references.Count(r => r.Kind == kind), tpiStream[kind].Length);
            }
        }
示例#2
0
        private void ReadTpiStream(TpiStream tpiStream)
        {
            if (tpiStream.HashSubstream != null)
            {
                Assert.NotNull(tpiStream.HashValues);
                Assert.NotEmpty(tpiStream.TypeIndexOffsets);
            }
            else
            {
                Assert.Null(tpiStream.HashValues);
                Assert.Null(tpiStream.TypeIndexOffsets);
            }
            if (tpiStream.HashSubstream != null && tpiStream.Header.HashAdjustersBuffer.Length > 0)
            {
                Assert.NotNull(tpiStream.HashAdjusters);
            }
            else
            {
                Assert.Null(tpiStream.HashAdjusters);
            }
            var references = tpiStream.References;

            Assert.NotNull(references);
            Assert.Equal(references.Count, tpiStream.TypeRecordCount);
            for (int i = 0; i < references.Count; i++)
            {
                Assert.NotNull(tpiStream[TypeIndex.FromArrayIndex(i)]);
            }
            var kinds = references.Select(r => r.Kind).Distinct().ToArray();

            foreach (var kind in kinds)
            {
                Assert.NotEmpty(tpiStream.GetIndexes(kind));
                Assert.NotEmpty(tpiStream[kind]);
            }

            // Check type record kinds
            var allKinds = new[]
            {
                ArgumentListRecord.Kinds,
                ArrayRecord.Kinds,
                BaseClassRecord.Kinds,
                BitFieldRecord.Kinds,
                BuildInfoRecord.Kinds,
                ClassRecord.Kinds,
                DataMemberRecord.Kinds,
                EnumeratorRecord.Kinds,
                EnumRecord.Kinds,
                FieldListRecord.Kinds,
                FunctionIdRecord.Kinds,
                LabelRecord.Kinds,
                ListContinuationRecord.Kinds,
                MemberFunctionIdRecord.Kinds,
                MemberFunctionRecord.Kinds,
                MethodOverloadListRecord.Kinds,
                ModifierRecord.Kinds,
                NestedTypeRecord.Kinds,
                OneMethodRecord.Kinds,
                OverloadedMethodRecord.Kinds,
                PointerRecord.Kinds,
                StaticDataMemberRecord.Kinds,
                StringIdRecord.Kinds,
                StringListRecord.Kinds,
                UdtModuleSourceLineRecord.Kinds,
                UnionRecord.Kinds,
                VirtualBaseClassRecord.Kinds,
                VirtualFunctionPointerRecord.Kinds,
                VirtualFunctionTableShapeRecord.Kinds,
            };

            if (references.Count > 0)
            {
                Assert.NotEmpty(allKinds.SelectMany(ka => ka.SelectMany(k => tpiStream[k])));
            }
        }