Merge branch 'v2.5' into monoorigin/mono

Conflicts:
	src/DotNetOpenId/Properties/AssemblyInfo.cs
	src/DotNetOpenId/RelyingParty/AuthenticationResponse.cs

8 files changed, 575 insertions, 129 deletions

diff --git a/src/DotNetOpenId.Test/RelyingParty/AuthenticationRequestTests.cs b/src/DotNetOpenId.Test/RelyingParty/AuthenticationRequestTests.cs
new file mode 100644
index 0000000..a1655ad
--- /dev/null
+++ b/src/DotNetOpenId.Test/RelyingParty/AuthenticationRequestTests.cs
@@ -0,0 +1,53 @@
+using System;

+using System.Collections.Generic;

+using System.Collections.Specialized;

+using System.Net;

+using System.Web;

+using DotNetOpenId.RelyingParty;

+using DotNetOpenId.Test.Mocks;

+using NUnit.Framework;

+

+namespace DotNetOpenId.Test.RelyingParty {

+	[TestFixture]

+	public class AuthenticationRequestTests {

+		Realm realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);

+		Uri returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);

+

+		[SetUp]

+		public void SetUp() {

+			if (!UntrustedWebRequest.WhitelistHosts.Contains("localhost"))

+				UntrustedWebRequest.WhitelistHosts.Add("localhost");

+		}

+

+		[TearDown]

+		public void TearDown() {

+			MockHttpRequest.Reset();

+		}

+

+		[Test]

+		public void Provider() {

+			OpenIdRelyingParty rp = new OpenIdRelyingParty(null, null, null);

+			Identifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+			IAuthenticationRequest request = rp.CreateRequest(id, realm, returnTo);

+			Assert.IsNotNull(request.Provider);

+		}

+

+		[Test]

+		public void AddCallbackArgumentReplacesExistingArguments() {

+			OpenIdRelyingParty rp = new OpenIdRelyingParty(null, null, null);

+			Identifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+

+			UriBuilder returnToWithParameter = new UriBuilder(returnTo);

+			UriUtil.AppendQueryArgs(returnToWithParameter, new Dictionary<string, string> { { "p1", "v1"} });

+

+			IAuthenticationRequest request = rp.CreateRequest(id, realm, returnToWithParameter.Uri);

+			request.AddCallbackArguments("p1", "v2");

+

+			Uri redirectUri = new Uri(request.RedirectingResponse.Headers[HttpResponseHeader.Location]);

+			NameValueCollection redirectArgs = HttpUtility.ParseQueryString(redirectUri.Query);

+			Uri returnToUri = new Uri(redirectArgs[Protocol.Default.openid.return_to]);

+			NameValueCollection returnToArgs = HttpUtility.ParseQueryString(returnToUri.Query);

+			Assert.AreEqual("v2", returnToArgs["p1"]);

+		}

+	}

+}

diff --git a/src/DotNetOpenId.Test/RelyingParty/AuthenticationResponseTests.cs b/src/DotNetOpenId.Test/RelyingParty/AuthenticationResponseTests.cs
index 7dcb792..532b379 100644
--- a/src/DotNetOpenId.Test/RelyingParty/AuthenticationResponseTests.cs
+++ b/src/DotNetOpenId.Test/RelyingParty/AuthenticationResponseTests.cs
@@ -1,14 +1,10 @@
 using System;

 using System.Collections.Generic;

-using System.Linq;

-using System.Text;

-using NUnit.Framework;

-using DotNetOpenId.RelyingParty;

-using System.Net;

-using System.Diagnostics;

-using System.IO;

-using System.Web;

 using System.Collections.Specialized;

+using System.Web;

+using DotNetOpenId.RelyingParty;

+using DotNetOpenId.Test.Mocks;

