turn on nullable for projects that include part root element tests

tomjebo · tomjebo · commit eba7b64b5bf0 · 2025-04-25T14:38:11.000-07:00
diff --git a/src/DocumentFormat.OpenXml.Framework/Packaging/PartExtensionProvider.cs b/src/DocumentFormat.OpenXml.Framework/Packaging/PartExtensionProvider.cs
@@ -28,7 +28,7 @@ public PartExtensionProvider()
         /// <param name="contentType">The content type</param>
         /// <param name="extension">Part Extension (".xml") to be used for the part with the specified content type.</param>
         /// <exception cref="ArgumentNullException">Thrown when either parameter is null.</exception>
-        public void Register(string contentType, string extension)
+        public void Register(string? contentType, string? extension)
         {
             if (contentType is null)
             {
diff --git a/src/DocumentFormat.OpenXml/Packaging/OpenXmlSupportedRelationshipExtensions.cs b/src/DocumentFormat.OpenXml/Packaging/OpenXmlSupportedRelationshipExtensions.cs
@@ -11,7 +11,7 @@ namespace DocumentFormat.OpenXml.Packaging;
 /// </summary>
 public static class OpenXmlSupportedRelationshipExtensions
 {
-    private static TChild InitPart<TChild>(this OpenXmlPartContainer parent, TChild childPart, PartTypeInfo partType, string? relId = null)
+    private static TChild InitPart<TChild>(this OpenXmlPartContainer? parent, TChild childPart, PartTypeInfo partType, string? relId = null)
         where TChild : OpenXmlPart
     {
         if (parent == null)
@@ -54,7 +54,7 @@ private static T DoInitPart<T>(OpenXmlPartContainer parent, T childPart, string
     /// <param name="id">The relationship id. Optional, default to null.</param>
     /// <return>The newly added part</return>
     public static AlternativeFormatImportPart AddAlternativeFormatImportPart<T>(this T parent, PartTypeInfo partType, string? id = null)
-        where T : OpenXmlPartContainer, ISupportedRelationship<AlternativeFormatImportPart>
+        where T : OpenXmlPartContainer?, ISupportedRelationship<AlternativeFormatImportPart>?
         => InitPart(parent, new AlternativeFormatImportPart(), partType, id);
 
     /// <summary>
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/Builder/OpenXmlPackageBuilderTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/Builder/OpenXmlPackageBuilderTests.cs
@@ -2,11 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using DocumentFormat.OpenXml.Builder;
-using DocumentFormat.OpenXml.Features;
-using DocumentFormat.OpenXml.Framework.Tests.Builder;
 using DocumentFormat.OpenXml.Packaging;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Xunit;
 
@@ -258,7 +255,7 @@ private static void Add(OpenXmlPackage package, int value)
 
     private sealed class Builder : OpenXmlPackageBuilder<TestPackage>
     {
-        public Builder(Builder other = null)
+        public Builder(Builder? other = null)
             : base(other)
         {
         }
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/DocumentFormat.OpenXml.Framework.Tests.csproj b/test/DocumentFormat.OpenXml.Framework.Tests/DocumentFormat.OpenXml.Framework.Tests.csproj
@@ -5,6 +5,7 @@
     <IsTestProject>true</IsTestProject>
     <IsPackable>false</IsPackable>
     <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/ElementLookupTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/ElementLookupTests.cs
@@ -58,7 +58,9 @@ public void VerifyTypedRootsCanBeCreatedWord()
             // Act/Assert
             foreach (var rootType in allTypedParts)
             {
+#nullable disable
                 var root = ((OpenXmlElement)Activator.CreateInstance(rootType))!;
+#nullable enable
                 Assert.True(feature.TryCreate(root.QName, out var created));
                 Assert.IsType(rootType, created);
             }
@@ -102,7 +104,7 @@ public CompositeRootElementFeature(params OpenXmlPackage[] package)
                 _features = package.Select(p => p.Features.GetRequired<IRootElementFeature>()).ToArray();
             }
 
-            public bool TryCreate(in OpenXmlQualifiedName qname, [NotNullWhen(true)] out OpenXmlElement element)
+            public bool TryCreate(in OpenXmlQualifiedName qname, [NotNullWhen(true)] out OpenXmlElement? element)
             {
                 foreach (var feature in _features)
                 {
@@ -131,8 +133,10 @@ ElementFactoryCollection GetLookup()
                 {
                     if (type.GetConstructor(Cached.Array<Type>()) is not null)
                     {
+#nullable disable
                         var instance = (OpenXmlElement)Activator.CreateInstance(type);
-                        return instance.Metadata.Children;
+#nullable enable
+                        return instance!.Metadata.Children;
                     }
                     else
                     {
@@ -143,15 +147,15 @@ ElementFactoryCollection GetLookup()
                 Children = GetLookup().Elements.Select(t => new OpenXmlTypeProxy(t.Type));
             }
 
-            public string Element { get; set; }
+            public string? Element { get; set; }
 
-            public IEnumerable<OpenXmlTypeProxy> Children { get; set; }
+            public IEnumerable<OpenXmlTypeProxy>? Children { get; set; }
 
-            public override bool Equals(object obj) => Equals(obj as LookupData);
+            public override bool Equals(object? obj) => Equals(obj as LookupData);
 
-            public bool Equals(LookupData other)
+            public bool Equals(LookupData? other)
             {
-                if (other is null)
+                if ((other is null) || (other.Children is null) || (Children is null))
                 {
                     return false;
                 }
@@ -186,9 +190,9 @@ public OpenXmlTypeProxy(OpenXmlSchemaType type)
 
             public OpenXmlQualifiedName Type { get; set; }
 
-            public bool Equals(OpenXmlTypeProxy other) => other is not null && Name.Equals(other.Name) && Type.Equals(other.Type);
+            public bool Equals(OpenXmlTypeProxy? other) => other is not null && Name.Equals(other.Name) && Type.Equals(other.Type);
 
-            public override bool Equals(object obj) => obj is OpenXmlTypeProxy other && Equals(other);
+            public override bool Equals(object? obj) => obj is OpenXmlTypeProxy other && Equals(other);
 
             public override int GetHashCode() => Name.GetHashCode() ^ Type.GetHashCode();
 
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/Features/PackageEventsTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/Features/PackageEventsTests.cs
@@ -19,7 +19,7 @@ public void PackageEventCalledOnClose()
             using (var package = WordprocessingDocument.Create(ms, WordprocessingDocumentType.Document))
             {
                 package.AddPackageEventsFeature();
-                package.Features.Get<IPackageEventsFeature>().Change += a => events.Add(a.Type);
+                package.Features.Get<IPackageEventsFeature>()!.Change += a => events.Add(a.Type);
             }
 
             Assert.Collection(
@@ -45,7 +45,7 @@ public void PartIdentifiedOpening()
                 var deleting = default(OpenXmlPart);
                 var deleted = default(OpenXmlPart);
 
-                package.Features.Get<IPartEventsFeature>().Change += a =>
+                package.Features.Get<IPartEventsFeature>()!.Change += a =>
                 {
                     events.Add(a.Type);
 
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/Features/PackageUriHandlingTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/Features/PackageUriHandlingTests.cs
@@ -244,7 +244,7 @@ private static string GetRelationshipContents(RelationshipInfo relationship)
 
     private sealed class DisposableFeature : IDisposableFeature, IDisposable
     {
-        private Action _dispose;
+        private Action? _dispose;
 
         void IDisposable.Dispose() => _dispose?.Invoke();
 
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/ObjectSizeTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/ObjectSizeTests.cs
@@ -50,7 +50,7 @@ public void VerifySize(Type type, int size, int fullSize, int padding, int field
 
     private static string GetTypeName(Type type)
     {
-        return type.FullName.Substring(type.FullName.IndexOf('+') + 1).Replace('+', '.');
+        return type.FullName!.Substring(type.FullName.IndexOf('+') + 1).Replace('+', '.');
     }
 
     private sealed class TestOpenXmlElement : OpenXmlElement
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/OpenXmlPartTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/OpenXmlPartTests.cs
@@ -71,7 +71,7 @@ public void ExtensionTestKnownContentType()
             var contentTypeFeature = Substitute.For<IContentTypeFeature>();
             var expectedUri = new Uri(FilePath, UriKind.Relative);
 
-            partExtensionFeature.TryGetExtension(ContentType, out string expectedExt).Returns(callInfo =>
+            partExtensionFeature.TryGetExtension(ContentType, out string? expectedExt).Returns(callInfo =>
             {
                 callInfo[1] = ExpectedExt;
                 return true;
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/PropertyBuilderTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/PropertyBuilderTests.cs
@@ -61,7 +61,7 @@ public void IsRequired()
 
         private class SomeElement : OpenXmlElement
         {
-            public StringValue Str { get; set; }
+            public StringValue? Str { get; set; }
 
             public override bool HasChildren => throw new NotImplementedException();
 
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/TestUtility.cs b/test/DocumentFormat.OpenXml.Framework.Tests/TestUtility.cs
@@ -22,10 +22,12 @@ internal static class TestUtility
             WriteIndented = true,
         };
 
-        public static T Deserialize<T>(string name)
+#nullable enable
+
+        public static T? Deserialize<T>(string name)
         {
             using (var stream = typeof(TestUtility).GetTypeInfo().Assembly.GetManifestResourceStream($"DocumentFormat.OpenXml.Framework.Tests.{name}"))
-            using (var reader = new StreamReader(stream))
+            using (var reader = new StreamReader(stream!))
             {
                 var txt = reader.ReadToEnd();
 
diff --git a/test/DocumentFormat.OpenXml.Framework.Tests/ValidatorAttributeTests.cs b/test/DocumentFormat.OpenXml.Framework.Tests/ValidatorAttributeTests.cs
@@ -58,15 +58,15 @@ public void JustUnion()
 
         private class NoValidatorsElement : BaseElement
         {
-            public StringValue Val { get; set; }
+            public StringValue? Val { get; set; }
 
             internal override void ConfigureMetadata(ElementMetadata.Builder builder) => builder.AddElement<NoValidatorsElement>()
                 .AddAttribute("val", a => a.Val);
         }
 
         private class ContainsRequiredValidator : BaseElement
         {
-            public StringValue Val { get; set; }
+            public StringValue? Val { get; set; }
 
             internal override void ConfigureMetadata(ElementMetadata.Builder builder) => builder.AddElement<NoValidatorsElement>()
                 .AddAttribute("val", a => a.Val, a =>
@@ -77,7 +77,7 @@ internal override void ConfigureMetadata(ElementMetadata.Builder builder) => bui
 
         private class JustUnionValidator : BaseElement
         {
-            public StringValue Val { get; set; }
+            public StringValue? Val { get; set; }
 
             internal override void ConfigureMetadata(ElementMetadata.Builder builder) => builder.AddElement<NoValidatorsElement>()
                 .AddAttribute("val", a => a.Val, a =>
diff --git a/test/DocumentFormat.OpenXml.Packaging.Tests/DocumentFormat.OpenXml.Packaging.Tests.csproj b/test/DocumentFormat.OpenXml.Packaging.Tests/DocumentFormat.OpenXml.Packaging.Tests.csproj
@@ -4,6 +4,7 @@
     <TargetFrameworks>$(TestTargetFrameworks)</TargetFrameworks>
     <IsTestProject>true</IsTestProject>
     <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/test/DocumentFormat.OpenXml.Packaging.Tests/OpenXmlPackageTests.cs b/test/DocumentFormat.OpenXml.Packaging.Tests/OpenXmlPackageTests.cs
@@ -164,7 +164,7 @@ public void CanRoundTripWordprocessingDocumentWithAltChunks()
 
                 using (WordprocessingDocument roundTripped = WordprocessingDocument.FromFlatOpcDocument(flatOpcDocument))
                 {
-                    List<AlternativeFormatImportPart> altChunkParts = roundTripped.MainDocumentPart
+                    List<AlternativeFormatImportPart> altChunkParts = roundTripped.MainDocumentPart!
                         .GetPartsOfType<AlternativeFormatImportPart>()
                         .ToList();
 
@@ -201,13 +201,13 @@ public void CanTransformWordprocessingDocumentWithAltChunksToFlatOpc()
                     .ToList();
 
                 // We want our MainDocumentPart to contain XML data.
-                Assert.Equal(WordprocessingMLContentType, (string)mainDocumentPart.Attribute(Pkg + "contentType"));
+                Assert.Equal(WordprocessingMLContentType, (string?)mainDocumentPart.Attribute(Pkg + "contentType"));
                 Assert.NotEmpty(mainDocumentPart.Elements(Pkg + "xmlData"));
 
                 // We want to see each one of our AlternativeFormatImportParts.
-                Assert.Contains(altChunkParts, p => (string)p.Attribute(Pkg + "contentType") == XhtmlContentType);
-                Assert.Contains(altChunkParts, p => (string)p.Attribute(Pkg + "contentType") == XmlContentType);
-                Assert.Contains(altChunkParts, p => (string)p.Attribute(Pkg + "contentType") == WordprocessingMLContentType);
+                Assert.Contains(altChunkParts, p => (string?)p.Attribute(Pkg + "contentType") == XhtmlContentType);
+                Assert.Contains(altChunkParts, p => (string?)p.Attribute(Pkg + "contentType") == XmlContentType);
+                Assert.Contains(altChunkParts, p => (string?)p.Attribute(Pkg + "contentType") == WordprocessingMLContentType);
 
                 // We want all of our AlternativeFormatImportParts to contain binary data,
                 // even though two of them have a content type ending with "+xml".
@@ -276,11 +276,23 @@ public void TestOpenModel3DWrittenByPowerPoint_DotMime()
             using var presDoc = PresentationDocument.Open(testFile, false);
 
             Assert.NotNull(presDoc);
+            Assert.NotNull(presDoc.PresentationPart);
 
             // Check to see that the Model3DReferenceRelationshippart has content type 'model/gltf-binary'
-            SlidePart slidePart = presDoc.PresentationPart.GetPartsOfType<SlidePart>().FirstOrDefault();
+            PresentationPart? presentationPart = presDoc.PresentationPart;
+            IEnumerable<SlidePart>? slideParts = presentationPart.GetPartsOfType<SlidePart>();
+
+            Assert.NotNull(slideParts);
+
+            Assert.True(slideParts.Count<SlidePart>() > 0);
+
+            SlidePart? slidePart = slideParts.First();
+
             IEnumerable<Model3DReferenceRelationshipPart> model3DReferenceRelationshipParts = slidePart.Model3DReferenceRelationshipParts;
-            Model3DReferenceRelationshipPart model3DReferenceRelationshipPart = model3DReferenceRelationshipParts.FirstOrDefault();
+
+            Assert.True(model3DReferenceRelationshipParts.Count<Model3DReferenceRelationshipPart>() > 0);
+
+            Model3DReferenceRelationshipPart model3DReferenceRelationshipPart = model3DReferenceRelationshipParts.First();
 
             Assert.Equal("model/gltf-binary", model3DReferenceRelationshipPart.ContentType);
         }
@@ -296,9 +308,9 @@ public void TestOpenModel3DWrittenByPowerPoint_DashMime()
             Assert.NotNull(presDoc);
 
             // Check to see that the Model3DReferenceRelationshippart has content type 'model/gltf-binary'
-            SlidePart slidePart = presDoc.PresentationPart.GetPartsOfType<SlidePart>().FirstOrDefault();
+            SlidePart slidePart = presDoc.PresentationPart!.GetPartsOfType<SlidePart>().First();
             IEnumerable<Model3DReferenceRelationshipPart> model3DReferenceRelationshipParts = slidePart.Model3DReferenceRelationshipParts;
-            Model3DReferenceRelationshipPart model3DReferenceRelationshipPart = model3DReferenceRelationshipParts.FirstOrDefault();
+            Model3DReferenceRelationshipPart model3DReferenceRelationshipPart = model3DReferenceRelationshipParts.First();
 
             Assert.Equal("model/gltf-binary", model3DReferenceRelationshipPart.ContentType);
         }
diff --git a/test/DocumentFormat.OpenXml.Packaging.Tests/OpenXmlPartReaderTests.cs b/test/DocumentFormat.OpenXml.Packaging.Tests/OpenXmlPartReaderTests.cs
@@ -15,8 +15,8 @@ public class OpenXmlPartReaderTests
     [Fact]
     public void ThrowsNull()
     {
-        Assert.Throws<ArgumentNullException>(() => new OpenXmlPartReader(null));
-        Assert.Throws<ArgumentNullException>(() => new OpenXmlPartReader(null, true));
+        Assert.Throws<ArgumentNullException>(() => new OpenXmlPartReader(null!));
+        Assert.Throws<ArgumentNullException>(() => new OpenXmlPartReader(null!, true));
     }
 
     [InlineData("<?xml version='1.0' encoding='UTF-8' standalone='yes'?><root/>", "UTF-8", true)]
@@ -27,7 +27,7 @@ public void ThrowsNull()
     [InlineData("<?xml version='1.0'?>", null, null)]
     [InlineData("<root/>", null, null)]
     [Theory]
-    public void ExtractsInfoFromStream(string xml, string encoding, bool? standalone)
+    public void ExtractsInfoFromStream(string xml, string? encoding, bool? standalone)
     {
         var features = new FeatureCollection();
         var elementFactory = Substitute.For<IRootElementFeature>();
diff --git a/test/DocumentFormat.OpenXml.Packaging.Tests/PartConstraintRuleTests.cs b/test/DocumentFormat.OpenXml.Packaging.Tests/PartConstraintRuleTests.cs
diff --git a/test/DocumentFormat.OpenXml.Packaging.Tests/ParticleTests.cs b/test/DocumentFormat.OpenXml.Packaging.Tests/ParticleTests.cs
diff --git a/test/DocumentFormat.OpenXml.Tests/DocumentFormat.OpenXml.Tests.csproj b/test/DocumentFormat.OpenXml.Tests/DocumentFormat.OpenXml.Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public PartExtensionProvider()`
`28`	`28`	`/// <param name="contentType">The content type</param>`
`29`	`29`	`/// <param name="extension">Part Extension (".xml") to be used for the part with the specified content type.</param>`
`30`	`30`	`/// <exception cref="ArgumentNullException">Thrown when either parameter is null.</exception>`
`31`		`- public void Register(string contentType, string extension)`
	`31`	`+ public void Register(string? contentType, string? extension)`
`32`	`32`	`{`
`33`	`33`	`if (contentType is null)`
`34`	`34`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,8 @@`
`2`	`2`	`// Licensed under the MIT license. See LICENSE file in the project root for full license information.`
`3`	`3`
`4`	`4`	`using DocumentFormat.OpenXml.Builder;`
`5`		`-using DocumentFormat.OpenXml.Features;`
`6`		`-using DocumentFormat.OpenXml.Framework.Tests.Builder;`
`7`	`5`	`using DocumentFormat.OpenXml.Packaging;`
`8`	`6`	`using System.Collections.Generic;`
`9`		`-using System.IO;`
`10`	`7`	`using System.Linq;`
`11`	`8`	`using Xunit;`
`12`	`9`
`@@ -258,7 +255,7 @@ private static void Add(OpenXmlPackage package, int value)`
`258`	`255`
`259`	`256`	`private sealed class Builder : OpenXmlPackageBuilder<TestPackage>`
`260`	`257`	`{`
`261`		`- public Builder(Builder other = null)`
	`258`	`+ public Builder(Builder? other = null)`
`262`	`259`	`: base(other)`
`263`	`260`	`{`
`264`	`261`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,9 @@ public void VerifyTypedRootsCanBeCreatedWord()`
`58`	`58`	`// Act/Assert`
`59`	`59`	`foreach (var rootType in allTypedParts)`
`60`	`60`	`{`
	`61`	`+#nullable disable`
`61`	`62`	`var root = ((OpenXmlElement)Activator.CreateInstance(rootType))!;`
	`63`	`+#nullable enable`
`62`	`64`	`Assert.True(feature.TryCreate(root.QName, out var created));`
`63`	`65`	`Assert.IsType(rootType, created);`
`64`	`66`	`}`
`@@ -102,7 +104,7 @@ public CompositeRootElementFeature(params OpenXmlPackage[] package)`
`102`	`104`	`_features = package.Select(p => p.Features.GetRequired<IRootElementFeature>()).ToArray();`
`103`	`105`	`}`
`104`	`106`
`105`		`- public bool TryCreate(in OpenXmlQualifiedName qname, [NotNullWhen(true)] out OpenXmlElement element)`
	`107`	`+ public bool TryCreate(in OpenXmlQualifiedName qname, [NotNullWhen(true)] out OpenXmlElement? element)`
`106`	`108`	`{`
`107`	`109`	`foreach (var feature in _features)`
`108`	`110`	`{`
`@@ -131,8 +133,10 @@ ElementFactoryCollection GetLookup()`
`131`	`133`	`{`
`132`	`134`	`if (type.GetConstructor(Cached.Array<Type>()) is not null)`
`133`	`135`	`{`
	`136`	`+#nullable disable`
`134`	`137`	`var instance = (OpenXmlElement)Activator.CreateInstance(type);`
`135`		`- return instance.Metadata.Children;`
	`138`	`+#nullable enable`
	`139`	`+ return instance!.Metadata.Children;`
`136`	`140`	`}`
`137`	`141`	`else`
`138`	`142`	`{`
`@@ -143,15 +147,15 @@ ElementFactoryCollection GetLookup()`
`143`	`147`	`Children = GetLookup().Elements.Select(t => new OpenXmlTypeProxy(t.Type));`
`144`	`148`	`}`
`145`	`149`
`146`		`- public string Element { get; set; }`
	`150`	`+ public string? Element { get; set; }`
`147`	`151`
`148`		`- public IEnumerable<OpenXmlTypeProxy> Children { get; set; }`
	`152`	`+ public IEnumerable<OpenXmlTypeProxy>? Children { get; set; }`
`149`	`153`
`150`		`- public override bool Equals(object obj) => Equals(obj as LookupData);`
	`154`	`+ public override bool Equals(object? obj) => Equals(obj as LookupData);`
`151`	`155`
`152`		`- public bool Equals(LookupData other)`
	`156`	`+ public bool Equals(LookupData? other)`
`153`	`157`	`{`
`154`		`- if (other is null)`
	`158`	`+ if ((other is null) \|\| (other.Children is null) \|\| (Children is null))`
`155`	`159`	`{`
`156`	`160`	`return false;`
`157`	`161`	`}`
`@@ -186,9 +190,9 @@ public OpenXmlTypeProxy(OpenXmlSchemaType type)`
`186`	`190`
`187`	`191`	`public OpenXmlQualifiedName Type { get; set; }`
`188`	`192`
`189`		`- public bool Equals(OpenXmlTypeProxy other) => other is not null && Name.Equals(other.Name) && Type.Equals(other.Type);`
	`193`	`+ public bool Equals(OpenXmlTypeProxy? other) => other is not null && Name.Equals(other.Name) && Type.Equals(other.Type);`
`190`	`194`
`191`		`- public override bool Equals(object obj) => obj is OpenXmlTypeProxy other && Equals(other);`
	`195`	`+ public override bool Equals(object? obj) => obj is OpenXmlTypeProxy other && Equals(other);`
`192`	`196`
`193`	`197`	`public override int GetHashCode() => Name.GetHashCode() ^ Type.GetHashCode();`
`194`	`198`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void PackageEventCalledOnClose()`
`19`	`19`	`using (var package = WordprocessingDocument.Create(ms, WordprocessingDocumentType.Document))`
`20`	`20`	`{`
`21`	`21`	`package.AddPackageEventsFeature();`
`22`		`- package.Features.Get<IPackageEventsFeature>().Change += a => events.Add(a.Type);`
	`22`	`+ package.Features.Get<IPackageEventsFeature>()!.Change += a => events.Add(a.Type);`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`Assert.Collection(`
`@@ -45,7 +45,7 @@ public void PartIdentifiedOpening()`
`45`	`45`	`var deleting = default(OpenXmlPart);`
`46`	`46`	`var deleted = default(OpenXmlPart);`
`47`	`47`
`48`		`- package.Features.Get<IPartEventsFeature>().Change += a =>`
	`48`	`+ package.Features.Get<IPartEventsFeature>()!.Change += a =>`
`49`	`49`	`{`
`50`	`50`	`events.Add(a.Type);`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ private static string GetRelationshipContents(RelationshipInfo relationship)`
`244`	`244`
`245`	`245`	`private sealed class DisposableFeature : IDisposableFeature, IDisposable`
`246`	`246`	`{`
`247`		`- private Action _dispose;`
	`247`	`+ private Action? _dispose;`
`248`	`248`
`249`	`249`	`void IDisposable.Dispose() => _dispose?.Invoke();`
`250`	`250`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public void VerifySize(Type type, int size, int fullSize, int padding, int field`
`50`	`50`
`51`	`51`	`private static string GetTypeName(Type type)`
`52`	`52`	`{`
`53`		`- return type.FullName.Substring(type.FullName.IndexOf('+') + 1).Replace('+', '.');`
	`53`	`+ return type.FullName!.Substring(type.FullName.IndexOf('+') + 1).Replace('+', '.');`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`private sealed class TestOpenXmlElement : OpenXmlElement`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void ExtensionTestKnownContentType()`
`71`	`71`	`var contentTypeFeature = Substitute.For<IContentTypeFeature>();`
`72`	`72`	`var expectedUri = new Uri(FilePath, UriKind.Relative);`
`73`	`73`
`74`		`- partExtensionFeature.TryGetExtension(ContentType, out string expectedExt).Returns(callInfo =>`
	`74`	`+ partExtensionFeature.TryGetExtension(ContentType, out string? expectedExt).Returns(callInfo =>`
`75`	`75`	`{`
`76`	`76`	`callInfo[1] = ExpectedExt;`
`77`	`77`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public void IsRequired()`
`61`	`61`
`62`	`62`	`private class SomeElement : OpenXmlElement`
`63`	`63`	`{`
`64`		`- public StringValue Str { get; set; }`
	`64`	`+ public StringValue? Str { get; set; }`
`65`	`65`
`66`	`66`	`public override bool HasChildren => throw new NotImplementedException();`
`67`	`67`