protected void AddMessage(bool isOutgoing, double messageIntervalSeconds, string senderPhoneNumber, string messageContents, string chatId, IMessageAttachment attachment)
        {
            _LastMessageId++;

            DateTime timestamp = _LastTimestamp.AddSeconds(messageIntervalSeconds);

            TextMessage textMessage = new TextMessage(_LastMessageId, isOutgoing, timestamp, messageContents, senderPhoneNumber, chatId, null, attachment);
            _TextMessages.Add(textMessage);

            _LastTimestamp = timestamp;
        }
        public void GetSenderDisplayNameTest()
        {
            IConversationMessage outgoingMessage = new TextMessage(105, true, new DateTime(2009, 3, 5, 16, 17, 15), "Hey, wassup?", "212-555-1234", CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
            VerifyMessageDisplayName(outgoingMessage, ConversationRendererBase_Accessor._localName);

            IConversationMessage incomingKnownContactMessage = new TextMessage(106, false, new DateTime(2009, 3, 5, 16, 17, 16), "Not much, and you?", "212-555-1234", CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
            incomingKnownContactMessage.Contact = new MockContact("Joe", "Billichuck");
            VerifyMessageDisplayName(incomingKnownContactMessage, "Joe Billichuck");

            incomingKnownContactMessage.Contact = new MockContact("Sarah", "Michelle", "Gellar");
            VerifyMessageDisplayName(incomingKnownContactMessage, "Sarah Michelle Gellar");

            incomingKnownContactMessage.Contact = new MockContact("Sting", null);
            VerifyMessageDisplayName(incomingKnownContactMessage, "Sting");

            incomingKnownContactMessage.Contact = new MockContact(null, "Madonna");
            VerifyMessageDisplayName(incomingKnownContactMessage, "Madonna");

            incomingKnownContactMessage.Contact = new MockContact(null, null);
            VerifyMessageDisplayName(incomingKnownContactMessage, "Unknown Sender");

            incomingKnownContactMessage.Contact = new MockContact("", "");
            VerifyMessageDisplayName(incomingKnownContactMessage, "Unknown Sender");
        }
Exemple #3
0
 public int CompareTo(TextMessage other)
 {
     if (this.Timestamp != other.Timestamp)
     {
         return this.Timestamp.CompareTo(other.Timestamp);
     }
     else
     {
         return this.MessageId.CompareTo(other.MessageId);
     }
 }
Exemple #4
0
        public bool Equals(TextMessage other)
        {
            if (this.MessageId != other.MessageId)
            {
                return false;
            }

            if (this.IsOutgoing != other.IsOutgoing)
            {
                return false;
            }

            if (this.Timestamp != other.Timestamp)
            {
                return false;
            }

            if (this.MessageContents != other.MessageContents)
            {
                return false;
            }

            if (this.Address != other.Address)
            {
                return false;
            }

            if (this.Contact != other.Contact)
            {
                return false;
            }

            if (this.ChatId != other.ChatId)
            {
                return false;
            }

            if (this.Country != other.Country)
            {
                return false;
            }

            if (!this.Attachments.SequenceEqual(other.Attachments))
            {
                return false;
            }

            return true;
        }
 public void VerifyMessageRowMatches(long messageId, bool isOutgoing, DateTime timestamp, string messageContents, string address)
 {
     TextMessage messageExpected = new TextMessage(messageId, isOutgoing, timestamp, messageContents, address, CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
     long flagsExpected = MessageFlagsAsLong(messageExpected.IsOutgoing);
     TextMessage messageActual = MessageFromDatabaseRow(messageId,
                                                        messageExpected.Address,
                                                        LocalTimeToUnixTime(messageExpected.Timestamp),
                                                        messageExpected.MessageContents,
                                                        flagsExpected,
                                                        CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
     Assert.AreEqual(messageExpected, messageActual);
 }
 public void UndefinedFlagTest()
 {
     TextMessage messageExpected = new TextMessage(6, true, new DateTime(2010, 5, 15, 8, 9, 59), "This is a flag you've never seen before!", "9879992762", CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
     long flagsExpected = MessageFlagsAsLong(messageExpected.IsOutgoing);
     long flagsInput = flagsExpected + 16;
     TextMessage messageActual = MessageFromDatabaseRow(messageExpected.MessageId,
                                                        messageExpected.Address,
                                                        LocalTimeToUnixTime(messageExpected.Timestamp),
                                                        messageExpected.MessageContents,
                                                        flagsInput,
                                                        messageExpected.Country);
     Assert.AreEqual(messageExpected, messageActual);
 }
 public void OverflowFlagTest()
 {
     TextMessage messageExpected = new TextMessage(87, true, new DateTime(2010, 12, 15, 8, 9, 59), "This is an overflowing flag!", "9827746655", CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
     long flagsExpected = MessageFlagsAsLong(messageExpected.IsOutgoing);
     long flagsInput = long.MaxValue;
     TextMessage messageActual = MessageFromDatabaseRow(messageExpected.MessageId,
                                                        messageExpected.Address,
                                                        LocalTimeToUnixTime(messageExpected.Timestamp),
                                                        messageExpected.MessageContents,
                                                        flagsInput,
                                                        CountryCallingCodeFinder.CountryAbbreviationUnitedStates);
     Assert.AreEqual(messageExpected, messageActual);
 }
 private void VerifyTextMessageMatchesConversationMessage(TextMessage textMessage, IConversationMessage conversationMessage)
 {
     Assert.AreEqual(textMessage.Timestamp, conversationMessage.Timestamp);
     Assert.AreEqual(textMessage.MessageContents, conversationMessage.MessageContents);
     Assert.AreEqual(textMessage.IsOutgoing, conversationMessage.IsOutgoing);
 }
        private void VerifyMessagesMatch(IConversation conversation, TextMessage[] messagesExpected)
        {
            Assert.AreEqual(messagesExpected.Length, conversation.MessageCount);

            for (int messageIndex = 0; messageIndex < conversation.MessageCount; messageIndex++)
            {
                IConversationMessage conversationMessageCurrent = conversation.GetMessage(messageIndex);
                TextMessage textMessageExpected = messagesExpected[messageIndex];
                VerifyTextMessageMatchesConversationMessage(textMessageExpected, conversationMessageCurrent);
            }
        }
Exemple #10
0
        public override bool Equals(object obj)
        {
            TextMessage message = (TextMessage)obj;

            return(Equals(message));
        }