+using NUnit.Framework;

 

 namespace DotNetOpenId.Test.RelyingParty {

 	[TestFixture]

@@ -16,7 +12,6 @@ namespace DotNetOpenId.Test.RelyingParty {
 		Realm realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);

 		Uri returnTo;

 		const string returnToRemovableParameter = "a";

-		ApplicationMemoryStore store;

 

 		public AuthenticationResponseTests() {

 			UriBuilder builder = new UriBuilder(TestSupport.GetFullUrl(TestSupport.ConsumerPage));

@@ -28,38 +23,23 @@ namespace DotNetOpenId.Test.RelyingParty {
 

 		[SetUp]

 		public void SetUp() {

-			store = new ApplicationMemoryStore();

 			if (!UntrustedWebRequest.WhitelistHosts.Contains("localhost"))

 				UntrustedWebRequest.WhitelistHosts.Add("localhost");

 		}

 

+		[TearDown]

+		public void TearDown() {

+			MockHttpRequest.Reset();

+		}

+

 		Uri getPositiveAssertion(ProtocolVersion version) {

-			try {

-				OpenIdRelyingParty rp = new OpenIdRelyingParty(store, null, null);

-				Identifier id = TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, version);

-				var request = rp.CreateRequest(id, realm, returnTo);

-				HttpWebRequest providerRequest = (HttpWebRequest)WebRequest.Create(request.RedirectingResponse.ExtractUrl());

-				providerRequest.AllowAutoRedirect = false;

-				Uri redirectUrl;

-				try {

-					using (HttpWebResponse providerResponse = (HttpWebResponse)providerRequest.GetResponse()) {

-						Assert.AreEqual(HttpStatusCode.Redirect, providerResponse.StatusCode);

-						redirectUrl = new Uri(providerResponse.Headers[HttpResponseHeader.Location]);

-					}

-				} catch (WebException ex) {

-					Trace.WriteLine(ex);

-					if (ex.Response != null) {

-						using (StreamReader sr = new StreamReader(ex.Response.GetResponseStream())) {

-							Trace.WriteLine(sr.ReadToEnd());

-						}

-					}

-					throw;

-				}

-				return redirectUrl;

-			} catch (OpenIdException ex) {

-				Assert.Ignore("Test failed to verify good or bad behavior on account of failing to set itself up: {0}", ex);

-				return null; // Assert.Ignore will throw an exception anyway

-			}

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			Identifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, version);

+			var request = rp.CreateRequest(id, realm, returnTo);

+			var provider = TestSupport.CreateProviderForRequest(request);

+			var opRequest = provider.Request as DotNetOpenId.Provider.IAuthenticationRequest;

+			opRequest.IsAuthenticated = true;

+			return opRequest.Response.ExtractUrl();

 		}

 		void removeQueryParameter(ref Uri uri, string parameterToRemove) {

 			UriBuilder builder = new UriBuilder(uri);

@@ -92,7 +72,7 @@ namespace DotNetOpenId.Test.RelyingParty {
 		void resign(ref Uri uri) {

 			UriBuilder builder = new UriBuilder(uri);

 			NameValueCollection nvc = HttpUtility.ParseQueryString(builder.Query);

-			TestSupport.Resign(nvc, store);

+			TestSupport.Resign(nvc, TestSupport.RelyingPartyStore);

 			builder.Query = UriUtil.CreateQueryString(nvc);

 			uri = builder.Uri;

 		}

@@ -106,7 +86,7 @@ namespace DotNetOpenId.Test.RelyingParty {
 			// which should cause a failure because the return_to argument

 			// says that parameter is supposed to be there.

 			removeQueryParameter(ref assertion, returnToRemovableParameter);

-			var response = new OpenIdRelyingParty(store, assertion, HttpUtility.ParseQueryString(assertion.Query)).Response;

+			var response = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, assertion, HttpUtility.ParseQueryString(assertion.Query)).Response;

 			Assert.AreEqual(AuthenticationStatus.Failed, response.Status);

 			Assert.IsNotNull(response.Exception);

 		}

@@ -140,10 +120,44 @@ namespace DotNetOpenId.Test.RelyingParty {
 			resign(ref assertion); // resign changed URL to simulate a contrived OP for breaking into RPs.

 

 			// (triggers exception) "... you're in trouble up to your ears."

-			var response = new OpenIdRelyingParty(store, assertion, HttpUtility.ParseQueryString(assertion.Query)).Response;

+			var response = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, assertion, HttpUtility.ParseQueryString(assertion.Query)).Response;

 			Assert.AreEqual(AuthenticationStatus.Failed, response.Status);

 			Assert.IsNotNull(response.Exception);

 		}

 

+		[Test]

+		public void ClaimedIdentifierChangesAtProviderUnexpectedly() {

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			MockIdentifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.ApproveOnSetup, ProtocolVersion.V20);

+			id = FixLocalIdToMatchClaimedId(id); // don't make it look like a delegated auth

+			Identifier newClaimedId = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+			Identifier newLocalId = TestSupport.GetDelegateUrl(TestSupport.Scenarios.AutoApproval);

+			MockHttpRequest.RegisterMockXrdsResponse(new Uri(newClaimedId), newClaimedId.Discover());

+			var request = rp.CreateRequest(id, realm, returnTo);

+			var provider = TestSupport.CreateProviderForRequest(request);

+			var opRequest = provider.Request as DotNetOpenId.Provider.IAuthenticationRequest;

+			opRequest.IsAuthenticated = true;

+			opRequest.ClaimedIdentifier = newClaimedId;

+			opRequest.LocalIdentifier = newLocalId;

+			var assertion = opRequest.Response.ExtractUrl();

+			var response = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, assertion, HttpUtility.ParseQueryString(assertion.Query)).Response;

+			Assert.AreEqual(AuthenticationStatus.Authenticated, response.Status);

+		}

+

+		private MockIdentifier FixLocalIdToMatchClaimedId(MockIdentifier identifier) {

+			var newEndpoints = new List<ServiceEndpoint>();

+			foreach (ServiceEndpoint se in identifier.Discover()) {

+				newEndpoints.Add(ServiceEndpoint.CreateForClaimedIdentifier(

+					se.ClaimedIdentifier,

+					se.ClaimedIdentifier,

+					se.ProviderEndpoint,

+					se.ProviderSupportedServiceTypeUris,

+					null,

+					null));

+			}

+

+			MockIdentifier altered = new MockIdentifier(identifier, newEndpoints);

+			return altered;

+		}

 	}

 }

diff --git a/src/DotNetOpenId.Test/RelyingParty/IProviderEndpointTests.cs b/src/DotNetOpenId.Test/RelyingParty/IProviderEndpointTests.cs
new file mode 100644
index 0000000..8830691
--- /dev/null
+++ b/src/DotNetOpenId.Test/RelyingParty/IProviderEndpointTests.cs
@@ -0,0 +1,55 @@
+using System;

+using DotNetOpenId.Extensions.AttributeExchange;

+using DotNetOpenId.Extensions.SimpleRegistration;

+using DotNetOpenId.RelyingParty;

+using NUnit.Framework;

+using DotNetOpenId.Test.Mocks;

+

+namespace DotNetOpenId.Test.RelyingParty {

+	[TestFixture]

+	public class IProviderEndpointTests {

+		IRelyingPartyApplicationStore store;

+		Realm realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);

+		Uri returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);

+

+		[SetUp]

+		public void SetUp() {

+			store = new ApplicationMemoryStore();

+			if (!UntrustedWebRequest.WhitelistHosts.Contains("localhost"))

+				UntrustedWebRequest.WhitelistHosts.Add("localhost");

+		}

+

+		[TearDown]

+		public void TearDown() {

+			Mocks.MockHttpRequest.Reset();

+		}

+

+		[Test]

+		public void IsExtensionSupportedTest() {

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			Identifier id = MockHttpRequest.RegisterMockXrdsResponse("/Discovery/xrdsdiscovery/xrds20.xml");

+			IAuthenticationRequest request = rp.CreateRequest(id, TestSupport.Realm, TestSupport.ReturnTo);

+			IProviderEndpoint provider = request.Provider;

+			Assert.IsTrue(provider.IsExtensionSupported<ClaimsRequest>());

+			Assert.IsTrue(provider.IsExtensionSupported(typeof(ClaimsRequest)));

+			Assert.IsFalse(provider.IsExtensionSupported<FetchRequest>());

+			Assert.IsFalse(provider.IsExtensionSupported(typeof(FetchRequest)));

+

+			// Test the AdditionalTypeUris list by pulling from an XRDS page with one of the

+			// TypeURIs that only shows up in that list.

+			id = MockHttpRequest.RegisterMockXrdsResponse("/Discovery/xrdsdiscovery/xrds10.xml");

+			request = rp.CreateRequest(id, realm, returnTo);

+			Assert.IsTrue(provider.IsExtensionSupported<ClaimsRequest>());

+			Assert.IsTrue(provider.IsExtensionSupported(typeof(ClaimsRequest)));

+		}

+

+		[Test]

