Exemple #1
0
	def testMessagesHash( self ) :

		m1 = Messages()
		h = m1.hash()

		lastHash = h
		for i in range( 10 ) :
			m1.add( Message( IECore.MessageHandler.Level.Debug, "testMessagesHash", "" ) )
			newHash = m1.hash()
			self.assertNotEqual( newHash, lastHash )
			lastHash = newHash

		# check stable
		self.assertEqual( m1.hash(), lastHash )

		m2 = Messages( m1 )
		self.assertEqual( m2.hash(), m1.hash() )

		m3 = Messages()
		for i in range( 10 ) :
			m3.add( Message( IECore.MessageHandler.Level.Debug, "testMessagesHash", "" ) )

		self.assertEqual( len(set( ( m1, m2, m3 ) ) ), 1 )

		m1.clear()
		self.assertEqual( m1.hash(), h )
		self.assertNotEqual( m1.hash(), m2.hash() )
Exemple #2
0
	def testMessages( self ) :

		m = Messages()
		self.assertEqual( m.size(), 0 )
		self.assertEqual( len(m), 0 )

		Level = IECore.MessageHandler.Level

		for l in ( Level.Error, Level.Warning, Level.Info, Level.Debug ) :
			self.assertEqual( m.count( l ), 0 )

		for i in range( 20 ) :
			m.add( Message( IECore.MessageHandler.Level( i % 4 ), "testMessages", str(i) ) )
			self.assertEqual( m.size(), i + 1 )

		self.assertEqual( len(m), m.size() )

		for i in range( 20 ) :
			self.assertEqual( m[i].level, IECore.MessageHandler.Level( i % 4 ) )
			self.assertEqual( m[i].context, "testMessages" )
			self.assertEqual( m[i].message, str(i) )

		m.clear()

		self.assertEqual( m.size(), 0 )
Exemple #3
0
	def testMessagesCopyPerformanceL( self ) :

		numMessages = 500000
		numCopies = 1000

		m = Messages()
		for i in range( numMessages ) :
			m.add( Message( IECore.MessageHandler.Level( i % 4 ), "testMessagesCopyPerformanceL", str(i) ) )

		with GafferTest.TestRunner.PerformanceScope() :
			GafferTest.testMessagesCopyPerformance( m, numCopies )
Exemple #4
0
	def testMessagesEquality( self ) :

		messages = [
			Message( IECore.MessageHandler.Level( i % 4 ), "testMessagesEquality", str(i) )
			for i in range( 10 )
		]

		m1 = Messages()
		m2 = Messages()

		for msg in messages :
			m1.add( msg )
			m2.add( msg )

		self.assertEqual( m1, m2 )
		self.assertFalse( m1 != m2 )

		m1.clear()

		self.assertNotEqual( m1, m2 )
		self.assertTrue( m1 != m2 )
Exemple #5
0
	def testData( self ) :

		m1 = Messages()
		m1d = MessagesData( m1 )
		self.assertEqual( repr(m1d), "Gaffer.Private.IECorePreview.MessagesData()" )

		m2d = m1d.copy()
		m2 = m2d.value
		m2.add( Message( IECore.MessageHandler.Level.Info, "testData", "message" ) )

		self.assertEqual( m1.size(), 0 )
		self.assertEqual( m2.size(), 1 )

		with self.assertRaises( IECore.Exception ) :
			repr(m2d)
Exemple #6
0
	def testMessagesCopy( self ) :

		m1 = Messages()
		for i in range( 11 ) :
			m1.add( Message( IECore.MessageHandler.Level( i % 4 ), "testMessagesCopy", str(i)  ) )

		m2 = m1
		m3 = Messages( m1 )

		self.assertEqual( m1, m2 )
		self.assertEqual( m1, m3 )
		self.assertEqual( m2, m3 )

		# Check copies are de-coupled

		m2.add( Message( IECore.MessageHandler.Level.Info, "testMessagesCopy", "message"  ) )

		self.assertEqual( m1, m2 )
		self.assertNotEqual( m2, m3 )

		m3.add( Message( IECore.MessageHandler.Level.Error, "testMessagesCopy", "message"  ) )

		self.assertEqual( m1, m2 )
		self.assertNotEqual( m2, m3 )
Exemple #7
0
    def testMessages(self):

        w = GafferUI.MessageWidget()
        self.assertCounts(w, 0, 0, 0, 0)

        m = Messages()
        for i in range(24):
            m.add(
                Message(IECore.MessageHandler.Level(i % 4), "testMessages",
                        "message %d" % i))

        w.setMessages(m)

        self.assertEqual(w.getMessages(), m)
        self.assertCounts(w, 6, 6, 6, 6)

        w.clear()
        self.assertNotEqual(w.getMessages(), m)
        self.assertCounts(w, 0, 0, 0, 0)
