+ CPPUNIT_TEST_SUITE(DIGESTMD5ClientAuthenticatorTest);

+ CPPUNIT_TEST(testGetInitialResponse);

+ CPPUNIT_TEST(testGetResponse);

+ CPPUNIT_TEST(testGetResponse_WithAuthorizationID);

+ //CPPUNIT_TEST(testSetChallenge);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ }

+

+ void testGetInitialResponse() {

+ DIGESTMD5ClientAuthenticator testling("xmpp.example.com", "abcdefgh", crypto.get());

+

+ CPPUNIT_ASSERT(!testling.getResponse());

+ }

+

+ void testGetResponse() {

+ DIGESTMD5ClientAuthenticator testling("xmpp.example.com", "abcdefgh", crypto.get());

+

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setChallenge(createByteArray(

+ "realm=\"example.com\","

+ "nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\","

+ "qop=auth,charset=utf-8,algorithm=md5-sess"));

+

+ SafeByteArray response = *testling.getResponse();

+

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=088891c800ecff1b842159ad6459104a,username=\"user\""), response);

+ }

+

+ void testGetResponse_WithAuthorizationID() {

+ DIGESTMD5ClientAuthenticator testling("xmpp.example.com", "abcdefgh", crypto.get());

+

+ testling.setCredentials("user", createSafeByteArray("pass"), "myauthzid");

+ testling.setChallenge(createByteArray(

+ "realm=\"example.com\","

+ "nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\","

+ "qop=auth,charset=utf-8,algorithm=md5-sess"));

+

+ SafeByteArray response = *testling.getResponse();

+

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("authzid=\"myauthzid\",charset=utf-8,cnonce=\"abcdefgh\",digest-uri=\"xmpp/xmpp.example.com\",nc=00000001,nonce=\"O6skKPuaCZEny3hteI19qXMBXSadoWs840MchORo\",qop=auth,realm=\"example.com\",response=4293834432b6e7889a2dee7e8fe7dd06,username=\"user\""), response);

+ }

+

+ private:

+ boost::shared_ptr<CryptoProvider> crypto;

+ CPPUNIT_TEST_SUITE(DIGESTMD5PropertiesTest);

+ CPPUNIT_TEST(testParse);