+		public void UriTest() {

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			Identifier id = MockHttpRequest.RegisterMockXrdsResponse("/Discovery/xrdsdiscovery/xrds20.xml");

+			IAuthenticationRequest request = rp.CreateRequest(id, TestSupport.Realm, TestSupport.ReturnTo);

+			IProviderEndpoint provider = request.Provider;

+			Assert.AreEqual(new Uri("http://a/b"), provider.Uri);

+		}

+	}

+}

diff --git a/src/DotNetOpenId.Test/RelyingParty/OpenIdMobileTextBoxTest.cs b/src/DotNetOpenId.Test/RelyingParty/OpenIdMobileTextBoxTest.cs
deleted file mode 100644
index 0feea56..0000000
--- a/src/DotNetOpenId.Test/RelyingParty/OpenIdMobileTextBoxTest.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using System;

-using System.Collections.Generic;

-using System.Linq;

-using System.Text;

-using NUnit.Framework;

-

-namespace DotNetOpenId.Test.RelyingParty {

-	[TestFixture]

-	public class OpenIdMobileTextBoxTest {

-		[Test]

-		public void TextBoxAppears() {

-			string html = TestSupport.Host.ProcessRequest(TestSupport.MobileConsumerPage);

-			Assert.IsTrue(html.Contains("<input "));

-		}

-	}

-}

diff --git a/src/DotNetOpenId.Test/RelyingParty/OpenIdRelyingPartyTest.cs b/src/DotNetOpenId.Test/RelyingParty/OpenIdRelyingPartyTest.cs
index ddef8a3..cf9a795 100644
--- a/src/DotNetOpenId.Test/RelyingParty/OpenIdRelyingPartyTest.cs
+++ b/src/DotNetOpenId.Test/RelyingParty/OpenIdRelyingPartyTest.cs
@@ -1,14 +1,15 @@
 using System;

+using System.Collections.Generic;

+using System.Collections.Specialized;

+using System.Web;

 using DotNetOpenId.RelyingParty;

+using DotNetOpenId.Test.Mocks;

 using NUnit.Framework;

-using ProviderMemoryStore = DotNetOpenId.AssociationMemoryStore<DotNetOpenId.AssociationRelyingPartyType>;

-using System.Web;

-using System.Collections.Specialized;

+using OpenIdProvider = DotNetOpenId.Provider.OpenIdProvider;

 

 namespace DotNetOpenId.Test.RelyingParty {

 	[TestFixture]

 	public class OpenIdRelyingPartyTest {

-		IRelyingPartyApplicationStore store;

 		UriIdentifier simpleOpenId = new UriIdentifier("http://nonexistant.openid.com");

 		readonly Realm realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);

 		readonly Uri returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);

