Further refactoring of discovery results.

12 files changed, 110 insertions, 117 deletions

diff --git a/src/DotNetOpenAuth.Test/Mocks/MockHttpRequest.cs b/src/DotNetOpenAuth.Test/Mocks/MockHttpRequest.cs
index b10da88..c18ea33 100644
--- a/src/DotNetOpenAuth.Test/Mocks/MockHttpRequest.cs
+++ b/src/DotNetOpenAuth.Test/Mocks/MockHttpRequest.cs
@@ -15,7 +15,6 @@ namespace DotNetOpenAuth.Test.Mocks {
 	using System.Web;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 	using DotNetOpenAuth.Test.OpenId;
 	using DotNetOpenAuth.Yadis;
@@ -84,19 +83,19 @@ namespace DotNetOpenAuth.Test.Mocks {
 			}
 		}
 
-		internal void RegisterMockXrdsResponse(IIdentifierDiscoveryResult endpoint) {
+		internal void RegisterMockXrdsResponse(IdentifierDiscoveryResult endpoint) {
 			Contract.Requires<ArgumentNullException>(endpoint != null);
 
 			string identityUri;
-			if (endpoint.ClaimedIdentifier == endpoint.ProviderEndpoint.GetProtocol().ClaimedIdentifierForOPIdentifier) {
+			if (endpoint.ClaimedIdentifier == endpoint.Protocol.ClaimedIdentifierForOPIdentifier) {
 				identityUri = endpoint.UserSuppliedIdentifier;
 			} else {
 				identityUri = endpoint.UserSuppliedIdentifier ?? endpoint.ClaimedIdentifier;
 			}
-			this.RegisterMockXrdsResponse(new Uri(identityUri), new IIdentifierDiscoveryResult[] { endpoint });
+			this.RegisterMockXrdsResponse(new Uri(identityUri), new IdentifierDiscoveryResult[] { endpoint });
 		}
 
-		internal void RegisterMockXrdsResponse(Uri respondingUri, IEnumerable<IIdentifierDiscoveryResult> endpoints) {
+		internal void RegisterMockXrdsResponse(Uri respondingUri, IEnumerable<IdentifierDiscoveryResult> endpoints) {
 			Contract.Requires<ArgumentNullException>(endpoints != null);
 
 			StringBuilder xrds = new StringBuilder();
@@ -111,16 +110,16 @@ namespace DotNetOpenAuth.Test.Mocks {
 			<openid:Delegate xmlns:openid='http://openid.net/xmlns/1.0'>{2}</openid:Delegate>
 		</Service>";
 				string serviceTypeUri;
-				if (endpoint.ClaimedIdentifier == endpoint.ProviderEndpoint.GetProtocol().ClaimedIdentifierForOPIdentifier) {
-					serviceTypeUri = endpoint.ProviderEndpoint.GetProtocol().OPIdentifierServiceTypeURI;
+				if (endpoint.ClaimedIdentifier == endpoint.Protocol.ClaimedIdentifierForOPIdentifier) {
+					serviceTypeUri = endpoint.Protocol.OPIdentifierServiceTypeURI;
 				} else {
-					serviceTypeUri = endpoint.ProviderEndpoint.GetProtocol().ClaimedIdentifierServiceTypeURI;
+					serviceTypeUri = endpoint.Protocol.ClaimedIdentifierServiceTypeURI;
 				}
 				string xrd = string.Format(
 					CultureInfo.InvariantCulture,
 					template,
 					HttpUtility.HtmlEncode(serviceTypeUri),
-					HttpUtility.HtmlEncode(endpoint.ProviderEndpoint.Uri.AbsoluteUri),
+					HttpUtility.HtmlEncode(endpoint.ProviderEndpoint.AbsoluteUri),
 					HttpUtility.HtmlEncode(endpoint.ProviderLocalIdentifier));
 				xrds.Append(xrd);
 			}
@@ -131,12 +130,12 @@ namespace DotNetOpenAuth.Test.Mocks {
 			this.RegisterMockResponse(respondingUri, ContentTypes.Xrds, xrds.ToString());
 		}
 
-		internal void RegisterMockXrdsResponse(UriIdentifier directedIdentityAssignedIdentifier, IIdentifierDiscoveryResult providerEndpoint) {
-			IIdentifierDiscoveryResult identityEndpoint = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
+		internal void RegisterMockXrdsResponse(UriIdentifier directedIdentityAssignedIdentifier, IdentifierDiscoveryResult providerEndpoint) {
+			IdentifierDiscoveryResult identityEndpoint = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
 				directedIdentityAssignedIdentifier,
 				directedIdentityAssignedIdentifier,
 				providerEndpoint.ProviderLocalIdentifier,
-				providerEndpoint.ProviderEndpoint,
+				new ProviderEndpointDescription(providerEndpoint.ProviderEndpoint, providerEndpoint.Capabilities),
 				10,
 				10);
 			this.RegisterMockXrdsResponse(identityEndpoint);
diff --git a/src/DotNetOpenAuth.Test/Mocks/MockIdentifier.cs b/src/DotNetOpenAuth.Test/Mocks/MockIdentifier.cs
index 862a05e..9f032b8 100644
--- a/src/DotNetOpenAuth.Test/Mocks/MockIdentifier.cs
+++ b/src/DotNetOpenAuth.Test/Mocks/MockIdentifier.cs
@@ -10,7 +10,6 @@ namespace DotNetOpenAuth.Test.Mocks {
 	using System.Diagnostics.Contracts;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 
 	/// <summary>
@@ -19,13 +18,13 @@ namespace DotNetOpenAuth.Test.Mocks {
 	/// having a dependency on a hosted web site to actually perform discovery on.
 	/// </summary>
 	internal class MockIdentifier : Identifier {
-		private IEnumerable<IIdentifierDiscoveryResult> endpoints;
+		private IEnumerable<IdentifierDiscoveryResult> endpoints;
 
 		private MockHttpRequest mockHttpRequest;
 
 		private Identifier wrappedIdentifier;
 
-		public MockIdentifier(Identifier wrappedIdentifier, MockHttpRequest mockHttpRequest, IEnumerable<IIdentifierDiscoveryResult> endpoints)
+		public MockIdentifier(Identifier wrappedIdentifier, MockHttpRequest mockHttpRequest, IEnumerable<IdentifierDiscoveryResult> endpoints)
 			: base(wrappedIdentifier.OriginalString, false) {
 			Contract.Requires<ArgumentNullException>(wrappedIdentifier != null);
 			Contract.Requires<ArgumentNullException>(mockHttpRequest != null);
@@ -40,7 +39,7 @@ namespace DotNetOpenAuth.Test.Mocks {
 			mockHttpRequest.RegisterMockXrdsResponse(new Uri(wrappedIdentifier.ToString()), endpoints);
 		}
 
-		internal IEnumerable<IIdentifierDiscoveryResult> DiscoveryEndpoints {
+		internal IEnumerable<IdentifierDiscoveryResult> DiscoveryEndpoints {
 			get { return this.endpoints; }
 		}
 
diff --git a/src/DotNetOpenAuth.Test/Mocks/MockIdentifierDiscoveryService.cs b/src/DotNetOpenAuth.Test/Mocks/MockIdentifierDiscoveryService.cs
index 8aea7e5..d74258d 100644
--- a/src/DotNetOpenAuth.Test/Mocks/MockIdentifierDiscoveryService.cs
+++ b/src/DotNetOpenAuth.Test/Mocks/MockIdentifierDiscoveryService.cs
@@ -11,7 +11,6 @@ namespace DotNetOpenAuth.Test.Mocks {
 	using System.Text;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 
 	internal class MockIdentifierDiscoveryService : IIdentifierDiscoveryService {
@@ -32,11 +31,11 @@ namespace DotNetOpenAuth.Test.Mocks {
 		/// <returns>
 		/// A sequence of service endpoints yielded by discovery.  Must not be null, but may be empty.
 		/// </returns>
-		public IEnumerable<IIdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) {
+		public IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) {
 			var mockIdentifier = identifier as MockIdentifier;
 			if (mockIdentifier == null) {
 				abortDiscoveryChain = false;
-				return Enumerable.Empty<IIdentifierDiscoveryResult>();
+				return Enumerable.Empty<IdentifierDiscoveryResult>();
 			}
 
 			abortDiscoveryChain = true;
diff --git a/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs b/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
index 0f6dd7e..4432c0d 100644
--- a/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/AssociationHandshakeTests.cs
@@ -318,7 +318,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		private void ParameterizedAssociationTest(
 			ProviderEndpointDescription opDescription,
 			string expectedAssociationType) {
-			Protocol protocol = Protocol.Lookup(opDescription.GetProtocol().ProtocolVersion);
+			Protocol protocol = Protocol.Lookup(Protocol.Lookup(opDescription.Version).ProtocolVersion);
 			bool expectSuccess = expectedAssociationType != null;
 			bool expectDiffieHellman = !opDescription.Uri.IsTransportSecure();
 			Association rpAssociation = null, opAssociation;
@@ -337,7 +337,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 					op.SendResponse(req);
 				});
 			coordinator.IncomingMessageFilter = message => {
-				Assert.AreSame(opDescription.GetProtocol().ProtocolVersion, message.Version, "The message was recognized as version {0} but was expected to be {1}.", message.Version, opDescription.GetProtocol().ProtocolVersion);
+				Assert.AreSame(Protocol.Lookup(opDescription.Version).ProtocolVersion, message.Version, "The message was recognized as version {0} but was expected to be {1}.", message.Version, Protocol.Lookup(opDescription.Version).ProtocolVersion);
 				var associateSuccess = message as AssociateSuccessfulResponse;
 				var associateFailed = message as AssociateUnsuccessfulResponse;
 				if (associateSuccess != null) {
@@ -348,7 +348,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 				}
 			};
 			coordinator.OutgoingMessageFilter = message => {
-				Assert.AreSame(opDescription.GetProtocol().ProtocolVersion, message.Version, "The message was for version {0} but was expected to be for {1}.", message.Version, opDescription.GetProtocol().Version);
+				Assert.AreSame(Protocol.Lookup(opDescription.Version).ProtocolVersion, message.Version, "The message was for version {0} but was expected to be for {1}.", message.Version, Protocol.Lookup(opDescription.Version).Version);
 			};
 			coordinator.Run();
 
diff --git a/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/UriDiscoveryServiceTests.cs b/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/UriDiscoveryServiceTests.cs
index 9c68daa..0655ff5 100644
--- a/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/UriDiscoveryServiceTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/UriDiscoveryServiceTests.cs
@@ -13,7 +13,6 @@ namespace DotNetOpenAuth.Test.OpenId.DiscoveryServices {
 	using System.Web;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 	using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -119,7 +118,7 @@ namespace DotNetOpenAuth.Test.OpenId.DiscoveryServices {
 			var insecureEndpoint = GetServiceEndpoint(0, ProtocolVersion.V20, 10, false);
 			var secureEndpoint = GetServiceEndpoint(1, ProtocolVersion.V20, 20, true);
 			UriIdentifier secureClaimedId = new UriIdentifier(VanityUriSsl, true);
-			this.MockResponder.RegisterMockXrdsResponse(secureClaimedId, new IIdentifierDiscoveryResult[] { insecureEndpoint, secureEndpoint });
+			this.MockResponder.RegisterMockXrdsResponse(secureClaimedId, new IdentifierDiscoveryResult[] { insecureEndpoint, secureEndpoint });
 			Assert.AreEqual(secureEndpoint.ProviderLocalIdentifier, this.Discover(secureClaimedId).Single().ProviderLocalIdentifier);
 		}
 
@@ -203,21 +202,21 @@ namespace DotNetOpenAuth.Test.OpenId.DiscoveryServices {
 			}
 			this.MockResponder.RegisterMockResponse(new Uri(idToDiscover), claimedId, contentType, headers ?? new WebHeaderCollection(), LoadEmbeddedFile(url));
 
-			IIdentifierDiscoveryResult expected = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
+			IdentifierDiscoveryResult expected = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
 				claimedId,
 				expectedLocalId,
 				new ProviderEndpointDescription(new Uri(providerEndpoint), new string[] { protocol.ClaimedIdentifierServiceTypeURI }), // services aren't checked by Equals
 				null,
 				null);
 
-			IIdentifierDiscoveryResult se = this.Discover(idToDiscover).FirstOrDefault(ep => ep.Equals(expected));
+			IdentifierDiscoveryResult se = this.Discover(idToDiscover).FirstOrDefault(ep => ep.Equals(expected));
 			Assert.IsNotNull(se, url + " failed to be discovered.");
 
 			// Do extra checking of service type URIs, which aren't included in 
 			// the ServiceEndpoint.Equals method.
-			Assert.AreEqual(expectSreg ? 2 : 1, se.ProviderEndpoint.Capabilities.Count);
-			Assert.IsTrue(se.ProviderEndpoint.Capabilities.Contains(protocol.ClaimedIdentifierServiceTypeURI));
-			Assert.AreEqual(expectSreg, se.ProviderEndpoint.IsExtensionSupported<ClaimsRequest>());
+			Assert.AreEqual(expectSreg ? 2 : 1, se.Capabilities.Count);
+			Assert.IsTrue(se.Capabilities.Contains(protocol.ClaimedIdentifierServiceTypeURI));
+			Assert.AreEqual(expectSreg, se.IsExtensionSupported<ClaimsRequest>());
 		}
 
 		private void DiscoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId, string providerEndpoint) {
diff --git a/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/XriDiscoveryProxyServiceTests.cs b/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/XriDiscoveryProxyServiceTests.cs
index b3383a4..404f37d 100644
--- a/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/XriDiscoveryProxyServiceTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/DiscoveryServices/XriDiscoveryProxyServiceTests.cs
@@ -10,7 +10,6 @@ namespace DotNetOpenAuth.Test.OpenId.DiscoveryServices {
 	using System.Linq;
 	using System.Text;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 	using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -56,11 +55,11 @@ namespace DotNetOpenAuth.Test.OpenId.DiscoveryServices {
 			this.MockResponder.RegisterMockXrdsResponses(mocks);
 
 			string expectedCanonicalId = "=!9B72.7DD1.50A9.5CCD";
-			IIdentifierDiscoveryResult se = this.VerifyCanonicalId("=Arnott", expectedCanonicalId);
-			Assert.AreEqual(Protocol.V10, Protocol.Lookup(se.ProviderEndpoint.Version).ProtocolVersion);
+			IdentifierDiscoveryResult se = this.VerifyCanonicalId("=Arnott", expectedCanonicalId);
+			Assert.AreEqual(Protocol.V10, Protocol.Lookup(se.Version).ProtocolVersion);
 			Assert.AreEqual("http://1id.com/sso", se.ProviderEndpoint.ToString());
 			Assert.AreEqual(se.ClaimedIdentifier, se.ProviderLocalIdentifier);
-			Assert.AreEqual("=Arnott", se.GetFriendlyIdentifierForDisplay());
+			Assert.AreEqual("=Arnott", se.FriendlyIdentifierForDisplay);
 		}
 
 		[TestMethod]
@@ -380,12 +379,12 @@ uEyb50RJ7DWmXctSC0b3eymZ2lSXxAWNOsNy
 			this.VerifyCanonicalId("@id*andrewarnott", null);
 		}
 
-		private IIdentifierDiscoveryResult VerifyCanonicalId(Identifier iname, string expectedClaimedIdentifier) {
+		private IdentifierDiscoveryResult VerifyCanonicalId(Identifier iname, string expectedClaimedIdentifier) {
 			var se = this.Discover(iname).FirstOrDefault();
 			if (expectedClaimedIdentifier != null) {
 				Assert.IsNotNull(se);
 				Assert.AreEqual(expectedClaimedIdentifier, se.ClaimedIdentifier.ToString(), "i-name {0} discovery resulted in unexpected CanonicalId", iname);
-				Assert.IsTrue(se.ProviderEndpoint.Capabilities.Count > 0);
+				Assert.IsTrue(se.Capabilities.Count > 0);
 			} else {
 				Assert.IsNull(se);
 			}
diff --git a/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPRequestTests.cs b/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPRequestTests.cs
index 73dc2b3..447d49e 100644
--- a/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPRequestTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/Extensions/ExtensionsInteropHelperRPRequestTests.cs
@@ -119,7 +119,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		/// </summary>
 		/// <param name="typeUri">The type URI.</param>
 		private void InjectAdvertisedTypeUri(string typeUri) {
-			var serviceEndpoint = ProviderEndpointDescription_Accessor.AttachShadow(((ProviderEndpointDescription)this.authReq.Provider));
+			var serviceEndpoint = ProviderEndpointDescription_Accessor.AttachShadow(this.authReq.Provider);
 			serviceEndpoint.Capabilities = new ReadOnlyCollection<string>(
 					serviceEndpoint.Capabilities.Concat(new[] { typeUri }).ToList());
 		}
diff --git a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
index 9889fac..5492bcc 100644
--- a/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/OpenIdTestBase.cs
@@ -13,7 +13,6 @@ namespace DotNetOpenAuth.Test.OpenId {
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.Messaging.Bindings;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.Provider;
 	using DotNetOpenAuth.OpenId.RelyingParty;
 	using DotNetOpenAuth.Test.Mocks;
@@ -118,11 +117,11 @@ namespace DotNetOpenAuth.Test.OpenId {
 			}
 		}
 
-		internal static IIdentifierDiscoveryResult GetServiceEndpoint(int user, ProtocolVersion providerVersion, int servicePriority, bool useSsl) {
+		internal static IdentifierDiscoveryResult GetServiceEndpoint(int user, ProtocolVersion providerVersion, int servicePriority, bool useSsl) {
 			return GetServiceEndpoint(user, providerVersion, servicePriority, useSsl, false);
 		}
 
-		internal static IIdentifierDiscoveryResult GetServiceEndpoint(int user, ProtocolVersion providerVersion, int servicePriority, bool useSsl, bool delegating) {
+		internal static IdentifierDiscoveryResult GetServiceEndpoint(int user, ProtocolVersion providerVersion, int servicePriority, bool useSsl, bool delegating) {
 			var providerEndpoint = new ProviderEndpointDescription(
 				useSsl ? OpenIdTestBase.OPUriSsl : OpenIdTestBase.OPUri,
 				new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI });
@@ -178,7 +177,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 			}
 		}
 
-		internal IEnumerable<IIdentifierDiscoveryResult> Discover(Identifier identifier) {
+		internal IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier) {
 			var rp = this.CreateRelyingParty(true);
 			rp.Channel.WebRequestHandler = this.RequestHandler;
 			return rp.Discover(identifier);
@@ -200,7 +199,7 @@ namespace DotNetOpenAuth.Test.OpenId {
 		protected Identifier GetMockIdentifier(ProtocolVersion providerVersion, bool useSsl, bool delegating) {
 			var se = GetServiceEndpoint(0, providerVersion, 10, useSsl, delegating);
 			UriIdentifier identityUri = (UriIdentifier)se.ClaimedIdentifier;
-			return new MockIdentifier(identityUri, this.MockResponder, new IIdentifierDiscoveryResult[] { se });
+			return new MockIdentifier(identityUri, this.MockResponder, new IdentifierDiscoveryResult[] { se });
 		}
 
 		/// <summary>
diff --git a/src/DotNetOpenAuth.Test/OpenId/OpenIdUtilitiesTests.cs b/src/DotNetOpenAuth.Test/OpenId/OpenIdUtilitiesTests.cs
index 1a68d0a..389ef81 100644
--- a/src/DotNetOpenAuth.Test/OpenId/OpenIdUtilitiesTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/OpenIdUtilitiesTests.cs
@@ -16,50 +16,5 @@ namespace DotNetOpenAuth.Test.OpenId {
 
 	[TestClass]
 	public class OpenIdUtilitiesTests : OpenIdTestBase {
-		private ProviderEndpointDescription se;
-
-		private string[] v20TypeUris = { Protocol.V20.ClaimedIdentifierServiceTypeURI };
-
-		[TestInitialize]
-		public override void SetUp() {
-			base.SetUp();
-
-			this.se = new ProviderEndpointDescription(OPUri, Protocol.V20.Version);
-		}
-
-		[TestMethod, ExpectedException(typeof(ArgumentNullException))]
-		public void IsExtensionSupportedNullType() {
-			this.se.IsExtensionSupported((Type)null);
-		}
-
-		[TestMethod, ExpectedException(typeof(ArgumentException))]
-		public void IsTypeUriPresentNullString() {
-			this.se.IsTypeUriPresent((string)null);
-		}
-
-		[TestMethod, ExpectedException(typeof(ArgumentException))]
-		public void IsTypeUriPresentEmptyString() {
-			this.se.IsTypeUriPresent(string.Empty);
-		}
-
-		[TestMethod, ExpectedException(typeof(ArgumentNullException))]
-		public void IsExtensionSupportedNullExtension() {
-			this.se.IsExtensionSupported((IOpenIdMessageExtension)null);
-		}
-
-		[TestMethod]
-		public void IsExtensionSupported() {
-			this.se = new ProviderEndpointDescription(OPUri, this.v20TypeUris);
-			Assert.IsFalse(this.se.IsExtensionSupported<ClaimsRequest>());
-			Assert.IsFalse(this.se.IsExtensionSupported(new ClaimsRequest()));
-			Assert.IsFalse(this.se.IsTypeUriPresent("http://someextension/typeuri"));
-
-			this.se = new ProviderEndpointDescription(
-				OPUri,
-				new[] { Protocol.V20.ClaimedIdentifierServiceTypeURI, "http://someextension", Constants.sreg_ns });
-			Assert.IsTrue(this.se.IsExtensionSupported<ClaimsRequest>());
-			Assert.IsTrue(this.se.IsExtensionSupported(new ClaimsRequest()));
-			Assert.IsTrue(this.se.IsTypeUriPresent("http://someextension"));
-		}
 	}
 }
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
index fea672d..1445e1d 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/AuthenticationRequestTests.cs
@@ -13,7 +13,6 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 	using System.Web;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
 	using DotNetOpenAuth.OpenId.Messages;
 	using DotNetOpenAuth.OpenId.RelyingParty;
@@ -63,7 +62,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 		[TestMethod]
 		public void ProviderVersion() {
 			var authRequest = this.CreateAuthenticationRequest(this.claimedId, this.claimedId);
-			Assert.AreEqual(this.protocol.Version, authRequest.DiscoveryResult.ProviderEndpoint.GetProtocol().Version);
+			Assert.AreEqual(this.protocol.Version, authRequest.DiscoveryResult.Version);
 		}
 
 		/// <summary>
@@ -184,7 +183,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 
 		private AuthenticationRequest CreateAuthenticationRequest(Identifier claimedIdentifier, Identifier providerLocalIdentifier) {
 			ProviderEndpointDescription providerEndpoint = new ProviderEndpointDescription(OPUri, this.protocol.Version);
-			IIdentifierDiscoveryResult endpoint = IdentifierDiscoveryResult.CreateForClaimedIdentifier(claimedIdentifier, providerLocalIdentifier, providerEndpoint, 10, 5);
+			IdentifierDiscoveryResult endpoint = IdentifierDiscoveryResult.CreateForClaimedIdentifier(claimedIdentifier, providerLocalIdentifier, providerEndpoint, 10, 5);
 			OpenIdRelyingParty rp = this.CreateRelyingParty();
 			return AuthenticationRequest.CreateForTest(endpoint, this.realm, this.returnTo, rp);
 		}
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
index 87969b1..701bcae 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/PositiveAuthenticationResponseTests.cs
@@ -38,7 +38,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 			Assert.AreEqual(AuthenticationStatus.Authenticated, authResponse.Status);
 			Assert.IsNull(authResponse.Exception);
 			Assert.AreEqual<string>(assertion.ClaimedIdentifier, authResponse.ClaimedIdentifier);
-			Assert.AreEqual<string>(authResponse.Endpoint.GetFriendlyIdentifierForDisplay(), authResponse.FriendlyIdentifierForDisplay);
+			Assert.AreEqual<string>(authResponse.Endpoint.FriendlyIdentifierForDisplay, authResponse.FriendlyIdentifierForDisplay);
 			Assert.AreSame(extension, authResponse.GetUntrustedExtension(typeof(ClaimsResponse)));
 			Assert.AreSame(extension, authResponse.GetUntrustedExtension<ClaimsResponse>());
 			Assert.IsNull(authResponse.GetCallbackArgument("a"));
diff --git a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/ServiceEndpointTests.cs b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/ServiceEndpointTests.cs
index 6718213..a7d9752 100644
--- a/src/DotNetOpenAuth.Test/OpenId/RelyingParty/ServiceEndpointTests.cs
+++ b/src/DotNetOpenAuth.Test/OpenId/RelyingParty/ServiceEndpointTests.cs
@@ -12,7 +12,6 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 	using System.Text;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId;
-	using DotNetOpenAuth.OpenId.DiscoveryServices;
 	using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
 	using DotNetOpenAuth.OpenId.Messages;
 	using DotNetOpenAuth.OpenId.RelyingParty;
@@ -31,43 +30,48 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 		private int servicePriority = 10;
 		private int uriPriority = 10;
 
+		[TestInitialize]
+		public override void SetUp() {
+			base.SetUp();
+		}
+
 		[TestMethod]
 		public void Ctor() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
 			Assert.AreEqual(this.claimedId, se.ClaimedIdentifier);
 			Assert.AreSame(this.providerEndpoint, se.ProviderEndpoint);
 			Assert.AreSame(this.localId, se.ProviderLocalIdentifier);
-			CollectionAssert<string>.AreEquivalent(this.v20TypeUris, se.ProviderEndpoint.Capabilities);
-			Assert.AreEqual(this.servicePriority, ((IXrdsProviderEndpoint)se).ServicePriority);
+			CollectionAssert<string>.AreEquivalent(this.v20TypeUris, se.Capabilities);
+			Assert.AreEqual(this.servicePriority, se.ServicePriority);
 		}
 
 		[TestMethod]
 		public void CtorImpliedLocalIdentifier() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, null, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, null, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
 			Assert.AreEqual(this.claimedId, se.ClaimedIdentifier);
 			Assert.AreSame(this.providerEndpoint, se.ProviderEndpoint);
 			Assert.AreSame(this.claimedId, se.ProviderLocalIdentifier);
-			CollectionAssert<string>.AreEquivalent(this.v20TypeUris, se.ProviderEndpoint.Capabilities);
+			CollectionAssert<string>.AreEquivalent(this.v20TypeUris, se.Capabilities);
 		}
 
 		[TestMethod]
 		public void ProtocolDetection() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
-			Assert.AreSame(Protocol.V20, se.ProviderEndpoint.GetProtocol());
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			Assert.AreSame(Protocol.V20, se.Protocol);
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
 				this.claimedId,
 				this.localId,
 				new ProviderEndpointDescription(this.providerEndpoint, new[] { Protocol.V20.OPIdentifierServiceTypeURI }),
 				this.servicePriority,
 				this.uriPriority);
-			Assert.AreSame(Protocol.V20, se.ProviderEndpoint.GetProtocol());
+			Assert.AreSame(Protocol.V20, se.Protocol);
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v11TypeUris), this.servicePriority, this.uriPriority);
-			Assert.AreSame(Protocol.V11, se.ProviderEndpoint.GetProtocol());
+			Assert.AreSame(Protocol.V11, se.Protocol);
 		}
 
 		[TestMethod, ExpectedException(typeof(ProtocolException))]
 		public void ProtocolDetectionWithoutClues() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
 				this.claimedId,
 				this.localId,
 				new ProviderEndpointDescription(this.providerEndpoint, new[] { Protocol.V20.HtmlDiscoveryLocalIdKey }), // random type URI irrelevant to detection
@@ -77,13 +81,13 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 
 		[TestMethod]
 		public void EqualsTests() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
-			IIdentifierDiscoveryResult se2 = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), (int?)null, (int?)null);
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			IdentifierDiscoveryResult se2 = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), (int?)null, (int?)null);
 			Assert.AreEqual(se2, se);
 			Assert.AreNotEqual(se, null);
 			Assert.AreNotEqual(null, se);
 
-			IIdentifierDiscoveryResult se3 = IdentifierDiscoveryResult.CreateForClaimedIdentifier(new UriIdentifier(this.claimedId + "a"), this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			IdentifierDiscoveryResult se3 = IdentifierDiscoveryResult.CreateForClaimedIdentifier(new UriIdentifier(this.claimedId + "a"), this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
 			Assert.AreNotEqual(se, se3);
 			se3 = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedId, this.localId, new ProviderEndpointDescription(new Uri(this.providerEndpoint.AbsoluteUri + "a"), this.v20TypeUris), this.servicePriority, this.uriPriority);
 			Assert.AreNotEqual(se, se3);
@@ -93,7 +97,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 			Assert.AreNotEqual(se, se3);
 
 			// make sure that Collection<T>.Contains works as desired.
-			var list = new List<IIdentifierDiscoveryResult>();
+			var list = new List<IdentifierDiscoveryResult>();
 			list.Add(se);
 			Assert.IsTrue(list.Contains(se2));
 		}
@@ -105,7 +109,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 			string[] serviceTypeUris = new string[] {
 				Protocol.V20.ClaimedIdentifierServiceTypeURI,
 			};
-			IIdentifierDiscoveryResult se;
+			IdentifierDiscoveryResult se;
 
 			// strip of protocol, port, query and fragment
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
@@ -114,12 +118,12 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 				new ProviderEndpointDescription(providerEndpoint, serviceTypeUris),
 				null,
 				null);
-			Assert.AreEqual("someprovider.somedomain.com/someuser", se.GetFriendlyIdentifierForDisplay());
+			Assert.AreEqual("someprovider.somedomain.com/someuser", se.FriendlyIdentifierForDisplay);
 
 			// unescape characters
 			Uri foreignUri = new Uri("http://server崎/村");
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(foreignUri, localId, new ProviderEndpointDescription(providerEndpoint, serviceTypeUris), null, null);
-			Assert.AreEqual("server崎/村", se.GetFriendlyIdentifierForDisplay());
+			Assert.AreEqual("server崎/村", se.FriendlyIdentifierForDisplay);
 
 			// restore user supplied identifier to XRIs
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
@@ -129,7 +133,7 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 				new ProviderEndpointDescription(providerEndpoint, serviceTypeUris),
 				null,
 				null);
-			Assert.AreEqual("=Arnott崎村", se.GetFriendlyIdentifierForDisplay());
+			Assert.AreEqual("=Arnott崎村", se.FriendlyIdentifierForDisplay);
 
 			// If UserSuppliedIdentifier is the same as the ClaimedIdentifier, don't display it twice...
 			se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(
@@ -139,26 +143,67 @@ namespace DotNetOpenAuth.Test.OpenId.RelyingParty {
 				new ProviderEndpointDescription(providerEndpoint, serviceTypeUris),
 				null,
 				null);
-			Assert.AreEqual("=!9B72.7DD1.50A9.5CCD", se.GetFriendlyIdentifierForDisplay());
+			Assert.AreEqual("=!9B72.7DD1.50A9.5CCD", se.FriendlyIdentifierForDisplay);
 		}
 
 		[TestMethod]
 		public void IsTypeUriPresent() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
-			Assert.IsTrue(se.ProviderEndpoint.IsTypeUriPresent(Protocol.Default.ClaimedIdentifierServiceTypeURI));
-			Assert.IsFalse(se.ProviderEndpoint.IsTypeUriPresent("http://someother"));
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			Assert.IsTrue(se.IsTypeUriPresent(Protocol.Default.ClaimedIdentifierServiceTypeURI));
+			Assert.IsFalse(se.IsTypeUriPresent("http://someother"));
 		}
 
 		[TestMethod, ExpectedException(typeof(ArgumentException))]
 		public void IsTypeUriPresentNull() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
-			se.ProviderEndpoint.IsTypeUriPresent(null);
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			se.IsTypeUriPresent(null);
 		}
 
 		[TestMethod, ExpectedException(typeof(ArgumentException))]
 		public void IsTypeUriPresentEmpty() {
-			IIdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
-			se.ProviderEndpoint.IsTypeUriPresent(string.Empty);
+			IdentifierDiscoveryResult se = IdentifierDiscoveryResult.CreateForClaimedIdentifier(this.claimedXri, this.userSuppliedXri, this.localId, new ProviderEndpointDescription(this.providerEndpoint, this.v20TypeUris), this.servicePriority, this.uriPriority);
+			se.IsTypeUriPresent(string.Empty);
+		}
+
+		[TestMethod, ExpectedException(typeof(ArgumentNullException))]
+		public void IsExtensionSupportedNullType() {
+			var se = IdentifierDiscoveryResult.CreateForProviderIdentifier(OPUri, new ProviderEndpointDescription(OPUri, this.v20TypeUris), null, null);
+			se.IsExtensionSupported((Type)null);
+		}
+
+		[TestMethod, ExpectedException(typeof(ArgumentException))]
+		public void IsTypeUriPresentNullString() {
+			var se = IdentifierDiscoveryResult.CreateForProviderIdentifier(OPUri, new ProviderEndpointDescription(OPUri, this.v20TypeUris), null, null);
+			se.IsTypeUriPresent((string)null);
+		}
+
+		[TestMethod, ExpectedException(typeof(ArgumentException))]
+		public void IsTypeUriPresentEmptyString() {
+			var se = IdentifierDiscoveryResult.CreateForProviderIdentifier(OPUri, new ProviderEndpointDescription(OPUri, this.v20TypeUris), null, null);
+			se.IsTypeUriPresent(string.Empty);
+		}
+
+		[TestMethod, ExpectedException(typeof(ArgumentNullException))]
+		public void IsExtensionSupportedNullExtension() {
+			var se = IdentifierDiscoveryResult.CreateForProviderIdentifier(OPUri, new ProviderEndpointDescription(OPUri, this.v20TypeUris), null, null);
+			se.IsExtensionSupported((IOpenIdMessageExtension)null);
+		}
+
+		[TestMethod]
+		public void IsExtensionSupported() {
+			var se = IdentifierDiscoveryResult.CreateForProviderIdentifier(OPUri, new ProviderEndpointDescription(OPUri, this.v20TypeUris), null, null);
+			Assert.IsFalse(se.IsExtensionSupported<ClaimsRequest>());
+			Assert.IsFalse(se.IsExtensionSupported(new ClaimsRequest()));
+			Assert.IsFalse(se.IsTypeUriPresent("http://someextension/typeuri"));
+
+			se = IdentifierDiscoveryResult.CreateForProviderIdentifier(
+				OPUri,
+				new ProviderEndpointDescription(OPUri, new[] { Protocol.V20.ClaimedIdentifierServiceTypeURI, "http://someextension", Constants.sreg_ns }),
+				null,
+				null);
+			Assert.IsTrue(se.IsExtensionSupported<ClaimsRequest>());
+			Assert.IsTrue(se.IsExtensionSupported(new ClaimsRequest()));
+			Assert.IsTrue(se.IsTypeUriPresent("http://someextension"));
 		}
 	}
 }