AccessModifierTesting.ns

Newspeak3
'Root'
class AccessModifierTesting usingPlatform: platform  testFramework: minitest 
(* :exemplar: AccessModifierTesting usingPlatform: platform  testFramework: ide minitest *) = (|
	private TestContext = minitest TestContext.
	private ClassMirror = platform mirrors ClassMirror.
	private MessageNotUnderstood = platform kernel MessageNotUnderstood.
|) (
public class ClassAccessingTests = TestContext (
(*	Try to access classes with different access modifiers, but only via public send.
	 Class access is implemented via accessor methods - so fetching a class falls back to finding the appropriate method.
	All kind of different method sends are already tested in the MethodAcessingTests. *)
|
	testSubjects = TestSubjects new.
|) (
public testPrivateClassAccess = (
	should: [testSubjects APrivateClass] signal: MessageNotUnderstood.
)
public testProtectedClassAccess = (
	should: [testSubjects AProtectedClass] signal: MessageNotUnderstood.
)
public testPublicClassAccess = (
	assert: testSubjects APublicClass new ping = #pong.
)
public testPublicClassAccess2 = (
	testSubjects AClass
)
) : (
TEST_CONTEXT = ()
)
public class JITTests = TestContext () (
class A = () (
protected foo = (
	^'A'
)
) : (
)
class B = A () (
private foo = (
	^'B'
)
) : (
)
class C = B () (
public foo = (
	^'C'
)
public superFoo = (
	^super foo
)
) : (
)
class D1 = C () (
public foo = (
	^'D1'
)
) : (
)
class D2 = C () (
public foo = (
	^'D2'
)
) : (
)
class D3 = C () (
public foo = (
	^'D3'
)
) : (
)
class ImplicitReceiverMNU = ImplicitReceiverMNUSuper (
) (
private result = (
	^#ImplicitReceiverMNU.
)
public sendImplicitReceiverFoo = (
	^foo
)
) : (
)
class ImplicitReceiverMNUSuper = (
) (
doesNotUnderstand: message = (
	^result
)
private result = (
	^#ImplicitReceiverMNUSuper.
)
) : (
)
class OuterMNU = OuterMNUSuper (
) (
public class Inner = () (
public sendOuterFoo = (
	^outer OuterMNU foo
)
) : (
)
private result = (
	^#OuterMNU.
)
) : (
)
class OuterMNUSuper = (
) (
doesNotUnderstand: message = (
	^result (* This implicit receiver send will crash if the method receiver is wrong. *)
)
private result = (
	^#OuterMNUSuper.
)
) : (
)
class SelfMNU = SelfMNUSuper (
) (
private result = (
	^#SelfMNU
)
public sendSelfFoo = (
	^self foo
)
) : (
)
class SelfMNUSuper = (
) (
doesNotUnderstand: message = (
	^result
)
private result = (
	^#SelfMNUSuper
)
) : (
)
class SuperMNU = SuperMNUSuper (
) (
private result = (
	^#SuperMNU
)
public sendSuperFoo = (
	^super foo
)
) : (
)
class SuperMNUSuper = (
) (
doesNotUnderstand: message = (
	^result
)
private result = (
	^#SuperMNUSuper
)
) : (
)
public testImplicitReceiverMNU = (
	| aImplicitReceiverMnu = ImplicitReceiverMNU new. |
	10 timesRepeat:
		[assert: aImplicitReceiverMnu sendSuperFoo equals: #ImplicitReceiverMNUSuper].
)
public testOuterMNU = (
	| anInner = OuterMNU new Inner new. |
	10 timesRepeat:
		[assert: anInner sendOuterFoo equals: #OuterMNUSuper].
)
public testPolymorphicSuper = (
	| d1 = D1 new. d2 = D2 new. d3 = D3 new. |
	10 timesRepeat:
		[assert: d1 superFoo equals: 'A'.
		assert: d2 superFoo equals: 'A'.
		assert: d3 superFoo equals: 'A'].
)
public testSelfMNU = (
	| aSelfMnu = SelfMNU new. |
	10 timesRepeat:
		[assert: aSelfMnu sendSelfFoo equals: #SelfMNUSuper].
)
public testSuperMNU = (
	| aSuperMnu = SuperMNU new. |
	10 timesRepeat:
		[assert: aSuperMnu sendSuperFoo equals: #SuperMNUSuper].
)
) : (
TEST_CONTEXT = ()
)
public class MethodAccessingTests = TestContext (
(* Test access to methods with different access modifiers *)
|
	testSubjects = TestSubjects new.
|) (
public testDefaultImplicitReceiverSend = (
	(* send a message via an implicitReceiverSend which goes to a method with default access modifier *)
	assert: testSubjects ASubClass new ASubInnerClass new defaultImplicitReceiverSend = #defaultImplicitReceiverTarget.
)
public testDefaultImplicitReceiverSendWithInheritance = (
	(* send a message via implicitReceiverSend which goes to a method with default access modifier with inheritance *)
	assert: testSubjects ASubClass new defaultImplicitReceiverSendWithInheritance = #defaultMethod.
)
public testDefaultOuterSend = (
	(* send a message via an outerSend which goes to a method with default access modifier *)
	assert: testSubjects AClass new AInnerClass new outerDefaultMethod = #defaultMethod.
)
public testDefaultOuterSendWithInheritance = (
	(* send a message via an outerSend which goes to a method with default access modifier via inheritance *)
	assert: testSubjects ASubClass new ASubInnerClass new defaultOuterSendWithInheritance = #defaultMethod.
)
public testDefaultPublicSend = (
	(* send a message via publicSend which goes to a method with default access modifier *)
	should: [testSubjects AClass new defaultMethod] signal: MessageNotUnderstood.
)
public testDefaultPublicSendWithInheritance = (
	(* send a message via publicSend which goes to a method with default access modifier in the super chain *)
	should: [testSubjects ASubClass new defaultMethod] signal: MessageNotUnderstood.
)
public testDefaultSelfSend = (
	(* send a message via selfSend which goes to a method with default access modifier *)
	assert: testSubjects AClass new selfDefaultMethod = #defaultMethod.
)
public testDefaultSelfSendWithInheritance = (
	(* send a message via selfSend which goes to a method with default access modifier in the super chain *)
	assert: testSubjects ASubClass new selfDefaultMethod = #defaultMethod.
)
public testDefaultSuperSend = (
	(* send a message via superSend which goes to a method with default access modifier *)
	assert: testSubjects ASubClass new superDefaultMethod = #defaultMethod.
)
public testImplicitPrivateOverriddenByProtected = (
	assert: testSubjects AClass new AInnerClass new implicitPrivateOverriddenByProtected
	equals: #private.
	assert: testSubjects ASubClass new AInnerClass new implicitPrivateOverriddenByProtected
	equals: #private.
)
public testImplicitPrivateOverriddenByPublic = (
	assert: testSubjects AClass new AInnerClass new implicitPrivateOverriddenByPublic
	equals: #private.
	assert: testSubjects ASubClass new AInnerClass new implicitPrivateOverriddenByPublic
	equals: #private.
)
public testImplicitProtectedOverriddenByPrivate = (
	assert: testSubjects AClass new AInnerClass new implicitProtectedOverriddenByPrivate
	equals: #protected.
	assert: testSubjects ASubClass new AInnerClass new implicitProtectedOverriddenByPrivate
	equals: #protected.
)
public testImplicitProtectedOverriddenByPublic = (
	assert: testSubjects AClass new AInnerClass new implicitProtectedOverriddenByPublic
	equals: #protected.
	assert: testSubjects ASubClass new AInnerClass new implicitProtectedOverriddenByPublic
	equals: #public.
)
public testImplicitPublicOverriddenByPrivate = (
	assert: testSubjects AClass new AInnerClass new implicitPublicOverriddenByPrivate
	equals: #public.
	assert: testSubjects ASubClass new AInnerClass new implicitPublicOverriddenByPrivate
	equals: #public.
)
public testImplicitPublicOverriddenByProtected = (
	assert: testSubjects AClass new AInnerClass new implicitPublicOverriddenByProtected
	equals: #public.
	assert: testSubjects ASubClass new AInnerClass new implicitPublicOverriddenByProtected
	equals: #protected.
)
public testObjectEncapsulationPrivate = (
	| sharedClass = testSubjects AClass. |
	should: [ sharedClass new callPrivateMethodOn: sharedClass new ]
	signal: MessageNotUnderstood.
)
public testObjectEncapsulationProtected = (
	| sharedClass = testSubjects AClass. |
	should: [ sharedClass new callProtectedMethodOn: sharedClass new ]
	signal: MessageNotUnderstood.
)
public testOrdinaryPrivateOverriddenByProtected = (
	should: [testSubjects ASubClass new privateOverriddenByProtected]
	signal: MessageNotUnderstood.
)
public testOrdinaryPrivateOverriddenByPublic = (
	assert: testSubjects ASubClass new privateOverriddenByPublic
	equals: #public.
)
public testOrdinaryProtectedOverriddenByPrivate = (
	should: [testSubjects ASubClass new protectedOverriddenByPrivate]
	signal: MessageNotUnderstood.
)
public testOrdinaryProtectedOverriddenByPublic = (
	assert: testSubjects ASubClass new protectedOverriddenByPublic
	equals: #public.
)
public testOrdinaryPublicOverriddenByPrivate = (
	assert: testSubjects ASubClass new publicOverriddenByPrivate
	equals: #public.
)
public testOrdinaryPublicOverriddenByProtected = (
	should: [testSubjects ASubClass new publicOverriddenByProtected]
	signal: MessageNotUnderstood.
)
public testOuterPrivateOverriddenByProtected = (
	assert: testSubjects AClass new AInnerClass new outerPrivateOverriddenByProtected
	equals: #private.
	assert: testSubjects ASubClass new AInnerClass new outerPrivateOverriddenByProtected
	equals: #private.
)
public testOuterPrivateOverriddenByPublic = (
	assert: testSubjects AClass new AInnerClass new outerPrivateOverriddenByPublic
	equals: #private.
	assert: testSubjects ASubClass new AInnerClass new outerPrivateOverriddenByPublic
	equals: #private.
)
public testOuterProtectedOverriddenByPrivate = (
	assert: testSubjects AClass new AInnerClass new outerProtectedOverriddenByPrivate
	equals: #protected.
	assert: testSubjects ASubClass new AInnerClass new outerProtectedOverriddenByPrivate
	equals: #protected.
)
public testOuterProtectedOverriddenByPublic = (
	assert: testSubjects AClass new AInnerClass new outerProtectedOverriddenByPublic
	equals: #protected.
	assert: testSubjects ASubClass new AInnerClass new outerProtectedOverriddenByPublic
	equals: #public.
)
public testOuterPublicOverriddenByPrivate = (
	assert: testSubjects AClass new AInnerClass new outerPublicOverriddenByPrivate
	equals: #public.
	assert: testSubjects ASubClass new AInnerClass new outerPublicOverriddenByPrivate
	equals: #public.
)
public testOuterPublicOverriddenByProtected = (
	assert: testSubjects AClass new AInnerClass new outerPublicOverriddenByProtected
	equals: #public.
	assert: testSubjects ASubClass new AInnerClass new outerPublicOverriddenByProtected
	equals: #protected.
)
public testOverriddenMethodInASubInnerClassClassViaImplicitReceiverSend = (
	assert: testSubjects ASubClass new callOverriddenMethod = #privateOverriddenMethod.
)
public testOverriddenMethodInInnerClassPublicSend = (
	assert: testSubjects ASubClass new overriddenMethod equals: #overriddenMethod
)
public testOverriddenMethodInSuperClassViaImplicitReceiverSend = (
	assert: testSubjects AClass new AInnerClass new callHiddenMethod = #privateHiddenMethod.
)
public testOverriddenMethodInSuperClassViaPublicSend = (
	should: [testSubjects AClass new AInnerClass new hiddenMethod] signal: MessageNotUnderstood.
)
public testPrivateDoesNotUnderstand = (
	assert: testSubjects WithPrivateDNU new foo
	equals: #privateDNU.
)
public testPrivateImplicitReceiverSend = (
	(* send a message via implicitReceiverSend which goes to a private method *)
	assert: testSubjects ASubClass new ASubInnerClass new privateImplicitReceiverSend = #privateImplicitReceiverTarget.
)
public testPrivateImplicitReceiverSendWithInheritance = (
	(* send a message via implicitReceiverSend which goes to a private method via inheritance *)
	should: [testSubjects ASubClass new privateImplicitReceiverSendWithInheritance] signal: MessageNotUnderstood.
)
public testPrivateOuterSend = (
	(* send a message via outerSend which goes to a private method *)
	assert: testSubjects AClass new AInnerClass new outerPrivateMethod = #privateMethod.
)
public testPrivateOuterSendWithInheritance = (
	(* send a message via outerSend which goes to a private method via inheritance *)
	should: [testSubjects ASubClass new ASubInnerClass new privateOuterSendWithInheritance] signal: MessageNotUnderstood.
)
public testPrivatePublicSend = (
	(* send a message via publicSend which goes to a private method *)
	should: [testSubjects AClass new privateMethod] signal: MessageNotUnderstood.
)
public testPrivatePublicSendWithInheritance = (
	(* send a message via publicSend which goes to a private method in the super chain *)
	should: [testSubjects ASubClass new privateMethod] signal: MessageNotUnderstood.
)
public testPrivateSelfSend = (
	(* send a message via selfSend which goes to a private method*)
	assert: testSubjects AClass new selfPrivateMethod = #privateMethod.
)
public testPrivateSelfSendwithInheritance = (
	(* send a message via selfSend which goes to a private method in the super chain *)
	should: [ testSubjects ASubClass new selfPrivateMethod ] signal: MessageNotUnderstood.
)
public testPrivateSuperSend = (
	(* send a message via superSend which goes to a private method *)
	should: [ testSubjects ASubClass new superPrivateMethod ] signal: MessageNotUnderstood.
)
public testProtectedImplicitReceiverSend = (
	(* send a message via implicitReceiverSend which goes to a protected method *)
	assert: testSubjects ASubClass new ASubInnerClass new protectedImplicitReceiverSend = #protectedImplicitReceiverTarget.
)
public testProtectedImplicitReceiverSendWithInheritance = (
	(* send a message via implicitReceiverSend which goes to a protected method via inheritance *)
	assert: testSubjects ASubClass new protectedImplicitReceiverSendWithInheritance = #protectedMethod.
)
public testProtectedOuterSend = (
	(* send a message via outerSend which goes to a protected method *)
	assert: testSubjects AClass new AInnerClass new outerProtectedMethod = #protectedMethod.
)
public testProtectedOuterSendWithInheritance = (
	(* send a message via outerSend which goes to a protected method via inheritance *)
	assert: testSubjects ASubClass new ASubInnerClass new protectedOuterSendWithInheritance = #protectedMethod.
)
public testProtectedPublicSend = (
	(* send a message via publicSend which goes to a protected method *)
	should: [testSubjects AClass new protectedMethod] signal: MessageNotUnderstood.
)
public testProtectedPublicSendWithInheritance = (
	(* send a message via publicSend which goes to a protected method in the super chain *)
	should: [testSubjects ASubClass new protectedMethod] signal: MessageNotUnderstood.
)
public testProtectedSelfSend = (
	(* send a message via selfSend which goes to a protected method*)
	assert: testSubjects AClass new selfProtectedMethod = #protectedMethod.
)
public testProtectedSelfSendWithInheritance = (
	(* send a message via selfSend which goes to a protected method in the super chain *)
	assert: testSubjects ASubClass new selfProtectedMethod = #protectedMethod.
)
public testProtectedSendDNULookupClass = (
	assert: testSubjects ADNUSubClass new sendSelfFoo equals: 'ADNUSubClass foo'.
	assert: testSubjects ADNUSubClass new sendSuperFoo equals: 'ADNUClass doesNotUnderstand: foo'.
	assert: testSubjects ADNUSubClass new sendSelfBar equals: 'ADNUSubClass doesNotUnderstand: bar'.
	assert: testSubjects ADNUSubClass new sendSuperBar equals: 'ADNUClass doesNotUnderstand: bar'.
)
public testProtectedSuperSend = (
	(* send a message via superSend which goes to a protected method *)
	assert: testSubjects ASubClass new superProtectedMethod = #protectedMethod.
)
public testPublicImplicitReceiverSend = (
	(* send a message via implicitReceiverSend which goes to a public method *)
	assert: testSubjects ASubClass new ASubInnerClass new publicImplicitReceiverSend = #publicImplicitReceiverTarget.
)
public testPublicImplicitReceiverSendWithInheritance = (
	(* send a message via implicitReceiverSend which goes to a public method via inheritance *)
	assert: testSubjects ASubClass new publicImplicitReceiverSendWithInheritance = #publicMethod.
)
public testPublicOuterSend = (
	(* send a message via outerSend which goes to a public method *)
	assert: testSubjects AClass new AInnerClass new outerPublicMethod = #publicMethod.
)
public testPublicOuterSendWithInheritance = (
	(* send a message via outerSend which goes to a public method via inheritance *)
	assert: testSubjects ASubClass new ASubInnerClass new publicOuterSendWithInheritance = #publicMethod.
)
public testPublicPublicSend = (
	(* send a message via publicSend which goes to a public method *)
	assert: testSubjects AClass new publicMethod = #publicMethod.
)
public testPublicPublicSendWithInheritance = (
	(* send a message via publicSend which goes to a public method in the super chain *)
	assert: testSubjects ASubClass new publicMethod = #publicMethod.
)
public testPublicSelfSend = (
	(* send a message via selfSend which goes to a public method*)
	assert: testSubjects AClass new selfPublicMethod = #publicMethod.
)
public testPublicSelfSendWithInheritance = (
	(* send a message via selfSend which goes to a public method in the super chain *)
	assert: testSubjects ASubClass new selfPublicMethod = #publicMethod.
)
public testPublicSuperSend = (
	(* send a message via superSend which goes to a public method *)
	assert: testSubjects ASubClass new superPublicMethod = #publicMethod.
)
public testSelfPrivateOverriddenByProtected = (
	assert: testSubjects ASubClass new selfPrivateOverriddenByProtected
	equals: #private.
	assert: testSubjects ASubClass new selfFromSubPrivateOverriddenByProtected
	equals: #protected.
)
public testSelfPrivateOverriddenByPublic = (
	assert: testSubjects ASubClass new selfPrivateOverriddenByPublic
	equals: #private.
	assert: testSubjects ASubClass new selfFromSubPrivateOverriddenByPublic
	equals: #public.
)
public testSelfProtectedOverriddenByPrivate = (
	assert: testSubjects ASubClass new selfProtectedOverriddenByPrivate
	equals: #protected.
	assert: testSubjects ASubClass new selfFromSubProtectedOverriddenByPrivate
	equals: #private.
)
public testSelfProtectedOverriddenByPublic = (
	assert: testSubjects ASubClass new selfProtectedOverriddenByPublic
	equals: #public.
	assert: testSubjects ASubClass new selfFromSubProtectedOverriddenByPublic
	equals: #public.
)
public testSelfPublicOverriddenByPrivate = (
	assert: testSubjects ASubClass new selfPublicOverriddenByPrivate
	equals: #public.
	assert: testSubjects ASubClass new selfFromSubPublicOverriddenByPrivate
	equals: #private.
)
public testSelfPublicOverriddenByProtected = (
	assert: testSubjects ASubClass new selfPublicOverriddenByProtected
	equals: #protected.
	assert: testSubjects ASubClass new selfFromSubPublicOverriddenByProtected
	equals: #protected.
)
public testSuperPrivateOverriddenByProtected = (
	should: [testSubjects ASubClass new superFromSubPrivateOverriddenByProtected]
	signal: MessageNotUnderstood.
)
public testSuperPrivateOverriddenByPublic = (
	should: [testSubjects ASubClass new superFromSubPrivateOverriddenByPublic]
	signal: MessageNotUnderstood.
)
public testSuperProtectedOverriddenByPrivate = (
	assert: testSubjects ASubClass new superFromSubProtectedOverriddenByPrivate
	equals: #protected.
)
public testSuperProtectedOverriddenByPublic = (
	assert: testSubjects ASubClass new superFromSubProtectedOverriddenByPublic
	equals: #protected.
)
public testSuperPublicOverriddenByPrivate = (
	assert: testSubjects ASubClass new superFromSubPublicOverriddenByPrivate
	equals: #public.
)
public testSuperPublicOverriddenByProtected = (
	assert: testSubjects ASubClass new superFromSubPublicOverriddenByProtected
	equals: #public.
)
) : (
TEST_CONTEXT = ()
)
public class SlotAccessingTests = TestContext (
(*	Try to access slots with different access modifiers, but only via public send.
	 Slot access is implemented via accessor methods - so fetching a slot falls back to finding the appropriate method.
	All kind of different method sends are already tested in the MethodAcessingTests. *)
|
	testSubjects = TestSubjects new.
|) (
public testDefaultSlotAccess = (
	should: [testSubjects AClass new defaultSlot] signal: MessageNotUnderstood.
)
public testPrivateSlotAccess = (
	should: [testSubjects AClass new privateSlot] signal: MessageNotUnderstood.
)
public testProtectedSlotAccess = (
	should: [testSubjects AClass new protectedSlot] signal: MessageNotUnderstood.
)
public testPublicSlotAccess = (
	assert: testSubjects AClass new publicSlot = #publicSlot.
)
) : (
TEST_CONTEXT = ()
)
public class TestSubjects = (
(* Holds a bunch of classes which we test against *)
) (
public class AClass = (
(* A class with a default access modifier. Slots and methods of all sort to be tested against *)
|
	public		publicSlot		= #publicSlot.
	protected	protectedSlot	= #protectedSlot.
	private		privateSlot		= #privateSlot.
				defaultSlot		= #defaultSlot.
|) (
public class AInnerClass = (
(* A class to test outerSends with different accessModifiers.*)
|
	public		publicSlot		= #innerPublicSlot.
	protected	protectedSlot	= #innerProtectedSlot.
	private		privateSlot		= #innerPrivateSlot.
				defaultSlot		= #innerDefaultSlot.
|) (
public callHiddenMethod = (
	^hiddenMethod
)
defaultMethod = (
	^#innerDefaultMethod
)
private hiddenMethod = (
	(*	This is a private method which hides a method with the same signature from an outer class.
		The outer method should never be executed when called from an instance of this class via implicit receiver send. *)
	^#privateHiddenMethod
)
public implicitPrivateOverriddenByProtected = (
	^privateOverriddenByProtected
)
public implicitPrivateOverriddenByPublic = (
	^privateOverriddenByPublic
)
public implicitProtectedOverriddenByPrivate = (
	^protectedOverriddenByPrivate
)
public implicitProtectedOverriddenByPublic = (
	^protectedOverriddenByPublic
)
public implicitPublicOverriddenByPrivate = (
	^publicOverriddenByPrivate
)
public implicitPublicOverriddenByProtected = (
	^publicOverriddenByProtected
)
public outerDefaultMethod = (
	^outer AClass defaultMethod
)
public outerPrivateMethod = (
	^outer AClass privateMethod
)
public outerPrivateOverriddenByProtected = (
	^outer AClass privateOverriddenByProtected
)
public outerPrivateOverriddenByPublic = (
	^outer AClass privateOverriddenByPublic
)
public outerProtectedMethod = (
	^outer AClass protectedMethod
)
public outerProtectedOverriddenByPrivate = (
	^outer AClass protectedOverriddenByPrivate
)
public outerProtectedOverriddenByPublic = (
	^outer AClass protectedOverriddenByPublic
)
public outerPublicMethod = (
	^outer AClass publicMethod
)
public outerPublicOverriddenByPrivate = (
	^outer AClass publicOverriddenByPrivate
)
public outerPublicOverriddenByProtected = (
	^outer AClass publicOverriddenByProtected
)
private privateMethod = (
	^#innerPrivateMethod
)
protected protectedMethod = (
	^#innerProtectedMethod
)
public publicMethod = (
	^#innerPublicMethod
)
) : (
)
public callPrivateMethodOn: other = (
	^other privateMethod
)
public callProtectedMethodOn: other = (
	^other protectedMethod
)
defaultMethod = (
	^#defaultMethod
)
public hiddenMethod = (
	(*	This is a public method which is hidden by an inner class.
		This should never be executed when called from the inner class via implicit receiver send. *)
	^#hiddenMethod
)
public overriddenMethod = (
	(*	This is a public method which is overridden by a subclass.
		This should never be executed when called from the subclass via implicit receiver send. *)
	^#overriddenMethod
)
private privateMethod = (
	^#privateMethod
)
private privateOverriddenByProtected = (
	^#private
)
private privateOverriddenByPublic = (
	^#private
)
protected protectedMethod = (
	^#protectedMethod
)
protected protectedOverriddenByPrivate = (
	^#protected
)
protected protectedOverriddenByPublic = (
	^#protected
)
public publicMethod = (
	^#publicMethod
)
public publicOverriddenByPrivate = (
	^#public
)
public publicOverriddenByProtected = (
	^#public
)
public selfDefaultMethod = (
	^self defaultMethod
)
public selfPrivateMethod = (
	^self privateMethod
)
public selfPrivateOverriddenByProtected = (
	^self privateOverriddenByProtected
)
public selfPrivateOverriddenByPublic = (
	^self privateOverriddenByPublic
)
public selfProtectedMethod = (
	^self protectedMethod
)
public selfProtectedOverriddenByPrivate = (
	^self protectedOverriddenByPrivate
)
public selfProtectedOverriddenByPublic = (
	^self protectedOverriddenByPublic
)
public selfPublicMethod = (
	^self publicMethod
)
public selfPublicOverriddenByPrivate = (
	^self publicOverriddenByPrivate
)
public selfPublicOverriddenByProtected = (
	^self publicOverriddenByProtected
)
) : (
)
class ADNUClass = (
) (
protected doesNotUnderstand: message = (
	^'ADNUClass doesNotUnderstand: ' , message selector
)
) : (
)
public class ADNUSubClass = ADNUClass (
) (
protected doesNotUnderstand: message = (
	^'ADNUSubClass doesNotUnderstand: ' , message selector
)
foo = (
	^'ADNUSubClass foo'
)
public sendSelfBar = (
	^self bar
)
public sendSelfFoo = (
	^self foo
)
public sendSuperBar = (
	^super bar
)
public sendSuperFoo = (
	^super foo
)
) : (
)
private class APrivateClass = () (
) : (
)
class AProtectedClass = () (
) : (
)
public class APublicClass = () (
public ping = (
	^#pong
)
) : (
)
public class ASubClass = AClass (
(* A class to test access to inherited slots/methods *)
) (
public class ASubInnerClass = (
(* A Class to test outerSends in combination with inheritance *)
|
				defaultImplicitReceiverTarget		= #defaultImplicitReceiverTarget.
	public		publicImplicitReceiverTarget		= #publicImplicitReceiverTarget.
	protected	protectedImplicitReceiverTarget	= #protectedImplicitReceiverTarget.
	private		privateImplicitReceiverTarget		= #privateImplicitReceiverTarget.
|) (
public defaultImplicitReceiverSend = (
	^defaultImplicitReceiverTarget
)
public defaultOuterSendWithInheritance = (
	^outer ASubClass defaultMethod
)
public privateImplicitReceiverSend = (
	^privateImplicitReceiverTarget
)
public privateOuterSendWithInheritance = (
	^outer ASubClass privateMethod
)
public protectedImplicitReceiverSend = (
	^protectedImplicitReceiverTarget
)
public protectedOuterSendWithInheritance = (
	^outer ASubClass protectedMethod
)
public publicImplicitReceiverSend = (
	^publicImplicitReceiverTarget
)
public publicOuterSendWithInheritance = (
	^outer ASubClass publicMethod
)
) : (
)
public callOverriddenMethod = (
	^overriddenMethod
)
public defaultImplicitReceiverSendWithInheritance = (
	^defaultMethod
)
private overriddenMethod = (
	(*	This is a private method which overrides a method with the same signature from a super class.
		The super method should never be executed when called from an instance of this class via implicit receiver send. *)
	^#privateOverriddenMethod
)
public privateImplicitReceiverSendWithInheritance = (
	^privateMethod
)
protected privateOverriddenByProtected = (
	^#protected
)
public privateOverriddenByPublic = (
	^#public
)
public protectedImplicitReceiverSendWithInheritance = (
	^protectedMethod
)
private protectedOverriddenByPrivate = (
	^#private
)
public protectedOverriddenByPublic = (
	^#public
)
public publicImplicitReceiverSendWithInheritance = (
	^publicMethod
)
private publicOverriddenByPrivate = (
	^#private
)
protected publicOverriddenByProtected = (
	^#protected
)
public selfDefaultMethod = (
	^self defaultMethod
)
public selfFromSubPrivateOverriddenByProtected = (
	^self privateOverriddenByProtected
)
public selfFromSubPrivateOverriddenByPublic = (
	^self privateOverriddenByPublic
)
public selfFromSubProtectedOverriddenByPrivate = (
	^self protectedOverriddenByPrivate
)
public selfFromSubProtectedOverriddenByPublic = (
	^self protectedOverriddenByPublic
)
public selfFromSubPublicOverriddenByPrivate = (
	^self publicOverriddenByPrivate
)
public selfFromSubPublicOverriddenByProtected = (
	^self publicOverriddenByProtected
)
public selfPrivateMethod = (
	^self privateMethod
)
public selfProtectedMethod = (
	^self protectedMethod
)
public selfPublicMethod = (
	^self publicMethod
)
public superDefaultMethod = (
	^super defaultMethod
)
public superFromSubPrivateOverriddenByProtected = (
	^super privateOverriddenByProtected
)
public superFromSubPrivateOverriddenByPublic = (
	^super privateOverriddenByPublic
)
public superFromSubProtectedOverriddenByPrivate = (
	^super protectedOverriddenByPrivate
)
public superFromSubProtectedOverriddenByPublic = (
	^super protectedOverriddenByPublic
)
public superFromSubPublicOverriddenByPrivate = (
	^super publicOverriddenByPrivate
)
public superFromSubPublicOverriddenByProtected = (
	^super publicOverriddenByProtected
)
public superPrivateMethod = (
	^super privateMethod
)
public superProtectedMethod = (
	^super protectedMethod
)
public superPublicMethod = (
	^super publicMethod
)
) : (
)
public class WithPrivateDNU = () (
private doesNotUnderstand: message = (
	^#privateDNU
)
) : (
)
) : (
)
) : (
)