@@ -16,11 +17,15 @@ namespace DotNetOpenId.Test.RelyingParty {
 

 		[SetUp]

 		public void Setup() {

-			store = new ApplicationMemoryStore();

 			if (!UntrustedWebRequest.WhitelistHosts.Contains("localhost"))

 				UntrustedWebRequest.WhitelistHosts.Add("localhost");

 		}

 

+		[TearDown]

+		public void TearDown() {

+			MockHttpRequest.Reset();

+		}

+

 		[Test]

 		[ExpectedException(typeof(InvalidOperationException))]

 		public void DefaultCtorWithoutContext() {

@@ -29,7 +34,7 @@ namespace DotNetOpenId.Test.RelyingParty {
 

 		[Test]

 		public void CtorWithNullRequestUri() {

-			new OpenIdRelyingParty(store, null, null);

+			new OpenIdRelyingParty(new ApplicationMemoryStore(), null, null);

 		}

 

 		[Test]

@@ -40,50 +45,82 @@ namespace DotNetOpenId.Test.RelyingParty {
 		[Test]

 		[ExpectedException(typeof(InvalidOperationException))]

 		public void CreateRequestWithoutContext1() {

-			var consumer = new OpenIdRelyingParty(store, simpleNonOpenIdRequest, new NameValueCollection());

+			var consumer = new OpenIdRelyingParty(new ApplicationMemoryStore(), simpleNonOpenIdRequest, new NameValueCollection());

 			consumer.CreateRequest(simpleOpenId);

 		}

 

 		[Test]

 		[ExpectedException(typeof(InvalidOperationException))]

 		public void CreateRequestWithoutContext2() {

-			var consumer = new OpenIdRelyingParty(store, simpleNonOpenIdRequest, new NameValueCollection());

+			var consumer = new OpenIdRelyingParty(new ApplicationMemoryStore(), simpleNonOpenIdRequest, new NameValueCollection());

 			consumer.CreateRequest(simpleOpenId, realm);

 		}

 

+		[Test, ExpectedException(typeof(ArgumentNullException))]

+		public void CreateRequestNullIdentifier() {

+			var consumer = TestSupport.CreateRelyingParty(null);

+			consumer.CreateRequest(null, realm, returnTo);

+		}

+

+		[Test, ExpectedException(typeof(ArgumentNullException))]

+		public void CreateRequestNullRealm() {

+			var consumer = TestSupport.CreateRelyingParty(null);

+			consumer.CreateRequest("=someEndpoint", null, returnTo);

+		}

+

+		[Test, ExpectedException(typeof(ArgumentNullException))]

+		public void CreateRequestNullReturnTo() {

+			var consumer = TestSupport.CreateRelyingParty(null);

+			consumer.CreateRequest("=someEndpoint", realm, null);

+		}

+

+		[Test]

+		public void CreateRequestStripsFragment() {

+			var consumer = TestSupport.CreateRelyingParty(null);

+			UriBuilder userSuppliedIdentifier = new UriBuilder((Uri)TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20));

+			userSuppliedIdentifier.Fragment = "c";

+			Identifier mockIdentifer = new MockIdentifier(userSuppliedIdentifier.Uri,

+				TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20).Discover());

+			Assert.IsTrue(mockIdentifer.ToString().EndsWith("#c"), "Test broken");

+			IAuthenticationRequest request = consumer.CreateRequest(mockIdentifer, TestSupport.Realm, TestSupport.ReturnTo);

+			Assert.AreEqual(0, new Uri(request.ClaimedIdentifier).Fragment.Length);

+		}

+

 		[Test]

 		public void AssociationCreationWithStore() {

-			var providerStore = new ProviderMemoryStore();

+			TestSupport.ResetStores(); // get rid of existing associations so a new one is created

 

-			OpenIdRelyingParty rp = new OpenIdRelyingParty(new ApplicationMemoryStore(), null, null);

-			var idUrl = TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			var directMessageSniffer = new DirectMessageSniffWrapper(rp.DirectMessageChannel);

+			rp.DirectMessageChannel = directMessageSniffer;

+			var idUrl = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

 

 			DotNetOpenId.RelyingParty.IAuthenticationRequest req;

 			bool associationMade = false;

-			TestSupport.Interceptor.SigningMessage = m => {

-				if (m.EncodedFields.ContainsKey("assoc_handle") && m.EncodedFields.ContainsKey("session_type"))

+			directMessageSniffer.Receiving += (provider, fields) => {

+				if (fields.ContainsKey("assoc_handle") && fields.ContainsKey("session_type"))

 					associationMade = true;

 			};

 			req = rp.CreateRequest(idUrl, realm, returnTo);

-			TestSupport.Interceptor.SigningMessage = null;

 			Assert.IsTrue(associationMade);

 		}

 

 		[Test]

 		public void NoAssociationRequestWithoutStore() {

-			var providerStore = new ProviderMemoryStore();

+			TestSupport.ResetStores(); // get rid of existing associations so a new one is created

 

-			OpenIdRelyingParty rp = new OpenIdRelyingParty(null, null, null);

-			var idUrl = TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null, null);

+			var directMessageSniffer = new DirectMessageSniffWrapper(rp.DirectMessageChannel);

+			rp.DirectMessageChannel = directMessageSniffer;

+			var idUrl = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

 

 			DotNetOpenId.RelyingParty.IAuthenticationRequest req;

 			bool associationMade = false;

-			TestSupport.Interceptor.SigningMessage = m => {

-				if (m.EncodedFields.ContainsKey("assoc_handle") && m.EncodedFields.ContainsKey("session_type"))

+			directMessageSniffer.Receiving += (provider, fields) => {

+				if (fields.ContainsKey("assoc_handle") && fields.ContainsKey("session_type"))

 					associationMade = true;

 			};

 			req = rp.CreateRequest(idUrl, realm, returnTo);

-			TestSupport.Interceptor.SigningMessage = null;

 			Assert.IsFalse(associationMade);

 		}

 

@@ -113,10 +150,8 @@ namespace DotNetOpenId.Test.RelyingParty {
 		}

 

 		private static void testExplicitPortOnRealmAndReturnTo(Uri returnTo, Realm realm) {

-			var identityUrl = TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

-			var consumer = new OpenIdRelyingParty(null, null, null);

-			var request = consumer.CreateRequest(identityUrl, realm, returnTo);

-			Protocol protocol = Protocol.Lookup(request.ProviderVersion);

+			var request = TestSupport.CreateRelyingPartyRequest(true, TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20, false);

+			Protocol protocol = Protocol.Lookup(request.Provider.Version);

 			var nvc = HttpUtility.ParseQueryString(request.RedirectingResponse.ExtractUrl().Query);

 			string realmString = nvc[protocol.openid.Realm];

 			string returnToString = nvc[protocol.openid.return_to];

@@ -132,15 +167,279 @@ namespace DotNetOpenId.Test.RelyingParty {
 

 		[Test]

 		public void ReturnToUrlEncodingTest() {

-			Uri origin = TestSupport.GetFullUrl(TestSupport.ConsumerPage);

-			var identityUrl = TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

-			var consumer = new OpenIdRelyingParty(null, null, null);

-			var request = consumer.CreateRequest(identityUrl, origin, origin);

-			Protocol protocol = Protocol.Lookup(request.ProviderVersion);

+			var request = TestSupport.CreateRelyingPartyRequest(true, TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20, false);

+			Protocol protocol = Protocol.Lookup(request.Provider.Version);

 			request.AddCallbackArguments("a+b", "c+d");

 			var requestArgs = HttpUtility.ParseQueryString(request.RedirectingResponse.ExtractUrl().Query);

 			var returnToArgs = HttpUtility.ParseQueryString(requestArgs[protocol.openid.return_to]);

 			Assert.AreEqual("c+d", returnToArgs["a+b"]);

 		}

+

+		static ServiceEndpoint getServiceEndpoint(int? servicePriority, int? uriPriority) {

+			Protocol protocol = Protocol.v20;

+			ServiceEndpoint ep = ServiceEndpoint.CreateForClaimedIdentifier(

+				TestSupport.GetIdentityUrl(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20),

+				TestSupport.GetDelegateUrl(TestSupport.Scenarios.AutoApproval),

+				TestSupport.GetFullUrl(TestSupport.ProviderPage),

+				new[] { protocol.ClaimedIdentifierServiceTypeURI },

+				servicePriority,

+				uriPriority

+				);

+			return ep;

+		}

+

+		[Test]

+		public void DefaultEndpointOrder() {

+			var consumer = new OpenIdRelyingParty(null, null, null);

+			Assert.AreSame(OpenIdRelyingParty.DefaultEndpointOrder, consumer.EndpointOrder);

+			var defaultEndpointOrder = OpenIdRelyingParty.DefaultEndpointOrder;

+			// Test service priority ordering

+			Assert.AreEqual(-1, defaultEndpointOrder(getServiceEndpoint(10, null), getServiceEndpoint(20, null)));

+			Assert.AreEqual(1, defaultEndpointOrder(getServiceEndpoint(20, null), getServiceEndpoint(10, null)));

+			Assert.AreEqual(0, defaultEndpointOrder(getServiceEndpoint(10, null), getServiceEndpoint(10, null)));

+			Assert.AreEqual(-1, defaultEndpointOrder(getServiceEndpoint(20, null), getServiceEndpoint(null, null)));

+			Assert.AreEqual(1, defaultEndpointOrder(getServiceEndpoint(null, null), getServiceEndpoint(10, null)));

+			Assert.AreEqual(0, defaultEndpointOrder(getServiceEndpoint(null, null), getServiceEndpoint(null, null)));

+			// Test secondary type uri ordering

+			Assert.AreEqual(-1, defaultEndpointOrder(getServiceEndpoint(10, 10), getServiceEndpoint(10, 20)));

+			Assert.AreEqual(1, defaultEndpointOrder(getServiceEndpoint(10, 20), getServiceEndpoint(10, 10)));

+			Assert.AreEqual(0, defaultEndpointOrder(getServiceEndpoint(10, 5), getServiceEndpoint(10, 5)));

+			// test that it is secondary...

+			Assert.AreEqual(1, defaultEndpointOrder(getServiceEndpoint(20, 10), getServiceEndpoint(10, 20)));

+			Assert.AreEqual(-1, defaultEndpointOrder(getServiceEndpoint(null, 10), getServiceEndpoint(null, 20)));

+			Assert.AreEqual(1, defaultEndpointOrder(getServiceEndpoint(null, 20), getServiceEndpoint(null, 10)));

+			Assert.AreEqual(0, defaultEndpointOrder(getServiceEndpoint(null, 10), getServiceEndpoint(null, 10)));

+		}

+

+		[Test]

+		public void DefaultFilter() {

+			var consumer = new OpenIdRelyingParty(null, null, null);

+			Assert.IsNull(consumer.EndpointFilter);

+		}

+

+		[Test]

+		public void MultipleServiceEndpoints() {

+			string xrds = @"<?xml version='1.0' encoding='UTF-8'?>

+<XRD xmlns='xri://$xrd*($v*2.0)'>

+ <Query>=MultipleEndpoint</Query>

+ <Status cid='verified' code='100' />

+ <ProviderID>=!91F2.8153.F600.AE24</ProviderID>

+ <CanonicalID>=!91F2.8153.F600.AE24</CanonicalID>

+ <Service>

+  <ProviderID>@!7F6F.F50.A4E4.1133</ProviderID>

+  <Type select='true'>xri://+i-service*(+contact)*($v*1.0)</Type>

+  <Type match='null'/>

+  <Path select='true'>(+contact)</Path>

+  <Path match='null'/>

+  <MediaType match='default'/>

+  <URI append='qxri'>http://contact.freexri.com/contact/</URI>

+ </Service>

+ <Service priority='20'>

+  <ProviderID>@!7F6F.F50.A4E4.1133</ProviderID>

+  <Type select='true'>http://openid.net/signon/1.0</Type>

+  <Path select='true'>(+login)</Path>

+  <Path match='default'/>

+  <MediaType match='default'/>

+  <URI append='none' priority='2'>http://authn.freexri.com/auth10/</URI>

+  <URI append='none' priority='1'>https://authn.freexri.com/auth10/</URI>

+ </Service>

+ <Service priority='10'>

+  <ProviderID>@!7F6F.F50.A4E4.1133</ProviderID>

+  <Type select='true'>http://specs.openid.net/auth/2.0/signon</Type>

+  <Path select='true'>(+login)</Path>

+  <Path match='default'/>

+  <MediaType match='default'/>

+  <URI append='none' priority='2'>http://authn.freexri.com/auth20/</URI>

+  <URI append='none' priority='1'>https://authn.freexri.com/auth20/</URI>

+ </Service>

+ <ServedBy>OpenXRI</ServedBy>

+</XRD>";

+			MockHttpRequest.RegisterMockXrdsResponses(new Dictionary<string, string> {

+				{"https://xri.net/=MultipleEndpoint?_xrd_r=application/xrd%2Bxml;sep=false", xrds},

+			});

+			OpenIdRelyingParty rp = new OpenIdRelyingParty(null, null, null);

+			Realm realm = new Realm("http://somerealm");

+			Uri return_to = new Uri("http://somerealm/return_to");

+			IAuthenticationRequest request = rp.CreateRequest("=MultipleEndpoint", realm, return_to);

+			Assert.AreEqual("https://authn.freexri.com/auth20/", request.Provider.Uri.AbsoluteUri);

+			rp.EndpointOrder = (se1, se2) => -se1.ServicePriority.Value.CompareTo(se2.ServicePriority.Value);

+			request = rp.CreateRequest("=MultipleEndpoint", realm, return_to);

+			Assert.AreEqual("https://authn.freexri.com/auth10/", request.Provider.Uri.AbsoluteUri);

+

+			// Now test the filter.  Auth20 would come out on top, if we didn't select it out with the filter.

+			rp.EndpointOrder = OpenIdRelyingParty.DefaultEndpointOrder;

+			rp.EndpointFilter = (se) => se.Uri.AbsoluteUri == "https://authn.freexri.com/auth10/";

+			request = rp.CreateRequest("=MultipleEndpoint", realm, return_to);

+			Assert.AreEqual("https://authn.freexri.com/auth10/", request.Provider.Uri.AbsoluteUri);

+		}

+

+		private string stripScheme(string identifier) {

+			return identifier.Substring(identifier.IndexOf("://") + 3);

+		}

+

+		[Test]

+		public void RequireSslPrependsHttpsScheme() {

+			MockHttpRequest.Reset();

+			OpenIdRelyingParty rp = TestSupport.CreateRelyingParty(null);

+			rp.Settings.RequireSsl = true;

+			Identifier mockId = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20, true);

+			string noSchemeId = stripScheme(mockId);

+			var request = rp.CreateRequest(noSchemeId, TestSupport.Realm, TestSupport.ReturnTo);

+			Assert.IsTrue(request.ClaimedIdentifier.ToString().StartsWith("https://", StringComparison.OrdinalIgnoreCase));

+		}

+

+		[Test]

+		public void DirectedIdentityWithRequireSslSucceeds() {

+			Uri claimedId = TestSupport.GetFullUrl("/secureClaimedId", null, true);

+			Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.AutoApproval, claimedId, true, true);

+			var rp = TestSupport.CreateRelyingParty(null);

+			rp.Settings.RequireSsl = true;

+			var rpRequest = rp.CreateRequest(opIdentifier, TestSupport.Realm, TestSupport.ReturnTo);

+			var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(rpRequest, opRequest => {

+				opRequest.IsAuthenticated = true;

+				opRequest.ClaimedIdentifier = claimedId;

+			});

+			Assert.AreEqual(AuthenticationStatus.Authenticated, rpResponse.Status);

+		}

+

+		[Test]

+		public void DirectedIdentityWithRequireSslFailsWithoutSecureIdentity() {

+			Uri claimedId = TestSupport.GetFullUrl("/insecureClaimedId", null, false);

+			Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.AutoApproval, claimedId, true, true);

+			var rp = TestSupport.CreateRelyingParty(null);

+			rp.Settings.RequireSsl = true;

+			var rpRequest = rp.CreateRequest(opIdentifier, TestSupport.Realm, TestSupport.ReturnTo);

+			var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(rpRequest, opRequest => {

+				opRequest.IsAuthenticated = true;

+				opRequest.ClaimedIdentifier = claimedId;

+			});

+			Assert.AreEqual(AuthenticationStatus.Failed, rpResponse.Status);

+		}

+

+		[Test]

+		public void DirectedIdentityWithRequireSslFailsWithoutSecureProviderEndpoint() {

+			Uri claimedId = TestSupport.GetFullUrl("/secureClaimedId", null, true);

+			// We want to generate an OP Identifier that itself is secure, but whose

+			// XRDS doc describes an insecure provider endpoint.

+			Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.AutoApproval, claimedId, true, false);

+			var rp = TestSupport.CreateRelyingParty(null);

+			rp.Settings.RequireSsl = true;

+			var rpRequest = rp.CreateRequest(opIdentifier, TestSupport.Realm, TestSupport.ReturnTo);

+			var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(rpRequest, opRequest => {

+				opRequest.IsAuthenticated = true;

+				opRequest.ClaimedIdentifier = claimedId;

+			});

+			Assert.AreEqual(AuthenticationStatus.Failed, rpResponse.Status);

+		}

+

+		[Test]

+		public void UnsolicitedAssertionWithRequireSsl() {

+			MockHttpRequest.Reset();

+			Mocks.MockHttpRequest.RegisterMockRPDiscovery();

+			TestSupport.Scenarios scenario = TestSupport.Scenarios.AutoApproval;

+			Identifier claimedId = TestSupport.GetMockIdentifier(scenario, ProtocolVersion.V20, true);

+			Identifier localId = TestSupport.GetDelegateUrl(scenario, true);

+

+			OpenIdProvider op = TestSupport.CreateProvider(null, true);

+			IResponse assertion = op.PrepareUnsolicitedAssertion(TestSupport.Realm, claimedId, localId);

+

+			var opAuthWebResponse = (Response)assertion;

+			var opAuthResponse = (DotNetOpenId.Provider.EncodableResponse)opAuthWebResponse.EncodableMessage;

+			var rp = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, opAuthResponse.RedirectUrl,

+				opAuthResponse.EncodedFields.ToNameValueCollection());

+			rp.Settings.RequireSsl = true;

+

+			Assert.AreEqual(AuthenticationStatus.Authenticated, rp.Response.Status);

+			Assert.AreEqual(claimedId, rp.Response.ClaimedIdentifier);

+		}

