text: import unittest
  
  import skype4pytest
  from Skype4Py.chat import *
  
  
  class ChatTest(skype4pytest.TestCase):
      def setUpObject(self):
          self.obj = Chat(self.skype, 'spam')
  
      # Methods
      # =======
  
      def testAcceptAdd(self):
          self.api.enqueue('ALTER CHAT spam ACCEPTADD', 'ALTER CHAT ACCEPTADD')
          self.obj.AcceptAdd()
          self.failUnless(self.api.is_empty())
  
      def testAddMembers(self):
          self.api.enqueue('ALTER CHAT spam ADDMEMBERS eggs', 'ALTER CHAT ADDMEMBERS eggs')
          self.obj.AddMembers(User(self.skype, 'eggs'))
          self.failUnless(self.api.is_empty())
  
      # https://github.com/awahlig/skype4py/pull/21
      def xxx_testBookmark(self):
          self.api.enqueue('ALTER CHAT spam BOOKMARK', 'ALTER CHAT spam BOOKMARKED TRUE')
          self.obj.Bookmark()
          self.failUnless(self.api.is_empty())
  
      def testClearRecentMessages(self):
          self.api.enqueue('ALTER CHAT spam CLEARRECENTMESSAGES', 'ALTER CHAT CLEARRECENTMESSAGES')
          self.obj.ClearRecentMessages()
          self.failUnless(self.api.is_empty())
  
      def testDisband(self):
          self.api.enqueue('ALTER CHAT spam DISBAND', 'ALTER CHAT DISBAND')
          self.obj.Disband()
          self.failUnless(self.api.is_empty())
  
      def testEnterPassword(self):
          self.api.enqueue('ALTER CHAT spam ENTERPASSWORD eggs', 'ALTER CHAT ENTERPASSWORD eggs')
          self.obj.EnterPassword('eggs')
          self.failUnless(self.api.is_empty())
  
      def testJoin(self):
          self.api.enqueue('ALTER CHAT spam JOIN', 'ALTER CHAT JOIN')
          self.obj.Join()
          self.failUnless(self.api.is_empty())
  
      def testKick(self):
          self.api.enqueue('ALTER CHAT spam KICK eggs, sausage', 'ALTER CHAT KICK eggs, sausage')
          self.obj.Kick('eggs', 'sausage')
          self.failUnless(self.api.is_empty())
  
      def _testKickBan(self):
          self.api.enqueue('ALTER CHAT spam KICKBAN eggs, sausage', 'ALTER CHAT KICKBAN eggs, sausage')
          self.obj.KickBan('eggs', 'sausage')
          self.failUnless(self.api.is_empty())
  
      def testLeave(self):
          self.api.enqueue('ALTER CHAT spam LEAVE', 'ALTER CHAT LEAVE')
          self.obj.Leave()
          self.failUnless(self.api.is_empty())
  
      def testOpenWindow(self):
          self.api.enqueue('OPEN CHAT spam')
          self.obj.OpenWindow()
          self.failUnless(self.api.is_empty())
  
      def testSendMessage(self):
          # Returned type: ChatMessage
          self.api.enqueue('CHATMESSAGE spam eggs',
                           'CHATMESSAGE 345 STATUS SENDING')
          t = self.obj.SendMessage('eggs')
          self.assertInstance(t, ChatMessage)
          self.assertEqual(t.Id, 345)
          self.failUnless(self.api.is_empty())
  
      def testSetPassword(self):
          self.api.enqueue('ALTER CHAT spam SETPASSWORD eggs sausage', 'ALTER CHAT SETPASSWORD eggs sausage')
          self.obj.SetPassword('eggs', 'sausage')
          self.failUnless(self.api.is_empty())
  
      # https://github.com/awahlig/skype4py/pull/21
      def xxx_testUnbookmark(self):
          self.api.enqueue('ALTER CHAT spam UNBOOKMARK', 'ALTER CHAT spam BOOKMARKED FALSE')
          self.obj.Unbookmark()
          self.failUnless(self.api.is_empty())
  
      # Properties
      # ==========
  
      def testActiveMembers(self):
          # Readable, Type: UserCollection
          self.api.enqueue('GET CHAT spam ACTIVEMEMBERS',
                           'CHAT spam ACTIVEMEMBERS eggs sausage')
          t = self.obj.ActiveMembers
          self.assertInstance(t, UserCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testActivityDatetime(self):
          # Readable, Type: datetime
          from datetime import datetime
          from time import time
          now = time()
          self.api.enqueue('GET CHAT spam ACTIVITY_TIMESTAMP',
                           'CHAT spam ACTIVITY_TIMESTAMP %f' % now)
          t = self.obj.ActivityDatetime
          self.assertInstance(t, datetime)
          self.assertEqual(t, datetime.fromtimestamp(now))
          self.failUnless(self.api.is_empty())
  
      def testActivityTimestamp(self):
          # Readable, Type: float
          self.api.enqueue('GET CHAT spam ACTIVITY_TIMESTAMP',
                           'CHAT spam ACTIVITY_TIMESTAMP 123.4')
          t = self.obj.ActivityTimestamp
          self.assertInstance(t, float)
          self.assertEqual(t, 123.4)
          self.failUnless(self.api.is_empty())
  
      def testAdder(self):
          # Readable, Type: User
          self.api.enqueue('GET CHAT spam ADDER',
                           'CHAT spam ADDER eggs')
          t = self.obj.Adder
          self.assertInstance(t, User)
          self.assertEqual(t.Handle, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testAlertString(self):
          # Writable, Type: unicode
          self.api.enqueue('ALTER CHAT spam SETALERTSTRING =eggs', 'ALTER CHAT SETALERTSTRING =eggs')
          self.obj.AlertString = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testApplicants(self):
          # Readable, Type: UserCollection
          self.api.enqueue('GET CHAT spam APPLICANTS',
                           'CHAT spam APPLICANTS eggs, sausage')
          t = self.obj.Applicants
          self.assertInstance(t, UserCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testBlob(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam BLOB',
                           'CHAT spam BLOB eggs')
          t = self.obj.Blob
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testBookmarked(self):
          # Readable, Type: bool
          self.api.enqueue('GET CHAT spam BOOKMARKED',
                           'CHAT spam BOOKMARKED TRUE')
          t = self.obj.Bookmarked
          self.assertInstance(t, bool)
          self.assertEqual(t, True)
          self.failUnless(self.api.is_empty())
  
      def testDatetime(self):
          # Readable, Type: datetime
          from datetime import datetime
          from time import time
          now = time()
          self.api.enqueue('GET CHAT spam TIMESTAMP',
                           'CHAT spam TIMESTAMP %f' % now)
          t = self.obj.Datetime
          self.assertInstance(t, datetime)
          self.assertEqual(t, datetime.fromtimestamp(now))
          self.failUnless(self.api.is_empty())
  
      def testDescription(self):
          # Readable, Writable, Type: unicode
          self.api.enqueue('GET CHAT spam DESCRIPTION',
                           'CHAT spam DESCRIPTION eggs')
          t = self.obj.Description
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('SET CHAT spam DESCRIPTION eggs',
                           'CHAT spam DESCRIPTION eggs')
          self.obj.Description = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testDialogPartner(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam DIALOG_PARTNER',
                           'CHAT spam DIALOG_PARTNER eggs')
          t = self.obj.DialogPartner
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testFriendlyName(self):
          # Readable, Type: unicode
          self.api.enqueue('GET CHAT spam FRIENDLYNAME',
                           'CHAT spam FRIENDLYNAME eggs')
          t = self.obj.FriendlyName
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testGuideLines(self):
          # Readable, Writable, Type: unicode
          self.api.enqueue('GET CHAT spam GUIDELINES',
                           'CHAT spam GUIDELINES eggs')
          t = self.obj.GuideLines
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('ALTER CHAT spam SETGUIDELINES eggs', 'ALTER CHAT SETGUIDELINES eggs')
          self.obj.GuideLines = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testMemberObjects(self):
          # Readable, Type: ChatMemberCollection
          self.api.enqueue('GET CHAT spam MEMBEROBJECTS',
                           'CHAT spam MEMBEROBJECTS 67, 89')
          t = self.obj.MemberObjects
          self.assertInstance(t, ChatMemberCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testMembers(self):
          # Readable, Type: UserCollection
          self.api.enqueue('GET CHAT spam MEMBERS',
                           'CHAT spam MEMBERS eggs sausage')
          t = self.obj.Members
          self.assertInstance(t, UserCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testMessages(self):
          # Readable, Type: ChatMessageCollection
          self.api.enqueue('GET CHAT spam CHATMESSAGES',
                           'CHAT spam CHATMESSAGES 67, 89')
          t = self.obj.Messages
          self.assertInstance(t, ChatMessageCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testMyRole(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam MYROLE',
                           'CHAT spam MYROLE eggs')
          t = self.obj.MyRole
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testMyStatus(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam MYSTATUS',
                           'CHAT spam MYSTATUS eggs')
          t = self.obj.MyStatus
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testName(self):
          # Readable, Type: str
          t = self.obj.Name
          self.assertInstance(t, str)
          self.assertEqual(t, 'spam')
          self.failUnless(self.api.is_empty())
  
      def testOptions(self):
          # Readable, Writable, Type: int
          self.api.enqueue('GET CHAT spam OPTIONS',
                           'CHAT spam OPTIONS 123')
          t = self.obj.Options
          self.assertInstance(t, int)
          self.assertEqual(t, 123)
          self.failUnless(self.api.is_empty())
          self.api.enqueue('ALTER CHAT spam SETOPTIONS eggs', 'ALTER CHAT SETOPTIONS eggs')
          self.obj.Options = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testPasswordHint(self):
          # Readable, Type: unicode
          self.api.enqueue('GET CHAT spam PASSWORDHINT',
                           'CHAT spam PASSWORDHINT eggs')
          t = self.obj.PasswordHint
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testPosters(self):
          # Readable, Type: UserCollection
          self.api.enqueue('GET CHAT spam POSTERS',
                           'CHAT spam POSTERS eggs, sausage')
          t = self.obj.Posters
          self.assertInstance(t, UserCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testRecentMessages(self):
          # Readable, Type: ChatMessageCollection
          self.api.enqueue('GET CHAT spam RECENTCHATMESSAGES',
                           'CHAT spam RECENTCHATMESSAGES 67, 89')
          t = self.obj.RecentMessages
          self.assertInstance(t, ChatMessageCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
      def testStatus(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam STATUS',
                           'CHAT spam STATUS eggs')
          t = self.obj.Status
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testTimestamp(self):
          # Readable, Type: float
          self.api.enqueue('GET CHAT spam TIMESTAMP',
                           'CHAT spam TIMESTAMP 123.4')
          t = self.obj.Timestamp
          self.assertInstance(t, float)
          self.assertEqual(t, 123.4)
          self.failUnless(self.api.is_empty())
  
      def testTopic(self):
          # Readable, Writable, Type: unicode
          self.api.enqueue('GET CHAT spam TOPIC',
                           'CHAT spam TOPIC eggs')
          t = self.obj.Topic
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('ALTER CHAT spam SETTOPIC eggs', 'ALTER CHAT SETTOPIC eggs')
          self.obj.Topic = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testTopicXML(self):
          # Readable, Writable, Type: unicode
          self.api.enqueue('GET CHAT spam TOPICXML',
                           'CHAT spam TOPICXML eggs')
          t = self.obj.TopicXML
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('ALTER CHAT spam SETTOPICXML eggs', 'ALTER CHAT SETTOPICXML eggs')
          self.obj.TopicXML = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testType(self):
          # Readable, Type: str
          self.api.enqueue('GET CHAT spam TYPE',
                           'CHAT spam TYPE eggs')
          t = self.obj.Type
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
  
  class ChatMessageTest(skype4pytest.TestCase):
      def setUpObject(self):
          self.obj = ChatMessage(self.skype, '1234')
  
      # Methods
      # =======
  
      def testMarkAsSeen(self):
          self.api.enqueue('SET CHATMESSAGE 1234 SEEN',
                           'CHATMESSAGE 1234 STATUS READ')
          self.obj.MarkAsSeen()
          self.failUnless(self.api.is_empty())
  
      # Properties
      # ==========
  
      def testBody(self):
          # Readable, Writable, Type: unicode
          self.api.enqueue('GET CHATMESSAGE 1234 BODY',
                           'CHATMESSAGE 1234 BODY eggs')
          t = self.obj.Body
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('SET CHATMESSAGE 1234 BODY eggs',
                           'CHATMESSAGE 1234 BODY eggs')
          self.obj.Body = 'eggs'
          self.failUnless(self.api.is_empty())
  
      def testChat(self):
          # Readable, Type: Chat
          self.api.enqueue('GET CHATMESSAGE 1234 CHATNAME',
                           'CHATMESSAGE 1234 CHATNAME spam')
          t = self.obj.Chat
          self.assertInstance(t, Chat)
          self.assertEqual(t.Name, 'spam')
          self.failUnless(self.api.is_empty())
  
      def testChatName(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 CHATNAME',
                           'CHATMESSAGE 1234 CHATNAME spam')
          t = self.obj.ChatName
          self.assertInstance(t, str)
          self.assertEqual(t, 'spam')
          self.failUnless(self.api.is_empty())
  
      def testDatetime(self):
          # Readable, Type: datetime
          from datetime import datetime
          from time import time
          now = time()
          self.api.enqueue('GET CHATMESSAGE 1234 TIMESTAMP',
                           'CHATMESSAGE 1234 TIMESTAMP %f' % now)
          t = self.obj.Datetime
          self.assertInstance(t, datetime)
          self.assertEqual(t, datetime.fromtimestamp(now))
          self.failUnless(self.api.is_empty())
  
      def testEditedBy(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 EDITED_BY',
                           'CHATMESSAGE 1234 EDITED_BY eggs')
          t = self.obj.EditedBy
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testEditedDatetime(self):
          # Readable, Type: datetime
          from datetime import datetime
          from time import time
          now = time()
          self.api.enqueue('GET CHATMESSAGE 1234 EDITED_TIMESTAMP',
                           'CHATMESSAGE 1234 EDITED_TIMESTAMP %f' % now)
          t = self.obj.EditedDatetime
          self.assertInstance(t, datetime)
          self.assertEqual(t, datetime.fromtimestamp(now))
          self.failUnless(self.api.is_empty())
  
      def testEditedTimestamp(self):
          # Readable, Type: float
          self.api.enqueue('GET CHATMESSAGE 1234 EDITED_TIMESTAMP',
                           'CHATMESSAGE 1234 EDITED_TIMESTAMP 123.4')
          t = self.obj.EditedTimestamp
          self.assertInstance(t, float)
          self.assertEqual(t, 123.4)
          self.failUnless(self.api.is_empty())
  
      def testFromDisplayName(self):
          # Readable, Type: unicode
          self.api.enqueue('GET CHATMESSAGE 1234 FROM_DISPNAME',
                           'CHATMESSAGE 1234 FROM_DISPNAME eggs')
          t = self.obj.FromDisplayName
          self.assertInstance(t, unicode)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testFromHandle(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 FROM_HANDLE',
                           'CHATMESSAGE 1234 FROM_HANDLE eggs')
          t = self.obj.FromHandle
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testId(self):
          # Readable, Type: int
          t = self.obj.Id
          self.assertInstance(t, int)
          self.assertEqual(t, 1234)
          self.failUnless(self.api.is_empty())
  
      def testIsEditable(self):
          # Readable, Type: bool
          self.api.enqueue('GET CHATMESSAGE 1234 IS_EDITABLE',
                           'CHATMESSAGE 1234 IS_EDITABLE TRUE')
          t = self.obj.IsEditable
          self.assertInstance(t, bool)
          self.assertEqual(t, True)
          self.failUnless(self.api.is_empty())
  
      def testLeaveReason(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 LEAVEREASON',
                           'CHATMESSAGE 1234 LEAVEREASON USER_NOT_FOUND')
          t = self.obj.LeaveReason
          self.assertInstance(t, str)
          self.assertEqual(t, 'USER_NOT_FOUND')
          self.failUnless(self.api.is_empty())
  
      def testSeen(self):
          # Writable, Type: bool
          from warnings import simplefilter
          self.api.enqueue('SET CHATMESSAGE 1234 SEEN',
                           'CHATMESSAGE 1234 STATUS READ')
          try:
              simplefilter('ignore')
              self.obj.Seen = True
          finally:
              simplefilter('default')
          self.failUnless(self.api.is_empty())
  
      def testSender(self):
          # Readable, Type: User
          self.api.enqueue('GET CHATMESSAGE 1234 FROM_HANDLE',
                           'CHATMESSAGE 1234 FROM_HANDLE eggs')
          t = self.obj.Sender
          self.assertInstance(t, User)
          self.assertEqual(t.Handle, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testStatus(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 STATUS',
                           'CHATMESSAGE 1234 STATUS SENDING')
          t = self.obj.Status
          self.assertInstance(t, str)
          self.assertEqual(t, 'SENDING')
          self.failUnless(self.api.is_empty())
  
      def testTimestamp(self):
          # Readable, Type: float
          self.api.enqueue('GET CHATMESSAGE 1234 TIMESTAMP',
                           'CHATMESSAGE 1234 TIMESTAMP 123.4')
          t = self.obj.Timestamp
          self.assertInstance(t, float)
          self.assertEqual(t, 123.4)
          self.failUnless(self.api.is_empty())
  
      def testType(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMESSAGE 1234 TYPE',
                           'CHATMESSAGE 1234 TYPE TEXT')
          t = self.obj.Type
          self.assertInstance(t, str)
          self.assertEqual(t, 'TEXT')
          self.failUnless(self.api.is_empty())
  
      def testUsers(self):
          # Readable, Type: UserCollection
          self.api.enqueue('GET CHATMESSAGE 1234 USERS',
                           'CHATMESSAGE 1234 USERS eggs sausage')
          t = self.obj.Users
          self.assertInstance(t, UserCollection)
          self.assertEqual(len(t), 2)
          self.failUnless(self.api.is_empty())
  
  
  class ChatMemberTest(skype4pytest.TestCase):
      def setUpObject(self):
          self.obj = ChatMember(self.skype, '1234')
  
      # Methods
      # =======
  
      def testCanSetRoleTo(self):
          # Returned type: bool
          self.api.enqueue('ALTER CHATMEMBER 1234 CANSETROLETO HELPER',
                           'ALTER CHATMEMBER CANSETROLETO TRUE')
          t = self.obj.CanSetRoleTo('HELPER')
          self.assertInstance(t, bool)
          self.assertEqual(t, True)
          self.failUnless(self.api.is_empty())
  
      # Properties
      # ==========
  
      def testChat(self):
          # Readable, Type: Chat
          self.api.enqueue('GET CHATMEMBER 1234 CHATNAME',
                           'CHATMEMBER 1234 CHATNAME eggs')
          t = self.obj.Chat
          self.assertInstance(t, Chat)
          self.assertEqual(t.Name, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testHandle(self):
          # Readable, Type: str
          self.api.enqueue('GET CHATMEMBER 1234 IDENTITY',
                           'CHATMEMBER 1234 IDENTITY eggs')
          t = self.obj.Handle
          self.assertInstance(t, str)
          self.assertEqual(t, 'eggs')
          self.failUnless(self.api.is_empty())
  
      def testId(self):
          # Readable, Type: int
          t = self.obj.Id
          self.assertInstance(t, int)
          self.assertEqual(t, 1234)
          self.failUnless(self.api.is_empty())
  
      def testIsActive(self):
          # Readable, Type: bool
          self.api.enqueue('GET CHATMEMBER 1234 IS_ACTIVE',
                           'CHATMEMBER 1234 IS_ACTIVE TRUE')
          t = self.obj.IsActive
          self.assertInstance(t, bool)
          self.assertEqual(t, True)
          self.failUnless(self.api.is_empty())
  
      def testRole(self):
          # Readable, Writable, Type: str
          self.api.enqueue('GET CHATMEMBER 1234 ROLE',
                           'CHATMEMBER 1234 ROLE HELPER')
          t = self.obj.Role
          self.assertInstance(t, str)
          self.assertEqual(t, 'HELPER')
          self.failUnless(self.api.is_empty())
          self.api.enqueue('ALTER CHATMEMBER 1234 SETROLETO HELPER')
          self.obj.Role = 'HELPER'
          self.failUnless(self.api.is_empty())
  
  
  def suite():
      return unittest.TestSuite([
          unittest.defaultTestLoader.loadTestsFromTestCase(ChatTest),
          unittest.defaultTestLoader.loadTestsFromTestCase(ChatMessageTest),
          unittest.defaultTestLoader.loadTestsFromTestCase(ChatMemberTest),
      ])
  
  
  if __name__ == '__main__':
      unittest.main()
  