using(Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))

{

    // At this point we're all logged into the server.

 

    // Create a presence packet.

    AvailableRequest Announce = new AvailableRequest(AvailableRequest.ShowValuesEnum.Normal,

     "Hello World");

 

    // Send it to the server

    activeSession.Send(Announce);

 

    // The server would now send out presence to anyone who is subscribed to my presence.

}

using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))

{

  JabberID toUser = new JabberID("targetuser", Utility.SoapBoxServer);

  MessagePacket mp = new MessagePacket(toUser, "Subject", "Body");

  activeSession.Send(mp);

}

using (Session user2Session = Session.Login(user2.UserID.UserName, user2.Password, user2.UserID.Server))

{

    // We'll be using these to trigger on subscriptions being completed

    ManualResetEvent user1ToUser2SubscriptionComplete = new ManualResetEvent(false);

    ManualResetEvent user2ToUser1SubscriptionComplete = new ManualResetEvent(false);

 

    // We have now logged in both users.

 

    // Announce presence for both users.

    user1Session.Send(new AvailableRequest());

    user2Session.Send(new AvailableRequest());

 

    // We need to have both users listen for the Subscribe Packets. This is what each user

    // will receive once we ask for a presence subscription

    user1Session.AddHandler(null, typeof(SubscribeRequest), IncomingSubscribeForUser1,    

     user1Session, false);

    user2Session.AddHandler(null, typeof(SubscribeRequest), IncomingSubscribeForUser2,

     user2Session, false);

 

 

    // We need to have both users listen for the Subscribed Response Packets. This is what

    // each user will receive once their subscription is approved.

    user1Session.AddHandler(null, typeof(SubscribedResponse),

     IncomingSubscribedResponseForUser1, user1ToUser2SubscriptionComplete, false);

    user2Session.AddHandler(null, typeof(SubscribedResponse),

     IncomingSubscribedResponseForUser2, user2ToUser1SubscriptionComplete, false);

 

 

    /*

    *      Start out by having User1 subscribe to User2's presence.

    *

    *      If you're not familiar with asynchronous programming, this

    *      is going to be a bit confusing.

    *

    */

 

    user1Session.Send(new SubscribeRequest(user2.UserID));

    if (!user1ToUser2SubscriptionComplete.WaitOne(30000, false))

        Assert.Fail("User 1 Subscribing to User 2 never completed.");

 

 

    /*

    *      Now have User2 Subscribe to User1

    */

 

    user2Session.Send(new SubscribeRequest(user1.UserID));

    if (!user2ToUser1SubscriptionComplete.WaitOne(30000, false))

        Assert.Fail("User 2 Subscribing to User 1 never completed.");

 

    /*

    * Subscriptions are now completed.

    *

    * Let's pull down the roster for each user, and make sure

    * everything is correct.

    *

    */

 

    RosterResponse user1Roster = user1Session.Send(new RosterRequest()) as RosterResponse;

    RosterResponse user2Roster = user2Session.Send(new RosterRequest()) as RosterResponse;

 

    // We now have rosters for both users. Let's check 'em.

    Assert.IsTrue(user1Roster.Items.Count == 1, "Invalid Number of items in User1 Roster");

    Assert.IsTrue(user2Roster.Items.Count == 1, "Invalid Number of items in User2 Roster");

 

    Assert.IsTrue(user1Roster.Items.Contains(user2.UserID),

     "User 2 is not found in user1's roster");

    Assert.IsTrue(user2Roster.Items.Contains(user1.UserID),

     "User 2 is not found in user1's roster");

 

    Assert.IsTrue(user1Roster.Items.Item(user2.UserID).Subscription.Equals

    ("both", StringComparison.InvariantCultureIgnoreCase),

    "Incorrect Subscription type in User1's Roster");

    Assert.IsTrue(user2Roster.Items.Item(user1.UserID).Subscription.Equals
   ("both", StringComparison.InvariantCultureIgnoreCase),

     "Incorrect Subscription type in User2's Roster");                   

}

using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))