+

+		[Test]

+		public void UnsolicitedAssertionWithRequireSslWithoutSecureIdentityUrl() {

+			MockHttpRequest.Reset();

+			Mocks.MockHttpRequest.RegisterMockRPDiscovery();

+			TestSupport.Scenarios scenario = TestSupport.Scenarios.AutoApproval;

+			Identifier claimedId = TestSupport.GetMockIdentifier(scenario, ProtocolVersion.V20);

+			Identifier localId = TestSupport.GetDelegateUrl(scenario);

+

+			OpenIdProvider op = TestSupport.CreateProvider(null);

+			IResponse assertion = op.PrepareUnsolicitedAssertion(TestSupport.Realm, claimedId, localId);

+

+			var opAuthWebResponse = (Response)assertion;

+			var opAuthResponse = (DotNetOpenId.Provider.EncodableResponse)opAuthWebResponse.EncodableMessage;

+			var rp = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, opAuthResponse.RedirectUrl,

+				opAuthResponse.EncodedFields.ToNameValueCollection());

+			rp.Settings.RequireSsl = true;

+

+			Assert.AreEqual(AuthenticationStatus.Failed, rp.Response.Status);

+			Assert.IsNull(rp.Response.ClaimedIdentifier);

+		}

+

+		[Test]

+		public void UnsolicitedAssertionWithRequireSslWithSecureIdentityButInsecureProviderEndpoint() {

+			MockHttpRequest.Reset();

+			Mocks.MockHttpRequest.RegisterMockRPDiscovery();

+			TestSupport.Scenarios scenario = TestSupport.Scenarios.AutoApproval;

+			ProtocolVersion version = ProtocolVersion.V20;

+			ServiceEndpoint providerEndpoint = TestSupport.GetServiceEndpoint(scenario, version, 10, false);

+			Identifier claimedId = new MockIdentifier(TestSupport.GetIdentityUrl(scenario, version, true), 

+				new ServiceEndpoint[] { providerEndpoint });

+			Identifier localId = TestSupport.GetDelegateUrl(scenario, true);

+

+			OpenIdProvider op = TestSupport.CreateProvider(null, false);

+			IResponse assertion = op.PrepareUnsolicitedAssertion(TestSupport.Realm, claimedId, localId);

+

+			var opAuthWebResponse = (Response)assertion;

+			var opAuthResponse = (DotNetOpenId.Provider.EncodableResponse)opAuthWebResponse.EncodableMessage;

+			var rp = TestSupport.CreateRelyingParty(TestSupport.RelyingPartyStore, opAuthResponse.RedirectUrl,

+				opAuthResponse.EncodedFields.ToNameValueCollection());

+			rp.Settings.RequireSsl = true;

+

+			Assert.AreEqual(AuthenticationStatus.Failed, rp.Response.Status);

+			Assert.IsNull(rp.Response.ClaimedIdentifier);

+		}