+ CPPUNIT_TEST(testSerialize);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testParse() {

+ DIGESTMD5Properties properties = DIGESTMD5Properties::parse(createByteArray(

+ "realm=\"myrealm1\",realm=\"myrealm2\",nonce=\"mynonce\","

+ "algorithm=md5-sess,charset=utf-8"));

+

+ CPPUNIT_ASSERT(properties.getValue("realm"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myrealm1"), *properties.getValue("realm"));

+ CPPUNIT_ASSERT(properties.getValue("nonce"));

+ CPPUNIT_ASSERT_EQUAL(std::string("mynonce"), *properties.getValue("nonce"));

+ CPPUNIT_ASSERT(properties.getValue("algorithm"));

+ CPPUNIT_ASSERT_EQUAL(std::string("md5-sess"), *properties.getValue("algorithm"));

+ CPPUNIT_ASSERT(properties.getValue("charset"));

+ CPPUNIT_ASSERT_EQUAL(std::string("utf-8"), *properties.getValue("charset"));

+ }

+

+ void testSerialize() {

+ DIGESTMD5Properties properties;

+ properties.setValue("authzid", "myauthzid");

+ properties.setValue("charset", "utf-8");

+ properties.setValue("cnonce", "mycnonce");

+ properties.setValue("digest-uri", "mydigesturi");

+ properties.setValue("nc", "1");

+ properties.setValue("nonce", "mynonce");

+ properties.setValue("qop", "auth");

+ properties.setValue("realm", "myrealm");

+ properties.setValue("response", "myresponse");

+ properties.setValue("username", "myuser");

+

+ ByteArray result = properties.serialize();

+ ByteArray expected(createByteArray("authzid=\"myauthzid\",charset=utf-8,cnonce=\"mycnonce\",digest-uri=\"mydigesturi\",nc=1,nonce=\"mynonce\",qop=auth,realm=\"myrealm\",response=myresponse,username=\"myuser\""));

+ CPPUNIT_ASSERT_EQUAL(byteArrayToString(expected), byteArrayToString(result));

+ }

+ CPPUNIT_TEST_SUITE(PLAINClientAuthenticatorTest);

+ CPPUNIT_TEST(testGetResponse_WithoutAuthzID);

+ CPPUNIT_TEST(testGetResponse_WithAuthzID);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void testGetResponse_WithoutAuthzID() {

+ PLAINClientAuthenticator testling;

+ testling.setCredentials("user", createSafeByteArray("pass"));

+ CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createSafeByteArray("\0user\0pass", 10));

+ }

+ void testGetResponse_WithAuthzID() {

+ PLAINClientAuthenticator testling;

+ testling.setCredentials("user", createSafeByteArray("pass"), "authz");

+ CPPUNIT_ASSERT_EQUAL(*testling.getResponse(), createSafeByteArray("authz\0user\0pass", 15));

+ }

+ CPPUNIT_TEST_SUITE(PLAINMessageTest);

+ CPPUNIT_TEST(testGetValue_WithoutAuthzID);

+ CPPUNIT_TEST(testGetValue_WithAuthzID);

+ CPPUNIT_TEST(testConstructor_WithoutAuthzID);

+ CPPUNIT_TEST(testConstructor_WithAuthzID);

+ CPPUNIT_TEST(testConstructor_NoAuthcid);

+ CPPUNIT_TEST(testConstructor_NoPassword);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ PLAINMessageTest() {}

+

+ void testGetValue_WithoutAuthzID() {

+ PLAINMessage message("user", createSafeByteArray("pass"));

+ CPPUNIT_ASSERT_EQUAL(message.getValue(), createSafeByteArray("\0user\0pass", 10));

+ }

+

+ void testGetValue_WithAuthzID() {

+ PLAINMessage message("user", createSafeByteArray("pass"), "authz");

+ CPPUNIT_ASSERT_EQUAL(message.getValue(), createSafeByteArray("authz\0user\0pass", 15));

+ }

+

+ void testConstructor_WithoutAuthzID() {

+ PLAINMessage message(createSafeByteArray("\0user\0pass", 10));

+

+ CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthorizationID());

+ CPPUNIT_ASSERT_EQUAL(std::string("user"), message.getAuthenticationID());

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("pass"), message.getPassword());

+ }

+

+ void testConstructor_WithAuthzID() {

+ PLAINMessage message(createSafeByteArray("authz\0user\0pass", 15));

+

+ CPPUNIT_ASSERT_EQUAL(std::string("authz"), message.getAuthorizationID());

+ CPPUNIT_ASSERT_EQUAL(std::string("user"), message.getAuthenticationID());

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("pass"), message.getPassword());

+ }

+

+ void testConstructor_NoAuthcid() {

+ PLAINMessage message(createSafeByteArray("authzid", 7));

+

+ CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthenticationID());

+ }

+

+ void testConstructor_NoPassword() {

+ PLAINMessage message(createSafeByteArray("authzid\0authcid", 15));

+

+ CPPUNIT_ASSERT_EQUAL(std::string(""), message.getAuthenticationID());

+ }

+ CPPUNIT_TEST_SUITE(SCRAMSHA1ClientAuthenticatorTest);

+ CPPUNIT_TEST(testGetInitialResponse);

+ CPPUNIT_TEST(testGetInitialResponse_UsernameHasSpecialChars);

+ CPPUNIT_TEST(testGetInitialResponse_WithAuthorizationID);

+ CPPUNIT_TEST(testGetInitialResponse_WithAuthorizationIDWithSpecialChars);

+ CPPUNIT_TEST(testGetInitialResponse_WithoutChannelBindingWithTLSChannelBindingData);

+ CPPUNIT_TEST(testGetInitialResponse_WithChannelBindingWithTLSChannelBindingData);

+ CPPUNIT_TEST(testGetFinalResponse);

+ CPPUNIT_TEST(testGetFinalResponse_WithoutChannelBindingWithTLSChannelBindingData);

+ CPPUNIT_TEST(testGetFinalResponse_WithChannelBindingWithTLSChannelBindingData);

+ CPPUNIT_TEST(testSetChallenge);

+ CPPUNIT_TEST(testSetChallenge_InvalidClientNonce);

+ CPPUNIT_TEST(testSetChallenge_OnlyClientNonce);

+ CPPUNIT_TEST(testSetChallenge_InvalidIterations);

