From VisualWorks®, 7.6 of February 1, 2008 on February 1, 2008 at 12:30:37 pm (Dialog confirm: 'You are filing-in a Parcel source file!\\While this is possible it will not have\the same effect as loading the parcel.\None of the Parcel''s prerequisites will\be loaded and none of its load actions\will be performed.\\Are you sure you want to file-in?' withCRs) ifFalse: [self error: 'Parcel file-in abandoned. Choose terminate or close.'] <class> <name>TestResult</name> <environment>Protocols</environment> <super>XProgramming.SUnit.TestResult</super> <private>false</private> none debugging <imports></imports> <category>Protocols-TestingExtensions</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <comment> Protocols.TestResult
This extends the SUnit TestResult to record the signaled exception for failures and errors, allowing for more detailed result summary. It also triggeres the changed/update mechanism allowing for UI feedback. Instance Variables: debugging <Boolean> should I suppress errors and failures
</comment> <class> <name>TestScripts</name> <environment>Protocols</environment> <super>Core.Object</super> <private>false</private> none <imports></imports> <category>Protocols-TestingExtensions</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <comment> Protocols.TestScripts
This is just a utility class for maintenance of our various testing scripts. Here's my little shell script that I use to run all our test scripts with a new build (currently I test on WinXP/w Cygwin, Linux and MacOSX). I create a 'testing' subdirectory of my main development directory with my development images and dump all the test scripts into .ws files named: tasn.ws tsec.ws topb.ws topc.ws tops.ws twsc.ws twst.ws tnet.ws You also need to create any of the settings-*.st files that are required by some of the test scripts (e.g. testNetClients). The build installation must also include the tests/ directory that comes from the InternalFiles tarball, that's the source of test parcels for the scripts. Then I just run the script from a bash prompt and if all works as expected I get a bunch of emails with test results a little while later. The 'vw' command is a tiny script that sets $VISUALWORKS and calls the appropriate VW executable, e.g (from my Cygwin setup): $ cat `which vw` #!/bin/bash export VISUALWORKS='e:\vw7.4.1' /opt/vw7.4.1/bin/win/vwntconsole.exe "$@" I guess it would be better to manage this with the visual command and VisualWorks.ini file at some point. Anyway, the test script looks as follows: #!/bin/sh if [ ! -f visual.im ] ; then cp $VISUALWORKS/image/visual.im . ; fi for file in tasn tsec topb topc tops twsc twst tnet ; do echo $file vw -nologo visual.im \ -headless -fileIn $file.ws \ -evaluate 'Transcript cr. #DONE' \ | tee $file.txt subject="$(grep RESULTS $file.txt)" if [ -z "$subject" ]; then subject="$(grep TOTAL $file.txt | tail -n 1)" ; fi subject="$file/$(uname): $subject" mail -s "$subject" kobetic@rogers.com < $file.txt ; done echo 'DONE'
</comment> <class> <name>MethodFilterPundle</name> <environment>Tools</environment> <super>Tools.MethodFilter</super> <private>false</private> none pundles packageCache <imports></imports> <category>Tools-Programming</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <class> <name>TestCase</name> <environment>Protocols</environment> <super>XProgramming.SUnit.TestCase</super> <private>false</private> none debugging <imports></imports> <category>Protocols-TestingExtensions</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <comment> Protocols.TestCase
This extends the SUnit TestCase with support for (a) keywords - allowing to assign a set of keywords to test case and (b) prerequisiteTests - which implies that for any test to pass, it's prerequisite tests must pass as well. It also adds a 'debugging' flag which will be set if the test is running in #debug mode. This flag can be used by testing code to provide additional instrumentation for debugging purposes only (e.g. more extensive logging, etc). The extended test running support takes the prerequisites into account sorting the tests into prerequisite tiers, and running the tiers in order. It also makes sure that any test resources are setUp before and torn down after for each TestCase suite. This allows different TestResources to exploit the same resources (e.g. using the same port numbers, etc). Instance Variables: debugging <Object> undocumented
</comment> <class> <name>TestCaseWithResource</name> <environment>Protocols</environment> <super>Protocols.TestCase</super> <private>false</private> none resource <imports></imports> <category>Protocols-TestingExtensions</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <comment> Protocols.TestCaseWithResource
This extends the SUnit TestCase to automatically cache the case's resource in an instance variable for easier access. Instance Variables: resource <TestResource> This holds the actual instance of the test resource so that it is conveniently accessible from the test methods.
</comment> <class> <name>TestResource</name> <environment>Protocols</environment> <super>XProgramming.SUnit.TestResource</super> <private>false</private> none <imports></imports> <category>Protocols-TestingExtensions</category> <attributes> <package>Protocols-TestingExtensions</package> </attributes> </class> <comment> Protocols.TestResource
This adds support for #debugging event. The test resources will be sent this notification before the test cases using it get to run in debugging mode, so it allows the resource to include additional debugging instrumentation in just this mode. Normal running mode will be unaffected.
</comment> <methods> Protocols.TestResult <category>Running</category>
newSubTotal ^self class new debugging: debugging; yourself
runCase: aTestCase [ [ self changed: #start with: aTestCase. aTestCase debugging: debugging. aTestCase runCase. self passed add: aTestCase. self changed: #success with: aTestCase ] on: self class failure do: [ :signal | self failures add: aTestCase -> signal. self changed: #failure with: aTestCase. debugging ifTrue: [signal pass] ] ] sunitOn: self class error do: [:signal | self errors add: aTestCase -> signal. self changed: #error with: aTestCase. debugging ifTrue: [signal pass] ]
</methods> <methods> Protocols.TestResult <category>Accessing</category>
debugging ^debugging
debugging: aBoolean debugging := aBoolean
</methods> <methods> Protocols.TestResult <category>Init / Release</category>
initialize super initialize. debugging := false
</methods> <methods> Protocols.TestResult <category>services</category>
addIn: aResult self errors addAll: aResult errors. self failures addAll: aResult failures. self passed addAll: aResult passed
printTotalsOn: aStream | printer | aStream nextPutAll: 'TOTAL : '; print: self; flush. printer := [ :ass || tc ex | tc := ass key. ex := ass value. aStream cr; tab; nextPutAll: ex description; cr; tab; tab; nextPutAll: tc class fullName; nextPutAll: ' debug: '; print: tc selector ]. self failureCount ~= 0 ifTrue: [ aStream cr; nextPutAll: 'FAILURES: '; print: self failureCount. self failures do: printer ]. self errorCount ~= 0 ifTrue: [ aStream cr; nextPutAll: 'ERRORS: '; print: self errorCount. self errors do: printer ]. aStream flush.
</methods> <methods> Protocols.TestScripts class <category>scripts</category>
testProtocols "This is the main test script that should be able to run the test suite in a fully loaded development image and also as a test script for build testing in an unmodified visual.im (with the Internal tarball installed). To run it as a build test script, just dump the code in this method into a file, e.g. test.st and then run it as follows: vw visual.im -fileIn test.st self testProtocols " | parcelPath testDir results | testDir := PortableFilename fromComponents: #('$(VISUALWORKS)' tests). parcelPath := Parcel searchPathModel value. (parcelPath includes: testDir) ifFalse: [ parcelPath addLast: testDir ]. Parcel ensureLoadedParcel: 'Protocols-TestingExtensions' withVersion: nil. results := Protocols.TestResult new. #( 'Protocols-Common-Tests' 'Protocols-CommonTypeMappingsTests' ) do: [ :package | Parcel ensureLoadedParcel: package withVersion: nil. Transcript cr. results addIn: (Protocols.TestCase runSuitesIn: package) ]. Transcript cr; cr. results printTotalsOn: Transcript
</methods> <methods> Tools.MethodFilterPundle <category>private</category>
privateSelectClass: aClass | classSymbol | classSymbol := aClass instanceBehavior absoluteSymbol. ^(self packages detect: [ :p | (p classModelAtClassSymbol: classSymbol ifAbsent: [nil]) notNil ] ifNone: [ nil ]) notNil
privateSelectClass: aClass selector: sel method: method | classSymbol emptyExtension | classSymbol := aClass instanceBehavior absoluteSymbol. emptyExtension := Store.ExtensionClassModel new. ^(self packages detect: [ :p | ( (p classModelAtClassSymbol: classSymbol ifAbsent: [emptyExtension]) selectorsMeta: aClass isMeta ) includes: sel ] ifNone: [ nil ] ) notNil
selectNameSpace: nameSpace key: name binding: binding | nsSymbol emptyExtension | nsSymbol := nameSpace absoluteSymbol. emptyExtension := Store.ExtensionNameSpaceModel new. ^(self packages detect: [ :p | (p modelAtSymbol: nsSymbol ifAbsent: [emptyExtension]) includesDataKey: name ] ifNone: [ nil ] ) notNil
</methods> <methods> Tools.MethodFilterPundle <category>accessing</category>
packages packageCache isNil ifTrue: [ packageCache := pundles inject: Set new into: [ :set : pundle | pundle isBundle ifTrue: [ set addAll: pundle leafItems ] ifFalse: [ set add: pundle ]. set ] ]. ^packageCache
pundle: aPundle pundles := Set with: aPundle
pundleName: aPundleName self pundle: (Store.Registry pundleNamed: aPundleName)
pundleNames: aPundleNameSet self pundles: (aPundleNameSet collect: [ :name | Store.Registry pundleNamed: name ])
pundles ^pundles
pundles: aPundleSet pundles := aPundleSet
</methods> <methods> Tools.MethodFilterPundle <category>printing</category>
auxiliaryDisplayString ^'in pundles <1s>' expandMacrosWith: (pundles collect: [ :p | p name ]) printString
displayString ^'In pundles <1s>' expandMacrosWith: (pundles collect: [ :p | p name ]) printString
</methods> <methods> Tools.MethodFilterPundle <category>ordering</category>
priority ^7
</methods> <methods> Tools.MethodFilterPundle class <category>tests</category>
testAll "(((self testPackage)))" self testBundle; testPackage
testBundle "(((self testBundle)))" | mc | mc := MethodCollector new. (mc select: (mc pundle: 'Tools') & (mc implementorsOf: #size)) size = 1 ifFalse: [self error: 'Test failed']
testPackage "(((self testPackage)))" | mc | mc := MethodCollector new. (mc select: (mc pundle: 'Tools-Differences') & (mc implementorsOf: #size)) size = 1 ifFalse: [self error: 'Test failed']
</methods> <methods> Protocols.TestCase <category>Running</category>
debug debugging := true. self resources do: [:res | res isAvailable ifFalse: [^res signalInitializationError]. res current debugging ]. [self runCase] sunitEnsure: [self resources do: [:each | each reset]]
debugUsing: aSymbol debugging := true. self areAllResourcesAvailable ifFalse: [ ^XProgramming.SUnit.TestResult signalErrorWith: 'Resource could not be initialized']. [self perform: aSymbol] sunitEnsure: [self resources do: [:each | each reset]]
run: aResult debugging := false. super run: aResult
</methods> <methods> Protocols.TestCase <category>attributes</category>
keywords "Return a list of symbols describing the key properties of the tests, much like book keywords. This is used to select out specific test suites for test runs, e.g. all TCP tests, all non mcast test, etc." ^#()
prerequisiteTests "Return the list of test classes that should be run before this one. Used to sort tests in a test run." ^#()
</methods> <methods> Protocols.TestCase <category>private</category>
debugging ^debugging
debugging: aBoolean debugging := aBoolean
setTestSelector: aSymbol super setTestSelector: aSymbol. debugging := false
</methods> <methods> Protocols.TestCase <category>opentalk</category>
total ^1
</methods> <methods> Protocols.TestCase class <category>Testing</category>
isAbstract "Let's assume for now that only leaf subclasses represent real test cases" ^self subclasses isEmpty not
shouldInheritSelectors ^true
</methods> <methods> Protocols.TestCase class <category>utilities - running</category>
addResult: aResult to: totalResult totalResult errors addAll: aResult errors. totalResult failures addAll: aResult failures. totalResult passed addAll: aResult passed
debug ^self runSuites: self testSuites total: (TestResult new debugging: true; yourself)
printResults: results Transcript cr; cr; show: 'RESULTS: '; show: ( '<1p> run, <2p> passed, <3p> failed, <4p> errors' expandMacrosWithArguments: ( results inject: #(0 0 0 0) into: [ :t :r | Array with: (t at: 1) + r runCount with: (t at: 2) + r passedCount with: (t at: 3) + r failureCount with: (t at: 4) + r errorCount ])). results do: [ :r | r defects do: [ :tex | Transcript cr; tab; show: ( '<1s> debug: <2p>.' expandMacrosWithArguments: ( Array with: tex key class fullName with: tex key selector)) ] ].
run ^self runSuites: self testSuites
runSuites: aSuiteCollection ^self runSuites: aSuiteCollection total: TestResult new
runSuites: aSuiteCollection total: aResult | total | total := aResult. (self sortSuites: aSuiteCollection) do: [ :s || result | Transcript cr; nextPutAll: s name; flush. result := aResult newSubTotal. [ s resources do: [ :res | res isAvailable ifFalse: [res signalInitializationError] ]. [s run: result] sunitEnsure: [s resources do: [:each | each reset]]. ] on: Error do: [ :ex | ex messageText: 'Resource Setup Failure: ', ex messageText. s tests do: [ :test | result errors add: test -> ex ] ]. total addIn: result. Transcript space; print: result; flush ]. Transcript cr;cr. total printTotalsOn: Transcript. ^total
runSuitesIn: pundleNames "Run suites in pundles. self runSuitesIn: 'Protocols-Common-Tests' self runSuitesIn: #('Protocols-Common-Tests') " ^self runSuites: ( self classSuitesMatching: ( pundleNames isCharacters ifTrue: [ MethodFilter pundle: pundleNames ] ifFalse: [ MethodFilter pundles: pundleNames ] ) )
runSuitesMatching: aMethodFilter " self runSuitesMatching: (MethodFilter pundles: #('Protocols-Common-Tests')) " ^self runSuites: (self suitesMatching: aMethodFilter)
</methods> <methods> Protocols.TestCase class <category>utilities - suites</category>
allTestSuites ^self buildSuite tests reject: [ :s | s tests isEmpty ]
classSuitesMatching: aMethodFilter "Build a collection of suites for each test class satisfying aMethodFilter. The filter will only filter classes not methods so only some types of filters will be relevant. self classSuitesMatching: (MethodFilter pundles: #('Protocols-Common-Tests')) " | filter classes suites | filter := aMethodFilter. classes := OrderedCollection new. SystemUtils allBehaviorsDo: [ :cls | ( (filter selectClass: cls) and: [ (cls includesBehavior: XProgramming.SUnit.TestCase) and: [ cls isAbstract not ] ] ) ifTrue: [ classes add: cls ] ]. suites := classes collect: [ :cls | cls buildSuite ]. ^suites reject: [ :s | s tests isEmpty ]
prerequisiteTiersFromSuites: aSuiteCollection | tiers remaining tier | tiers := OrderedCollection new. remaining := aSuiteCollection copy. [ tier := OrderedCollection new. remaining do: [ :r | "A tier are all remaining suites whose all prerequisites are not in remaining" r prerequisiteTests detect: [ :pt | (remaining detect: [ :p | p tests first class inheritsFrom: pt ] ifNone: [ nil ]) notNil ] ifNone: [ tier add: r ] ]. tier isEmpty ] whileFalse: [ remaining removeAll: tier. tiers add: tier ]. remaining isEmpty ifFalse: [ self error: 'Cannot sort graphs with cycles !' ]. ^tiers
printAllTestSuitesWithKeywords "(((self printAllTestSuitesWithKeywords)))" (self allTestSuites asSortedCollection: [ :a :b | a name < b name ]) do: [ :s | Transcript cr; nextPutAll: s name; space; print: s keywords ]. Transcript flush
printAllTestSuiteTiers "(((self printAllTestSuiteTiers)))" Transcript cr. (self prerequisiteTiersFromSuites: self allTestSuites) do: [ :t | t do: [ :s | Transcript show: s name; space ] ] separatedBy: [ Transcript cr; show: ' ------------------------------'; cr ]. Transcript flush
sortSuites: aSuiteCollection "Just concatenate the prerequisite tiers in order" ^(self prerequisiteTiersFromSuites: aSuiteCollection) inject: (OrderedCollection new: aSuiteCollection size) into: [ :sorted :tier | sorted addAll: tier. sorted ]
suitesMatching: aMethodFilter "Build a collection of suites (one suite per test class) with all test methods satisfying aMethodFilter (taking into account abstract classes and inherited case methods). self suitesMatching: (MethodFilter pundles: #('Protocols-Common-Tests')) " | filter cases suites | filter := (MethodFilter behavior: XProgramming.SUnit.TestCase) & aMethodFilter & (MethodFilter select: [ :m | m isKindOf: CompiledMethod ]) "filter out initializers" & (MethodFilter select: [ :m | 'test*' match: m selector ]). cases := filter select inject: OrderedCollection new into: [ :set :m || classes | classes := m implementingClass withAllSubclasses reject: [ :c | c isAbstract ]. classes := classes select: [ :c | filter selectSubClass: c ]. set, (classes collect: [ :c | c selector: m selector ]) ]. suites := cases inject: Dictionary new into: [ :map :case | (map at: case class ifAbsentPut: [ case class suiteClass named: case class name ]) addTest: case. map ]. ^suites values
testSuites ^self isAbstract ifTrue: [self allTestSuites] ifFalse: [OrderedCollection with: self buildSuite]
</methods> <methods> Protocols.TestCaseWithResource <category>setup/teardown</category>
resources ^self subclassResponsibility
setUp resource isNil ifTrue: [ resource := self resources first current ]. ^resource
tearDown resource := nil
</methods> <methods> Protocols.TestResource <category>Running</category>
debugging "Does nothing. Subclasses can override to provide additional debugging instrumentation."
</methods> <methods> Protocols.EventCollector <category>user interface</category>
inspectorActions ^Array with: (Tools.Trippy.Action label: 'To Transcript' block: [self toTranscript] enablement: [self events notEmpty]) with: (Tools.Trippy.Action label: 'Clear To Transcript' block: [self clearToTranscript] enablement: [self events notEmpty]) with: (Tools.Trippy.Action label: 'Clear' block: [self clear] enablement: [self events notEmpty]) with: (Tools.Trippy.Action label: 'Reset Clock' block: [self resetClock] enablement: [true])
</methods> <methods> Protocols.EventCollector <category>printing</category>
printOn: aStream super printOn: aStream. aStream nextPut: $[; print: events size; nextPut: $]
</methods> <methods> XProgramming.SUnit.TestSuite <category>opentalk</category>
keywords ^tests isEmpty ifTrue: [#()] ifFalse: [tests first keywords]
prerequisiteTests ^tests isEmpty ifTrue: [#()] ifFalse: [tests first prerequisiteTests]
printOn: aStream aStream nextPutAll: (name ifNil: [ 'TestSuite' ]); nextPut: $(; print: self total; nextPut: $)
total ^self tests inject: 0 into: [ :total :suite | total + suite total ]
</methods> <methods> Tools.MethodFilterOr <category>private</category>
selectSubClass: aClass | fp final | final := false. 1 to: filters size do: [:i | fp := (filters at: i) selectSubClass: aClass. final := final | fp]. ^final
</methods> <methods> Tools.MethodFilter class <category>building queries</category>
behavior: aBehavior "Answer a filter that answers all methods in a behavior, or one of its subclasses, or one of its superclasses. Do not search the metaclass's class hierarchy. This is especially useful when viewing instance variable accesses. | mc | mc := MethodCollector new. mc browseSelect: (mc instVarUse: 'format' access: #write) & (mc searchBehaviorHierarchy: Message class). mc browseSelect: (mc instVarUse: 'selector' access: #write) & (mc searchBehaviorHierarchy: Message). " ^MethodFilterClassHierarchy new targetClass: aBehavior; searchMetaclass: false
class: aClass "Answer a filter that answers all methods in a class, its superclass and subclass hierarchy, or the metaclass, or superclass and subclass hierarchy of the metaclass. This is useful when trying to restrict searches for implementors or references to a message. | mc | mc := MethodCollector new. mc browseSelect: (mc implementorsOf: #at:put:) & (mc searchClassHierarchy: OrderedCollection). mc browseSelect: (mc referencesTo: #at:put:) & (mc searchClassHierarchy: OrderedCollection). " ^MethodFilterClassHierarchy new targetClass: aClass instanceBehavior; searchMetaclass: true
implementorsOf: aSelector "Answer a filter that answers all implementors of a selector. | mc | mc := MethodCollector new. mc browseSelect: (mc implementorsOf: #at:put:). mc browseSelect: (mc implementorsOf: #at:put:) & (mc searchClassHierarchy: OrderedCollection). " ^MethodFilterImplementor new value: aSelector
nameSpace: aNameSpaceOrItsName "Answer a filter that answers methods in a NameSpace. | mc | mc := MethodCollector new. mc browseSelect: (mc nameSpace: 'Tools'). mc browseSelect: (mc nameSpace: 'Tools') & (mc searchClassHierarchy: VisualPart). " ^MethodFilterNameSpace new nameSpaceName: (aNameSpaceOrItsName isCharacters ifTrue: [aNameSpaceOrItsName] ifFalse: [aNameSpaceOrItsName name])
parcel: aParcelOrItsName "Answer a filter that answers methods in a parcel. | mc | mc := MethodCollector new. mc browseSelect: (mc parcel: 'UIPainter'). mc browseSelect: (mc parcel: 'UIPainter') & (mc searchClassHierarchy: Collection). " ^MethodFilterParcel new parcelName: (aParcelOrItsName isCharacters ifTrue: [aParcelOrItsName] ifFalse: [aParcelOrItsName name])
protocol: aString "Answer a filter that answers methods in a protocol. | mc | mc := MethodCollector new. mc browseSelect: (mc protocol: #accessing). mc browseSelect: (mc protocol: #accessing) & (mc searchClassHierarchy: Collection). " ^MethodFilterProtocol new category: aString
pundle: aPundleOrItsName "Answer a filter that answers methods in a pundle. | mc | mc := MethodCollector new. mc browseSelect: (mc pundle: 'Tools') & (mc searchClassHierarchy: Collection). " ^self pundles: (Set with: aPundleOrItsName)
pundles: aPundleOrPundleNameSet "Answer a filter that answers methods in a pundle. | mc | mc := MethodCollector new. mc browseSelect: (mc pundles: #('Tools' 'OS')) & (mc searchClassHierarchy: Collection). " ^(aPundleOrPundleNameSet detect: [ :p | p isCharacters ] ifNone: [ nil ]) notNil ifTrue: [MethodFilterPundle new pundleNames: aPundleOrPundleNameSet] ifFalse: [MethodFilterPundle new pundles: aPundleOrPundleNameSet]
referencesTo: anObject "Answer a filter that answers all references to a selector, static variable, or other method literal. | mc | mc := MethodCollector new. mc browseSelect: (mc referencesTo: #at:put:). mc browseSelect: (mc referencesTo: #at:put:) & (mc searchClassHierarchy: OrderedCollection). " ^MethodFilterReference new value: anObject
select: aBlock "Answer a filter that answers all methods for which aBlock answers true. | mc | mc := MethodCollector new. mc browseSelect: (mc methodsSelect: [:m| m numLiterals > 75]) " ^MethodFilterSelect new block: aBlock
</methods> <methods> Tools.MethodFilter <category>private</category>
selectSubClass: aClass ^self selectClass: aClass
</methods> <methods> Tools.MethodFilterAnd <category>private</category>
selectSubClass: aClass | fp final | final := true. 1 to: filters size do: [:i | fp := (filters at: i) selectSubClass: aClass. final := final & fp]. ^final
</methods> <methods> Protocols.EventPrinter <category>printing</category>
printOn: aStream aStream nextPutAll: self class name. label ifNotNil: [ aStream nextPut: $(; nextPutAll: label; nextPut: $) ]
</methods> <methods> XProgramming.SUnit.TestCase <category>private</category>
debugging: aBoolean
</methods> <methods> Tools.MethodFilterProtocol <category>private</category>
selectSubClass: aClass ^true
</methods> "Imported Classes:" self error: 'Attempting to file-in parcel imports. Choose terminate or close' <class> <name>Object</name> <environment>Core</environment> <super></super> <private>false</private> none <imports></imports> <category>Kernel-Objects</category> <attributes> <package>Kernel-Objects</package> </attributes> </class> <class> <name>MethodFilter</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none <imports></imports> <category>Tools-Programming</category> <attributes> <package>Tools-Programming</package> </attributes> </class> <class> <name>MethodFilterOr</name> <environment>Tools</environment> <super>Tools.MethodFilter</super> <private>false</private> none filters <imports></imports> <category>Tools-Programming</category> <attributes> <package>Tools-Programming</package> </attributes> </class> <class> <name>EventPrinter</name> <environment>Protocols</environment> <super>Protocols.EventProcessor</super> <private>false</private> none label <imports></imports> <category>Opentalk</category> <attributes> <package>Protocols-Common</package> </attributes> </class> <class> <name>TestResource</name> <environment>XProgramming.SUnit</environment> <super>Core.Object</super> <private>false</private> none name description current <imports></imports> <category>SUnit</category> <attributes> <package>SUnit</package> </attributes> </class> <class> <name>MethodFilterAnd</name> <environment>Tools</environment> <super>Tools.MethodFilter</super> <private>false</private> none filters <imports></imports> <category>Tools-Programming</category> <attributes> <package>Tools-Programming</package> </attributes> </class> <class> <name>TestCase</name> <environment>XProgramming.SUnit</environment> <super>Core.Object</super> <private>false</private> none testSelector <imports></imports> <category>SUnit</category> <attributes> <package>SUnit</package> </attributes> </class> <class> <name>TestResult</name> <environment>XProgramming.SUnit</environment> <super>Core.Object</super> <private>false</private> none failures errors passed <imports></imports> <category>SUnit</category> <attributes> <package>SUnit</package> </attributes> </class> <class> <name>EventCollector</name> <environment>Protocols</environment> <super>Protocols.EventPrinter</super> <private>false</private> none events baseClockValue <imports></imports> <category>Opentalk</category> <attributes> <package>Protocols-Common</package> </attributes> </class> <class> <name>TestSuite</name> <environment>XProgramming.SUnit</environment> <super>Core.Object</super> <private>false</private> none tests resources name <imports></imports> <category>SUnit</category> <attributes> <package>SUnit</package> </attributes> </class> <class> <name>MethodFilterProtocol</name> <environment>Tools</environment> <super>Tools.MethodFilter</super> <private>false</private> none category <imports></imports> <category>Tools-Programming</category> <attributes> <package>Tools-Programming</package> </attributes> </class>