+

+		/// <summary>

+		/// Verifies that an RP will not "discover" endpoints below OpenID 2.0 when appropriate.

+		/// </summary>

+		[Test, ExpectedException(typeof(OpenIdException))]

+		public void MinimumOPVersion20() {

+			MockIdentifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V11);

+

+			var rp = TestSupport.CreateRelyingParty(null);

+			rp.Settings.MinimumRequiredOpenIdVersion = ProtocolVersion.V20;

+			rp.CreateRequest(id, TestSupport.Realm, TestSupport.ReturnTo);

+		}

+

+		/// <summary>

+		/// Verifies that an RP configured to require 2.0 OPs will fail on communicating with 1.x OPs

+		/// that merely advertise 2.0 support but don't really have it.

+		/// </summary>

+		[Test]

+		public void MinimumOPVersion20WithDeceptiveEndpointRealizedAtAuthentication() {

+			// Create an identifier that claims to have a 2.0 OP endpoint.

+			MockIdentifier id = TestSupport.GetMockIdentifier(TestSupport.Scenarios.AutoApproval, ProtocolVersion.V20);

+

+			var rp = TestSupport.CreateRelyingParty(null, null);

+

+			IAuthenticationRequest req = rp.CreateRequest(id, TestSupport.Realm, TestSupport.ReturnTo);

+			IResponse providerResponse = TestSupport.CreateProviderResponseToRequest(req, opReq => {

+				opReq.IsAuthenticated = true;

+			});

+

+			var opAuthWebResponse = (Response)providerResponse;

+			var opAuthResponse = (DotNetOpenId.Provider.EncodableResponse)opAuthWebResponse.EncodableMessage;

+			var rp2 =TestSupport. CreateRelyingParty(null, opAuthResponse.RedirectUrl,

+				opAuthResponse.EncodedFields.ToNameValueCollection());

+			rp2.Settings.MinimumRequiredOpenIdVersion = ProtocolVersion.V20;

+			// Rig an intercept between the provider and RP to make our own Provider LOOK like a 1.x provider.

+			var sniffer = new DirectMessageSniffWrapper(rp2.DirectMessageChannel);

+			rp2.DirectMessageChannel = sniffer;

+			sniffer.Receiving += (endpoint, fields) => {

+				fields.Remove(Protocol.v20.openidnp.ns);

+			};

+			var resp = rp2.Response;

+

+			Assert.AreEqual(AuthenticationStatus.Failed, resp.Status, "Authentication should have failed since OP is really a 1.x OP masquerading as a 2.0 OP.");

+		}

 	}

 }