{

   //Create a new request and add some data to store into it.

   PrivateStorageRequest storageRequest = new PrivateStorageRequest();

   storageRequest.AddPackage("PrivateStorageSample", "coversant", "This is my private data")

    ;

 

   // Send our storage request to the server.

   activeSession.Send(storageRequest);

 

   // Lookup our stored data in the server.

   PrivateGetRequest storageLookup = new PrivateGetRequest("PrivateStorageSample",

    "coversant");

   PrivateGetResponse storedData = activeSession.Send(storageLookup) as PrivateGetResponse;

 

 

   Assert.IsTrue(storedData.Package.InnerText == "This is my private data", "Wrong data from

    server");

}

using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))

{

    /*

    *      Roster Add

    */

 

    // Create a new user name, and prepare to add that user to our roster. This user should

    // be in the Bare JID format (user@server) and NOT in the Resource JID format

     (user@server/resource).

    JabberID userToAdd = new JabberID(Guid.NewGuid().ToString(), Utility.SoapBoxServer,    

     string.Empty);

 

    // Create the Roster Add Packet, and Send it to the server.

    RosterAdd r = new RosterAdd(userToAdd, FriendlyUserName);

    activeSession.Send(r);

 

 

    /*

    *      Roster Get (aka: Verify the user was really Added)

    */

 

    // Let's pull down the roster now, and make sure that new user is really in there.

    RosterResponse currentRoster = activeSession.Send(new RosterRequest()) as

     RosterResponse;

 

    // The roster that we now have is going to have Roster Items in it. Let's iterate over

    // these items and find the one we just added.

 

    RosterItem ourUser = null;

    foreach (RosterItem ri in currentRoster.Items)

    {

        if (ri.JID.Equals(userToAdd))

        {

            ourUser = ri;

            break;

        }

    }

 

    Assert.IsNotNull(ourUser, "Unable to find the user we just added");

    Assert.AreEqual(ourUser.Name, FriendlyUserName, "Incorrect Friendly Name");

 

 

    /*

    *      Roster Remove

    */

 

    // The easiest way to remove a user is to just pass in

    // the roster item that should be removed.

    // Alternativly, we could pass in the JID and Friendly Name of the item to remove.

    RosterRemove remove = new RosterRemove(ourUser);

    activeSession.Send(remove);

 

    /*

    *      Roster Get (aka: Verify the user was removed)

    */

    // The User is now removed. Let's pull down the roster again and make sure.               

    RosterResponse removedUserRoster = activeSession.Send(new RosterRequest()) as

     RosterResponse;

    foreach (RosterItem ri in removedUserRoster.Items)

    {

        if (ri.JID.Equals(userToAdd))

            Assert.Fail("The user that was just removed ('{0}' has been found",

             ri.JID.ToString());               

    }

}

using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))

    {  

        // Ask the server 'What Time is it?'

        TimeResponse tr = activeSession.Send(new TimeRequest()) as TimeResponse;

 

        // Print out the results.

        System.Console.WriteLine("The time is {0} in timezone {1}", tr.UTCDateTime,

         tr.Timezone);

    }

using( Session activeSession = new Session(co) )

{

    activeSession.OpenStreamSynchronous();

 

    // At this point we have a stream that's open, and is not secured.

    System.Console.WriteLine("Session ID is: {0}  On Server: {1} with XMPP Domain Name: {2}",

        activeSession.SessionID,

        activeSession.ServerInformation.HostName,

        activeSession.ServerInformation.XMPPDomain);

}

using (Session s = new Session(Utility.SoapBoxServer))

{

    s.OpenStreamSynchronous();

 

    // Send the "Get Instructions" message to the server.

    RegisterInfoRequest info = new RegisterInfoRequest(Utility.SoapBoxServerJID);

    RegisterInfoResponse Key = WConvert.ToRegisterInfoResponse(s.Send(info));

 

    // When we register, send in the key that was returned earlier.

    RegisterRequest register = new RegisterRequest(Utility.SoapBoxServerJID,

     newUserName.UserName, newUserPassword, Key.Key);

    s.Send(register);

 

    // We now have a new user! Let's dispose this session, and do a standard login.

}

 

using (Session s = Session.Login(newUserName.UserName, newUserPassword, newUserName.Server))

{

    // If we got this far, the user is logged in.

 

    // Announce Presence

    s.Send(new AvailableRequest());

}

using (Session s = new Session(Utility.SoapBoxServer))

{

    s.OpenStreamSynchronous();

 

    for (int i = 0; i < userCount; i++)

    {

        IDAndPassword user = CreateOneUser(s);

        users.Add(user);

    }

}