Exemple #8
0
	def testMessagesCount( self ) :

		Level = IECore.MessageHandler.Level
		messageCounts = ( ( Level.Error, 1 ), ( Level.Warning, 2 ), ( Level.Info, 3 ), ( Level.Debug, 4 ) )

		m = Messages()

		self.assertEqual( { m.count(l) for l, c in messageCounts }, { 0 } )
		self.assertEqual( m.count( Level.Invalid ), 0 )

		for level, count in messageCounts :
			for i in range( count ) :
				m.add( Message( level, "testMessagesCount", "Message %d" % i ) )

		self.assertEqual( [ m.count(l) for l, c in messageCounts ], [ c for l, c in messageCounts ] )

		m.clear()

		self.assertEqual( { m.count(l) for l, c in messageCounts }, { 0 } )
Exemple #9
0
	def testIndexing( self ) :

		messages = (
			Message( IECore.MessageHandler.Level.Debug, "testIndexing", "message1" ),
			Message( IECore.MessageHandler.Level.Info, "testIndexing", "message2" ),
			Message( IECore.MessageHandler.Level.Warning, "testIndexing", "message3" ),
			Message( IECore.MessageHandler.Level.Error, "testIndexing", "message4" )
		)

		m = Messages()

		for msg in messages :
			m.add( msg )

		for i in range( len(messages) ) :
			self.assertEqual( m[i], messages[i] )
			if i > 0 :
				self.assertEqual( m[-i], messages[-i] )

		with self.assertRaises( IndexError ) :
			m[ len(m) ]

		with self.assertRaises( IndexError ) :
			m[ - ( len(m) + 1 ) ]
Exemple #10
0
		def generateMessages( count, context ) :
			m = Messages()
			appendMessages( m, count, context )
			return m
Exemple #11
0
	def testFirstDifference( self ) :

		def generateMessages( count, context ) :
			m = Messages()
			appendMessages( m, count, context )
			return m

		def appendMessages( messages, count, context ) :
			for i in range( count ) :
				messages.add( Message( IECore.MessageHandler.Level( i % 4 ), context, "message %d" % i ) )

		# NB, bucketSize is 100 in the current implementation, we need to
		# definitely verify the results of this method in multi-bucket
		# scenarios, along with incomplete buckets.

		# Test one empty

		m1 = Messages()
		m2 = generateMessages( 10, "m" )

		self.assertIsNone( m1.firstDifference( m2 ) )
		self.assertEqual( m2.firstDifference( m1 ), 0 )

		# Test equal

		m1 = generateMessages( 1234, "m" )
		m2 = Messages( m1 )

		self.assertIsNone( m1.firstDifference( m2 ) )
		self.assertIsNone( m2.firstDifference( m1 ) )

		# Test all different

		m1 = generateMessages( 1234, "a" )
		m2 = generateMessages( 1234, "b" )

		self.assertEqual( m1.firstDifference( m2 ), 0 )
		self.assertEqual( m2.firstDifference( m1 ), 0 )

		# Test varying length

		m1 = generateMessages( 1102, "a" )
		m2 = Messages( m1 )
		appendMessages( m2, 100, "a" )

		self.assertIsNone( m1.firstDifference( m2 ) )
		self.assertEqual( m2.firstDifference( m1 ), 1102 )

		# Test some different

		m1 = generateMessages( 47, "a" )
		m2 = Messages( m1 )
		appendMessages( m1, 2, "a" )
		appendMessages( m2, 2, "b" )

		self.assertEqual( m1.firstDifference( m2 ), 47 )
		self.assertEqual( m2.firstDifference( m1 ), 47 )

		m1 = generateMessages( 1030, "a" )
		m2 = Messages( m1 )
		appendMessages( m1, 300, "b" )
		appendMessages( m2, 302, "a" )

		self.assertEqual( m1.firstDifference( m2 ), 1030 )
		self.assertEqual( m2.firstDifference( m1 ), 1030 )

		# Test comparison optimisation

		m1 = generateMessages( 30005, "a" )
		m2 = Messages( m1 )
		appendMessages( m1, 1, "a" )
		appendMessages( m2, 1, "b" )

		with GafferTest.TestRunner.PerformanceScope() :
			self.assertEqual( m1.firstDifference( m2 ), 30005 )