+ CPPUNIT_TEST(testSetChallenge_ZeroIterations);

+ CPPUNIT_TEST(testSetChallenge_NegativeIterations);

+ CPPUNIT_TEST(testSetChallenge_MissingIterations);

+ CPPUNIT_TEST(testSetFinalChallenge);

+ CPPUNIT_TEST(testSetFinalChallenge_InvalidChallenge);

+ CPPUNIT_TEST(testGetResponseAfterFinalChallenge);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void setUp() {

+ idnConverter = boost::shared_ptr<IDNConverter>(PlatformIDNConverter::create());

+ crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ }

+ void testGetInitialResponse() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("n,,n=user,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetInitialResponse_UsernameHasSpecialChars() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false, idnConverter.get(), crypto.get());

+ testling.setCredentials(",us=,er=", createSafeByteArray("pass"), "");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("n,,n==2Cus=3D=2Cer=3D,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetInitialResponse_WithAuthorizationID() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "auth");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("n,a=auth,n=user,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetInitialResponse_WithAuthorizationIDWithSpecialChars() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "a=u,th");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("n,a=a=3Du=2Cth,n=user,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetInitialResponse_WithoutChannelBindingWithTLSChannelBindingData() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", false, idnConverter.get(), crypto.get());

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("y,,n=user,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetInitialResponse_WithChannelBindingWithTLSChannelBindingData() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefghABCDEFGH", true, idnConverter.get(), crypto.get());

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("p=tls-unique,,n=user,r=abcdefghABCDEFGH"), response);

+ }

+ void testGetFinalResponse() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("c=biws,r=abcdefghABCDEFGH,p=CZbjGDpIteIJwQNBgO0P8pKkMGY="), response);

+ }

+ void testGetFinalResponse_WithoutChannelBindingWithTLSChannelBindingData() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("c=eSws,r=abcdefghABCDEFGH,p=JNpsiFEcxZvNZ1+FFBBqrYvYxMk="), response);

+ }

+ void testGetFinalResponse_WithChannelBindingWithTLSChannelBindingData() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", true, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setTLSChannelBindingData(createByteArray("xyza"));

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ SafeByteArray response = *testling.getResponse();

+ CPPUNIT_ASSERT_EQUAL(createSafeByteArray("c=cD10bHMtdW5pcXVlLCx4eXph,r=abcdefghABCDEFGH,p=i6Rghite81P1ype8XxaVAa5l7v0="), response);

+ }

+ void testSetFinalChallenge() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));

+ CPPUNIT_ASSERT(result);

+ }

+ void testSetChallenge() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT(result);

+ }

+ void testSetChallenge_InvalidClientNonce() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefgiABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetChallenge_OnlyClientNonce() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefgh,s=MTIzNDU2NzgK,i=4096"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetChallenge_InvalidIterations() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=bla"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetChallenge_MissingIterations() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetChallenge_ZeroIterations() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=0"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetChallenge_NegativeIterations() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ bool result = testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=-1"));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testSetFinalChallenge_InvalidChallenge() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ bool result = testling.setChallenge(createByteArray("v=e26kI69ICb6zosapLLxrER/631A="));

+ CPPUNIT_ASSERT(!result);

+ }

+ void testGetResponseAfterFinalChallenge() {

+ SCRAMSHA1ClientAuthenticator testling("abcdefgh", false, idnConverter.get(), crypto.get());

+ testling.setCredentials("user", createSafeByteArray("pass"), "");

+ testling.setChallenge(createByteArray("r=abcdefghABCDEFGH,s=MTIzNDU2NzgK,i=4096"));

+ testling.setChallenge(createByteArray("v=Dd+Q20knZs9jeeK0pi1Mx1Se+yo="));

+ CPPUNIT_ASSERT(!testling.getResponse());

+ }

+ boost::shared_ptr<IDNConverter> idnConverter;

+ boost::shared_ptr<CryptoProvider> crypto;

+ CPPUNIT_TEST_SUITE(WindowsServicePrincipalNameTest);

+ CPPUNIT_TEST(testServiceClass);

+ CPPUNIT_TEST(testServiceName);

+ CPPUNIT_TEST(testInstanceName);

+ CPPUNIT_TEST(testInstancePort);