diff --git a/src/DotNetOpenId.Test/RelyingParty/OpenIdTextBoxTest.cs b/src/DotNetOpenId.Test/RelyingParty/OpenIdTextBoxTest.cs
deleted file mode 100644
index 9176096..0000000
--- a/src/DotNetOpenId.Test/RelyingParty/OpenIdTextBoxTest.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System;

-using System.Collections.Generic;

-using System.Text;

-using NUnit.Framework;

-using DotNetOpenId.Test.Hosting;

-using System.Net;

-

-namespace DotNetOpenId.Test.RelyingParty {

-	[TestFixture]

-	public class OpenIdTextBoxTest {

-		[Test]

-		public void TextBoxAppears() {

-			string html = TestSupport.Host.ProcessRequest(TestSupport.ConsumerPage);

-			Assert.IsTrue(html.Contains("<input "));

-		}

-	}

-}

diff --git a/src/DotNetOpenId.Test/RelyingParty/ServiceEndpointTests.cs b/src/DotNetOpenId.Test/RelyingParty/ServiceEndpointTests.cs
index b85044b..d2677b8 100644
--- a/src/DotNetOpenId.Test/RelyingParty/ServiceEndpointTests.cs
+++ b/src/DotNetOpenId.Test/RelyingParty/ServiceEndpointTests.cs
@@ -1,32 +1,37 @@
 using System;

 using System.Collections.Generic;

-using System.Linq;

+using System.IO;

 using System.Text;

-using NUnit.Framework;

 using DotNetOpenId.RelyingParty;

-using System.IO;

+using NUnit.Framework;

+using System.Diagnostics;

 

 namespace DotNetOpenId.Test.RelyingParty {

 	[TestFixture]

 	public class ServiceEndpointTests {

-		Identifier claimedId = "http://claimedid.justatest.com";

+		UriIdentifier claimedId = new UriIdentifier("http://claimedid.justatest.com");

+		XriIdentifier claimedXri = new XriIdentifier("=!9B72.7DD1.50A9.5CCD");

+		XriIdentifier userSuppliedXri = new XriIdentifier("=Arnot");

 		Uri providerEndpoint = new Uri("http://someprovider.com");

 		Identifier localId = "http://localid.someprovider.com";

 		string[] v20TypeUris = { Protocol.v20.ClaimedIdentifierServiceTypeURI };

 		string[] v11TypeUris = { Protocol.v11.ClaimedIdentifierServiceTypeURI };

+		int servicePriority = 10;

+		int uriPriority = 10;

 

 		[Test]

 		public void Ctor() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, localId, v20TypeUris);

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			Assert.AreSame(claimedId, se.ClaimedIdentifier);

 			Assert.AreSame(providerEndpoint, se.ProviderEndpoint);

 			Assert.AreSame(localId, se.ProviderLocalIdentifier);

 			Assert.AreSame(v20TypeUris, se.ProviderSupportedServiceTypeUris);

+			Assert.AreEqual(servicePriority, ((IXrdsProviderEndpoint)se).ServicePriority);

 		}

 

 		[Test]

 		public void CtorImpliedLocalIdentifier() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, null, v20TypeUris);

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, null, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			Assert.AreSame(claimedId, se.ClaimedIdentifier);

 			Assert.AreSame(providerEndpoint, se.ProviderEndpoint);

 			Assert.AreSame(claimedId, se.ProviderLocalIdentifier);

@@ -35,25 +40,26 @@ namespace DotNetOpenId.Test.RelyingParty {
 

 		[Test]

 		public void ProtocolDetection() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, localId, v20TypeUris);

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			Assert.AreSame(Protocol.v20, se.Protocol);

-			se = new ServiceEndpoint(claimedId, providerEndpoint, localId,

-				new[] { Protocol.v20.OPIdentifierServiceTypeURI });

+			se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint,

+				new[] { Protocol.v20.OPIdentifierServiceTypeURI }, servicePriority, uriPriority);

 			Assert.AreSame(Protocol.v20, se.Protocol);

-			se = new ServiceEndpoint(claimedId, providerEndpoint, localId, v11TypeUris);

+			se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v11TypeUris, servicePriority, uriPriority);

 			Assert.AreSame(Protocol.v11, se.Protocol);

 		}

 

 		[Test, ExpectedException(typeof(InvalidOperationException))]

 		public void ProtocolDetectionWithoutClues() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, localId,

-				new[] { Protocol.v20.HtmlDiscoveryLocalIdKey }); // random type URI irrelevant to detection

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(

+				claimedId, localId, providerEndpoint,

+				new[] { Protocol.v20.HtmlDiscoveryLocalIdKey }, servicePriority, uriPriority); // random type URI irrelevant to detection

 			Protocol p = se.Protocol;

 		}

 

 		[Test]

-		public void Serialization() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, localId, v20TypeUris);