+ CPPUNIT_TEST(testReferrer);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testServiceClass() {

+ WindowsServicePrincipalName spn("mlink.adlon.isode.net");

+

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/mlink.adlon.isode.net"));

+

+ spn.setServiceClass("ldap");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("ldap/mlink.adlon.isode.net"));

+

+ spn.setServiceClass("中文");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("中文/mlink.adlon.isode.net"));

+

+ try {

+ spn.setServiceClass("");

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+

+ try {

+ spn.setServiceClass("xm/pp"); /* Foward slash not allowed */

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+ }

+

+ void testServiceName() {

+ try {

+ WindowsServicePrincipalName spn("");

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+

+ try {

+ WindowsServicePrincipalName spn2("mlink/adlon.isode.net"); /* Foward slash not allowed */

+ spn2.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+

+ WindowsServicePrincipalName spn3("mlinkÄ.adlon.isode.net");

+ CPPUNIT_ASSERT_EQUAL(spn3.toString(), std::string("xmpp/mlinkÄ.adlon.isode.net"));

+ }

+

+ void testInstanceName() {

+ WindowsServicePrincipalName spn("adlon.isode.net");

+

+ spn.setInstanceName("mlink.adlon.isode.net");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/mlink.adlon.isode.net/adlon.isode.net"));

+

+ spn.setInstanceName("127.0.0.1");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/127.0.0.1/adlon.isode.net"));

+

+ spn.setInstanceName("");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/adlon.isode.net"));

+

+ spn.setInstanceName("cañón.adlon.isode.net");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/cañón.adlon.isode.net/adlon.isode.net"));

+

+ try {

+ spn.setInstanceName("mlink/adlon.isode.net"); /* Foward slash not allowed */

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+ }

+

+ void testInstancePort() {

+ WindowsServicePrincipalName spn("adlon.isode.net");

+

+ spn.setInstanceName("mlink.adlon.isode.net");

+ spn.setInstancePort(6222);

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/mlink.adlon.isode.net:6222/adlon.isode.net"));

+

+ spn.setInstancePort(0);

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/mlink.adlon.isode.net/adlon.isode.net"));

+

+ WindowsServicePrincipalName spn2("mlink.adlon.isode.net");

+

+ spn2.setInstancePort(6222);

+ CPPUNIT_ASSERT_EQUAL(spn2.toString(), std::string("xmpp/mlink.adlon.isode.net:6222"));

+

+ spn2.setInstancePort(0);

+ CPPUNIT_ASSERT_EQUAL(spn2.toString(), std::string("xmpp/mlink.adlon.isode.net"));

+ }

+

+ void testReferrer() {

+ WindowsServicePrincipalName spn("127.0.0.1");

+

+ spn.setReferrer("referrer.net");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/127.0.0.1/referrer.net"));

+

+ spn.setInstancePort(6222);

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/127.0.0.1:6222/referrer.net"));

+

+ spn.setReferrer("हिन्दी.net");

+ CPPUNIT_ASSERT_EQUAL(spn.toString(), std::string("xmpp/127.0.0.1:6222/हिन्दी.net"));

+

+ try {

+ spn.setReferrer("referrer/net"); /* Foward slash not allowed */

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+

+ try {

+ spn.setReferrer(""); /* seems like you must have referrer with an IP */

+ spn.toString();

+ CPPUNIT_ASSERT(false);

+ } catch (std::runtime_error) {

+ /* expected */

+ }

+

+ WindowsServicePrincipalName spn2("mlink.adlon.isode.net");

+

+ spn2.setReferrer("referrer.net"); /* Referrer ignored if service name is not IP */

+ CPPUNIT_ASSERT_EQUAL(spn2.toString(), std::string("xmpp/mlink.adlon.isode.net"));

+

+ spn2.setReferrer("referrer/net"); /* Referrer ignored if service name is not IP */

+ CPPUNIT_ASSERT_EQUAL(spn2.toString(), std::string("xmpp/mlink.adlon.isode.net"));

+ WindowsServicePrincipalName spn3("adlon.isode.net");

+ spn3.setInstanceName("mlink.adlon.isode.net");

+ spn3.setInstancePort(6222);

+ spn3.setReferrer("referrer.net"); /* Referrer ignored if service name is not IP */

+ CPPUNIT_ASSERT_EQUAL(spn3.toString(), std::string("xmpp/mlink.adlon.isode.net:6222/adlon.isode.net"));

+ }