+		public void SerializationWithUri() {

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			StringBuilder sb = new StringBuilder();

 			using (StringWriter sw = new StringWriter(sb)) {

 				se.Serialize(sw);

@@ -62,25 +68,79 @@ namespace DotNetOpenId.Test.RelyingParty {
 				ServiceEndpoint se2 = ServiceEndpoint.Deserialize(sr);

 				Assert.AreEqual(se, se2);

 				Assert.AreEqual(se.Protocol.Version, se2.Protocol.Version, "Particularly interested in this, since type URIs are not serialized but version info is.");

+				Assert.AreEqual(se.UserSuppliedIdentifier, se2.UserSuppliedIdentifier);

+				Assert.AreEqual(se.FriendlyIdentifierForDisplay, se2.FriendlyIdentifierForDisplay);

+			}

+		}

+

+		[Test]

+		public void SerializationWithXri() {

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedXri, userSuppliedXri, localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

+			StringBuilder sb = new StringBuilder();

+			using (StringWriter sw = new StringWriter(sb)) {

+				se.Serialize(sw);

+			}

+			using (StringReader sr = new StringReader(sb.ToString())) {

+				ServiceEndpoint se2 = ServiceEndpoint.Deserialize(sr);

+				Assert.AreEqual(se, se2);

+				Assert.AreEqual(se.Protocol.Version, se2.Protocol.Version, "Particularly interested in this, since type URIs are not serialized but version info is.");

+				Assert.AreEqual(se.UserSuppliedIdentifier, se2.UserSuppliedIdentifier);

+				Assert.AreEqual(se.FriendlyIdentifierForDisplay, se2.FriendlyIdentifierForDisplay);

 			}

 		}

 

 		[Test]

 		public void EqualsTests() {

-			ServiceEndpoint se = new ServiceEndpoint(claimedId, providerEndpoint, localId, v20TypeUris);

-			ServiceEndpoint se2 = new ServiceEndpoint(claimedId, providerEndpoint, localId, v20TypeUris);

+			ServiceEndpoint se = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

+			ServiceEndpoint se2 = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v20TypeUris, (int?)null, (int?)null);

 			Assert.AreEqual(se2, se);

 			Assert.AreNotEqual(se, null);

 			Assert.AreNotEqual(null, se);

 

-			ServiceEndpoint se3 = new ServiceEndpoint(claimedId + "a", providerEndpoint, localId, v20TypeUris);

+			ServiceEndpoint se3 = ServiceEndpoint.CreateForClaimedIdentifier(new UriIdentifier(claimedId + "a"), localId, providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			Assert.AreNotEqual(se, se3);

-			se3 = new ServiceEndpoint(claimedId, new Uri(providerEndpoint.AbsoluteUri + "a"), localId, v20TypeUris);

+			se3 = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, new Uri(providerEndpoint.AbsoluteUri + "a"), v20TypeUris, servicePriority, uriPriority);

 			Assert.AreNotEqual(se, se3);

-			se3 = new ServiceEndpoint(claimedId, providerEndpoint, localId + "a", v20TypeUris);

+			se3 = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId + "a", providerEndpoint, v20TypeUris, servicePriority, uriPriority);

 			Assert.AreNotEqual(se, se3);

-			se3 = new ServiceEndpoint(claimedId, providerEndpoint, localId, v11TypeUris);

+			se3 = ServiceEndpoint.CreateForClaimedIdentifier(claimedId, localId, providerEndpoint, v11TypeUris, servicePriority, uriPriority);

 			Assert.AreNotEqual(se, se3);

+

+			// make sure that Collection<T>.Contains works as desired.

+			List<ServiceEndpoint> list = new List<ServiceEndpoint>();

+			list.Add(se);

+			Assert.IsTrue(list.Contains(se2));

+		}

+

+		[Test]

+		public void FriendlyIdentifierForDisplay() {

+			Uri providerEndpoint= new Uri("http://someprovider");

+			Identifier localId = "someuser";

+			string[] serviceTypeUris = new string[] {

+				Protocol.v20.ClaimedIdentifierServiceTypeURI,

+			};

+			ServiceEndpoint se;

+

+			// strip of protocol and fragment

+			se = ServiceEndpoint.CreateForClaimedIdentifier("http://someprovider.somedomain.com:79/someuser#frag",

+				localId, providerEndpoint, serviceTypeUris, null, null);

+			Assert.AreEqual("someprovider.somedomain.com:79/someuser", se.FriendlyIdentifierForDisplay);

+

+			// unescape characters

+			Uri foreignUri = new Uri("http://server崎/村");

+			se = ServiceEndpoint.CreateForClaimedIdentifier(foreignUri, localId, providerEndpoint, serviceTypeUris, null, null);

+			Assert.AreEqual("server崎/村", se.FriendlyIdentifierForDisplay);

+			

+			// restore user supplied identifier to XRIs

+			se = ServiceEndpoint.CreateForClaimedIdentifier(new XriIdentifier("=!9B72.7DD1.50A9.5CCD"),

+				new XriIdentifier("=Arnott崎村"), localId, providerEndpoint, serviceTypeUris, null, null);

+			Assert.AreEqual("=Arnott崎村", se.FriendlyIdentifierForDisplay);

+

+			// If UserSuppliedIdentifier is the same as the ClaimedIdentifier, don't display it twice...

+			se = ServiceEndpoint.CreateForClaimedIdentifier(

+				new XriIdentifier("=!9B72.7DD1.50A9.5CCD"), new XriIdentifier("=!9B72.7DD1.50A9.5CCD"),

+				localId, providerEndpoint, serviceTypeUris, null, null);

+			Assert.AreEqual("=!9B72.7DD1.50A9.5CCD", se.FriendlyIdentifierForDisplay);

 		}

 	}

 }

diff --git a/src/DotNetOpenId.Test/RelyingParty/TokenTest.cs b/src/DotNetOpenId.Test/RelyingParty/TokenTest.cs
index b83c47f..c57f68a 100644
--- a/src/DotNetOpenId.Test/RelyingParty/TokenTest.cs
+++ b/src/DotNetOpenId.Test/RelyingParty/TokenTest.cs
@@ -1,20 +1,18 @@
-using System;

-using System.Collections.Generic;

-using System.Text;

+using DotNetOpenId.RelyingParty;

 using NUnit.Framework;

-using DotNetOpenId.RelyingParty;

-using System.Threading;

 

 namespace DotNetOpenId.Test.RelyingParty {

 	[TestFixture]

 	public class TokenTest {

 		static ServiceEndpoint getServiceEndpoint(TestSupport.Scenarios scenario, ProtocolVersion version) {

 			Protocol protocol = Protocol.Lookup(version);

-			ServiceEndpoint ep = new ServiceEndpoint(

+			ServiceEndpoint ep = ServiceEndpoint.CreateForClaimedIdentifier(

 				TestSupport.GetIdentityUrl(scenario, version),

-				TestSupport.GetFullUrl(TestSupport.ProviderPage),

 				TestSupport.GetDelegateUrl(scenario),

-				new[] { protocol.ClaimedIdentifierServiceTypeURI }

+				TestSupport.GetFullUrl(TestSupport.ProviderPage),

+				new[] { protocol.ClaimedIdentifierServiceTypeURI },

+				10,

+				10

 				);

 			return ep;

 		}