Attachment #23871 for bug #98901

View | Details | Raw Unified | Return to bug 98901 | Differences between
Collapse All | Expand All




   <!--     End of generics tests                                      -->
   <!-- ============================================================== -->
   
   <ajc-test dir="bugs150/pr98901" title="public method with declare @method">
     <compile files="Case01.aj" options="-1.5 -Xlint:error"/>
     <run class="B01">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
   <ajc-test dir="bugs150/pr98901" title="public method on the aspect that declares @method on it">
     <compile files="Case02.aj" options="-1.5 -Xlint:error"/>
     <run class="B02">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
   <ajc-test dir="bugs150/pr98901" title="public annotated method">
     <compile files="Case03.aj" options="-1.5 -Xlint:error"/>
     <run class="B03">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public ITD method with declare @method">
     <compile files="Case04.aj" options="-1.5 -Xlint:error"/>
     <run class="B04">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public annotated ITD method">
     <compile files="Case05.aj" options="-1.5 -Xlint:error"/>
     <run class="B05">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public ITD-on-itself method with declare @method">
     <compile files="Case06.aj" options="-1.5 -Xlint:error"/>
     <run class="B06">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public annotated ITD-on-itself method">
     <compile files="Case07.aj" options="-1.5 -Xlint:error"/>
     <run class="B07">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public method on an Interface with declare @method">
     <compile files="Case08.aj" options="-1.5 -Xlint:error"/>
     <run class="B08">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public annotated method on an Interface">
     <compile files="Case09.aj" options="-1.5 -Xlint:error"/>
     <run class="B09">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public ITD method onto an Interface with declare @method">
     <compile files="Case10.aj" options="-1.5 -Xlint:error"/>
     <run class="B10">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public annotated ITD method onto an Interface">
     <compile files="Case11.aj" options="-1.5 -Xlint:error"/>
     <run class="B11">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract method with declare @method">
     <compile files="Case12.aj" options="-1.5 -Xlint:error"/>
     <run class="B12">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public abstract method on the aspect that declares @method on it">
     <compile files="Case13.aj" options="-1.5 -Xlint:error"/>
     <run class="B13">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract annotated method">
     <compile files="Case14.aj" options="-1.5 -Xlint:error"/>
     <run class="B14">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract ITD method with declare @method">
     <compile files="Case15.aj" options="-1.5 -Xlint:error"/>
     <run class="B15">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD method">
     <compile files="Case16.aj" options="-1.5 -Xlint:error"/>
     <run class="B16">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract ITD-on-itself method with declare @method">
     <compile files="Case17.aj" options="-1.5 -Xlint:error"/>
     <run class="B17">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD-on-itself method">
     <compile files="Case18.aj" options="-1.5 -Xlint:error"/>
     <run class="B18">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract method on an Interface with declare @method">
     <compile files="Case19.aj" options="-1.5 -Xlint:error"/>
     <run class="B19">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public abstract annotated method on an Interface">
     <compile files="Case20.aj" options="-1.5 -Xlint:error"/>
     <run class="B20">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract ITD method onto an Interface with declare @method">
     <compile files="Case21.aj" options="-1.5 -Xlint:error"/>
     <run class="B21">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD method onto an Interface">
     <compile files="Case22.aj" options="-1.5 -Xlint:error"/>
     <run class="B22">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public field with declare @field">
     <compile files="Case23.aj" options="-1.5 -Xlint:error"/>
     <run class="B23">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
  

<ajc-test dir="bugs150/pr98901" title="public field on the aspect that declares @field on it">
     <compile files="Case24.aj" options="-1.5 -Xlint:error"/>
     <run class="B24">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public annotated field">
     <compile files="Case25.aj" options="-1.5 -Xlint:error"/>
     <run class="B25">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public ITD field with declare @field">
     <compile files="Case26.aj" options="-1.5 -Xlint:error"/>
     <run class="B26">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>

<ajc-test dir="bugs150/pr98901" title="public annotated ITD field">
     <compile files="Case27.aj" options="-1.5 -Xlint:error"/>
     <run class="B27">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public ITD-on-itself field with declare @field">
     <compile files="Case28.aj" options="-1.5 -Xlint:error"/>
     <run class="B28">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
<ajc-test dir="bugs150/pr98901" title="public annotated ITD-on-itself field">
     <compile files="Case29.aj" options="-1.5 -Xlint:error"/>
     <run class="B29">
         <stdout>
           <line text="@anInterface()"/>
         </stdout>
       </run>
   </ajc-test>
   
</suite>




// "public method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A01{
	public void a(){}
}

aspect B01 {
	declare @method : void A01.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A01.class;
		try {
		Method m = c.getDeclaredMethod("a", new Class [0]);
		Annotation [] anns = m.getDeclaredAnnotations();
		for (int i = 0;i < anns.length;i++){
			System.out.println(anns[i]);
		}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




//"public method on the aspect that declares @method on it"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B02 {
	public void a(){}
	declare @method : void B02.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = B02.class;
		try {
		Method m = c.getDeclaredMethod("a", new Class [0]);
		Annotation [] anns = m.getDeclaredAnnotations();
		for (int i = 0;i < anns.length;i++){
			System.out.println(anns[i]);
		}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




//"public annotated method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A03{
	@anInterface
	public void a(){}
}

aspect B03 {
	
	public static void main(String [] args){
		Class c = A03.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public ITD method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A04{
}

aspect B04 {
	
	public void A04.a(){}
	declare @method : void A04.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A04.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public annotated ITD method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A05{
}

aspect B05 {
	
	@anInterface
	public void A05.a(){}
	
	public static void main(String [] args){
		Class c = A05.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public ITD-on-itself method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B06 {
	
	public void B06.a(){}
	declare @method : void B06.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = B06.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




//"public annotated ITD-on-itself method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B07 {
	
	@anInterface
	public void B07.a(){}
	
	public static void main(String [] args){
		Class c = B07.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public method on an Interface with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A08{
	public void a();
}

aspect B08 {
	
	declare @method : void A08.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A08.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public annotated method on an Interface"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A09{
	@anInterface
	public void a();
}

aspect B09 {
	
	public static void main(String [] args){
		Class c = A09.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public ITD method onto an Interface with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A10{
}

aspect B10 {
	
	public void A10.a(){}
	declare @method : void A10.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A10.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




//"public annotated ITD method onto an Interface"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A11{
}

aspect B11 {
	
	@anInterface
	public void A11.a(){}
	
	public static void main(String [] args){
		Class c = A11.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract class A12{
	public abstract void a();
}

aspect B12 {
	
	declare @method : abstract void A12.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A12.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract method on the aspect that declares @method on it"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract aspect A13{
	public abstract void a();
	declare @method : abstract void A13.a(..) : @anInterface;
}

aspect B13 {
	
	public static void main(String [] args){
		Class c = A13.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract annotated method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract class A14{
	@anInterface
	public abstract void a();
}

aspect B14 {
	
	public static void main(String [] args){
		Class c = A14.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract ITD method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract class A15{
}

aspect B15 {
	
	public abstract void A15.a();
	declare @method : abstract void A15.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A15.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract annotated ITD method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract class A16{
}

aspect B16 {
	
	@anInterface
	public abstract void A16.a();
	
	public static void main(String [] args){
		Class c = A16.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract ITD-on-itself method with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract aspect A17 {
	public abstract void A17.a();
	declare @method : abstract void A17.a(..) : @anInterface;
}

aspect B17 {
	
	public static void main(String [] args){
		Class c = A17.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract annotated ITD-on-itself method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

abstract aspect A18 {
	@anInterface
	public abstract void A18.a();
}

aspect B18 {
	
	public static void main(String [] args){
		Class c = A18.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




//"public abstract method on an Interface with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A19 {
	public abstract void a();
}

aspect B19 {
	
	declare @method : abstract void A19.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A19.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract annotated method on an Interface"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A20 {
	@anInterface
	public abstract void a();
}

aspect B20 {
	
	public static void main(String [] args){
		Class c = A20.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract ITD method onto an Interface with declare @method"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A21 {
}

aspect B21 {
	
	public abstract void A21.a();
	declare @method : abstract void A21.a(..) : @anInterface;
	
	public static void main(String [] args){
		Class c = A21.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public abstract annotated ITD method onto an Interface"

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

interface A22 {
}

aspect B22 {
	
	@anInterface
	public abstract void A22.a();
	
	public static void main(String [] args){
		Class c = A22.class;
		try {
			Method m = c.getDeclaredMethod("a", new Class [0]);
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public field with declare @field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A23 {
	public int a;
}

aspect B23 {
	
	declare @field : int A23.a : @anInterface;
	
	public static void main(String [] args){
		Class c = A23.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public field on the aspect that declares @field on it"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B24 {
	
	public int a;
	declare @field : int B24.a : @anInterface;
	
	public static void main(String [] args){
		Class c = B24.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public annotated field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A25{
	@anInterface
	public int a;
}

aspect B25 {
	
	public static void main(String [] args){
		Class c = A25.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public ITD field with declare @field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A26{
}

aspect B26 {
	
	public int A26.a;
	declare @field : int A26.a : @anInterface;
	
	public static void main(String [] args){
		Class c = A26.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public annotated ITD field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

class A27{
}

aspect B27 {
	
	@anInterface
	public int A27.a;
	
	public static void main(String [] args){
		Class c = A27.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public ITD-on-itself field with declare @field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B28 {
	
	public int B28.a;
	declare @field : int B28.a : @anInterface;
	
	public static void main(String [] args){
		Class c = B28.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




// "public annotated ITD-on-itself field"

import java.lang.annotation.*;
import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)
@interface anInterface{}

aspect B29 {
	
	@anInterface
	public int B29.a;
	
	public static void main(String [] args){
		Class c = B29.class;
		try {
			Field m = c.getDeclaredField("a");
			Annotation [] anns = m.getDeclaredAnnotations();
			for (int i = 0;i < anns.length;i++){
				System.out.println(anns[i]);
			}
		} catch (Exception e){
			System.out.println("exceptional!");
		}
	}
}




package org.aspectj.systemtest.ajc150;

import java.io.File;

import junit.framework.Test;

import org.aspectj.testing.XMLBasedAjcTestCase;


/**
 *  Checking that runtime visible annotations are visible at runtime (they get into the class file)
 */
public class RuntimeAnnotations extends XMLBasedAjcTestCase {

	  public static Test suite() {
	    return XMLBasedAjcTestCase.loadSuite(RuntimeAnnotations.class);
	  }

	  protected File getSpecFile() {
	    return new File("../tests/src/org/aspectj/systemtest/ajc150/ajc150.xml");
	  }
  
  public void test01(){
    runTest("public method with declare @method");
  }
  
  public void test02(){
	    runTest("public method on the aspect that declares @method on it");
  }
  
  public void test03(){
	    runTest("public annotated method");
  }
  
  public void test04(){
	    runTest("public ITD method with declare @method");
}
  
  public void test05(){
	    runTest("public annotated ITD method");
}
  public void test06(){
	    runTest("public ITD-on-itself method with declare @method");
}
  public void test07(){
	    runTest("public annotated ITD-on-itself method");
}
  public void test08(){
	    runTest("public method on an Interface with declare @method");
}

  public void test09(){
	    runTest("public annotated method on an Interface");
}
  
  public void test10(){
	    runTest("public ITD method onto an Interface with declare @method");
}
  public void test11(){
	    runTest("public annotated ITD method onto an Interface");
}
  
  public void test12(){
	    runTest("public abstract method with declare @method");
}

  public void test13(){
	    runTest("public abstract method on the aspect that declares @method on it");
}
  
  public void test14(){
	    runTest("public abstract annotated method");
}
  
  public void test15(){
	    runTest("public abstract ITD method with declare @method");
}

  public void test16(){
	    runTest("public abstract annotated ITD method");
}
  
  public void test17(){
	    runTest("public abstract ITD-on-itself method with declare @method");
}
  public void test18(){
	    runTest("public abstract annotated ITD-on-itself method");
}
  public void test19(){
	    runTest("public abstract method on an Interface with declare @method");
}

  public void test20(){
	    runTest("public abstract annotated method on an Interface");
}
  public void test21(){
	    runTest("public abstract ITD method onto an Interface with declare @method");
}
  public void test22(){
	    runTest("public abstract annotated ITD method onto an Interface");
}
  public void test23(){
	    runTest("public field with declare @field");
}

  public void test24(){
	    runTest("public field on the aspect that declares @field on it");
}
  public void test25(){
	    runTest("public annotated field");
}
  public void test26(){
	    runTest("public ITD field with declare @field");
}

  public void test27(){
	    runTest("public annotated ITD field");
}
  public void test28(){
	    runTest("public ITD-on-itself field with declare @field");
}
  public void test29(){
	    runTest("public annotated ITD-on-itself field");
}

}

Return to bug 98901

Lines 2370-2373 Link Here

(-)src/org/aspectj/systemtest/ajc150/ajc150.xml (+262 lines)
2370	<!-- End of generics tests -->	2370	<!-- End of generics tests -->
2371	<!-- ============================================================== -->	2371	<!-- ============================================================== -->
2372		2372
		2373	<ajc-test dir="bugs150/pr98901" title="public method with declare @method">
		2374	<compile files="Case01.aj" options="-1.5 -Xlint:error"/>
		2375	<run class="B01">
		2376	<stdout>
		2377	<line text="@anInterface()"/>
		2378	</stdout>
		2379	</run>
		2380	</ajc-test>
		2381
		2382	<ajc-test dir="bugs150/pr98901" title="public method on the aspect that declares @method on it">
		2383	<compile files="Case02.aj" options="-1.5 -Xlint:error"/>
		2384	<run class="B02">
		2385	<stdout>
		2386	<line text="@anInterface()"/>
		2387	</stdout>
		2388	</run>
		2389	</ajc-test>
		2390
		2391	<ajc-test dir="bugs150/pr98901" title="public annotated method">
		2392	<compile files="Case03.aj" options="-1.5 -Xlint:error"/>
		2393	<run class="B03">
		2394	<stdout>
		2395	<line text="@anInterface()"/>
		2396	</stdout>
		2397	</run>
		2398	</ajc-test>
		2399
		2400	<ajc-test dir="bugs150/pr98901" title="public ITD method with declare @method">
		2401	<compile files="Case04.aj" options="-1.5 -Xlint:error"/>
		2402	<run class="B04">
		2403	<stdout>
		2404	<line text="@anInterface()"/>
		2405	</stdout>
		2406	</run>
		2407	</ajc-test>
		2408
		2409	<ajc-test dir="bugs150/pr98901" title="public annotated ITD method">
		2410	<compile files="Case05.aj" options="-1.5 -Xlint:error"/>
		2411	<run class="B05">
		2412	<stdout>
		2413	<line text="@anInterface()"/>
		2414	</stdout>
		2415	</run>
		2416	</ajc-test>
		2417
		2418	<ajc-test dir="bugs150/pr98901" title="public ITD-on-itself method with declare @method">
		2419	<compile files="Case06.aj" options="-1.5 -Xlint:error"/>
		2420	<run class="B06">
		2421	<stdout>
		2422	<line text="@anInterface()"/>
		2423	</stdout>
		2424	</run>
		2425	</ajc-test>
		2426
		2427	<ajc-test dir="bugs150/pr98901" title="public annotated ITD-on-itself method">
		2428	<compile files="Case07.aj" options="-1.5 -Xlint:error"/>
		2429	<run class="B07">
		2430	<stdout>
		2431	<line text="@anInterface()"/>
		2432	</stdout>
		2433	</run>
		2434	</ajc-test>
		2435
		2436	<ajc-test dir="bugs150/pr98901" title="public method on an Interface with declare @method">
2437	<compile files="Case08.aj" options="-1.5 -Xlint:error"/>
2438	<run class="B08">
2439	<stdout>
2440	<line text="@anInterface()"/>
2441	</stdout>
2442	</run>
2443	</ajc-test>
2444
2445	<ajc-test dir="bugs150/pr98901" title="public annotated method on an Interface">
2446	<compile files="Case09.aj" options="-1.5 -Xlint:error"/>
2447	<run class="B09">
2448	<stdout>
2449	<line text="@anInterface()"/>
2450	</stdout>
2451	</run>
2452	</ajc-test>
2453
2454	<ajc-test dir="bugs150/pr98901" title="public ITD method onto an Interface with declare @method">
2455	<compile files="Case10.aj" options="-1.5 -Xlint:error"/>
2456	<run class="B10">
2457	<stdout>
2458	<line text="@anInterface()"/>
2459	</stdout>
2460	</run>
2461	</ajc-test>
2462
2463	<ajc-test dir="bugs150/pr98901" title="public annotated ITD method onto an Interface">
2464	<compile files="Case11.aj" options="-1.5 -Xlint:error"/>
2465	<run class="B11">
2466	<stdout>
2467	<line text="@anInterface()"/>
2468	</stdout>
2469	</run>
2470	</ajc-test>
2471
2472	<ajc-test dir="bugs150/pr98901" title="public abstract method with declare @method">
2473	<compile files="Case12.aj" options="-1.5 -Xlint:error"/>
2474	<run class="B12">
2475	<stdout>
2476	<line text="@anInterface()"/>
2477	</stdout>
2478	</run>
2479	</ajc-test>
2480
2481	<ajc-test dir="bugs150/pr98901" title="public abstract method on the aspect that declares @method on it">
2482	<compile files="Case13.aj" options="-1.5 -Xlint:error"/>
2483	<run class="B13">
2484	<stdout>
2485	<line text="@anInterface()"/>
2486	</stdout>
2487	</run>
2488	</ajc-test>
2489
2490	<ajc-test dir="bugs150/pr98901" title="public abstract annotated method">
2491	<compile files="Case14.aj" options="-1.5 -Xlint:error"/>
2492	<run class="B14">
2493	<stdout>
2494	<line text="@anInterface()"/>
2495	</stdout>
2496	</run>
2497	</ajc-test>
2498
2499	<ajc-test dir="bugs150/pr98901" title="public abstract ITD method with declare @method">
2500	<compile files="Case15.aj" options="-1.5 -Xlint:error"/>
2501	<run class="B15">
2502	<stdout>
2503	<line text="@anInterface()"/>
2504	</stdout>
2505	</run>
2506	</ajc-test>
2507
2508	<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD method">
2509	<compile files="Case16.aj" options="-1.5 -Xlint:error"/>
2510	<run class="B16">
2511	<stdout>
2512	<line text="@anInterface()"/>
2513	</stdout>
2514	</run>
2515	</ajc-test>
2516
2517	<ajc-test dir="bugs150/pr98901" title="public abstract ITD-on-itself method with declare @method">
2518	<compile files="Case17.aj" options="-1.5 -Xlint:error"/>
2519	<run class="B17">
2520	<stdout>
2521	<line text="@anInterface()"/>
2522	</stdout>
2523	</run>
2524	</ajc-test>
2525
2526	<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD-on-itself method">
2527	<compile files="Case18.aj" options="-1.5 -Xlint:error"/>
2528	<run class="B18">
2529	<stdout>
2530	<line text="@anInterface()"/>
2531	</stdout>
2532	</run>
2533	</ajc-test>
2534
2535	<ajc-test dir="bugs150/pr98901" title="public abstract method on an Interface with declare @method">
2536	<compile files="Case19.aj" options="-1.5 -Xlint:error"/>
2537	<run class="B19">
2538	<stdout>
2539	<line text="@anInterface()"/>
2540	</stdout>
2541	</run>
2542	</ajc-test>
2543
2544	<ajc-test dir="bugs150/pr98901" title="public abstract annotated method on an Interface">
2545	<compile files="Case20.aj" options="-1.5 -Xlint:error"/>
2546	<run class="B20">
2547	<stdout>
2548	<line text="@anInterface()"/>
2549	</stdout>
2550	</run>
2551	</ajc-test>
2552
2553	<ajc-test dir="bugs150/pr98901" title="public abstract ITD method onto an Interface with declare @method">
2554	<compile files="Case21.aj" options="-1.5 -Xlint:error"/>
2555	<run class="B21">
2556	<stdout>
2557	<line text="@anInterface()"/>
2558	</stdout>
2559	</run>
2560	</ajc-test>
2561
2562	<ajc-test dir="bugs150/pr98901" title="public abstract annotated ITD method onto an Interface">
2563	<compile files="Case22.aj" options="-1.5 -Xlint:error"/>
2564	<run class="B22">
2565	<stdout>
2566	<line text="@anInterface()"/>
2567	</stdout>
2568	</run>
2569	</ajc-test>
2570
2571	<ajc-test dir="bugs150/pr98901" title="public field with declare @field">
2572	<compile files="Case23.aj" options="-1.5 -Xlint:error"/>
2573	<run class="B23">
2574	<stdout>
2575	<line text="@anInterface()"/>
2576	</stdout>
2577	</run>
2578	</ajc-test>
2579
2580
2581	<ajc-test dir="bugs150/pr98901" title="public field on the aspect that declares @field on it">
2582	<compile files="Case24.aj" options="-1.5 -Xlint:error"/>
2583	<run class="B24">
2584	<stdout>
2585	<line text="@anInterface()"/>
2586	</stdout>
2587	</run>
2588	</ajc-test>
2589
2590	<ajc-test dir="bugs150/pr98901" title="public annotated field">
2591	<compile files="Case25.aj" options="-1.5 -Xlint:error"/>
2592	<run class="B25">
2593	<stdout>
2594	<line text="@anInterface()"/>
2595	</stdout>
2596	</run>
2597	</ajc-test>
2598
2599	<ajc-test dir="bugs150/pr98901" title="public ITD field with declare @field">
2600	<compile files="Case26.aj" options="-1.5 -Xlint:error"/>
2601	<run class="B26">
2602	<stdout>
2603	<line text="@anInterface()"/>
2604	</stdout>
2605	</run>
2606	</ajc-test>
2607
2608	<ajc-test dir="bugs150/pr98901" title="public annotated ITD field">
2609	<compile files="Case27.aj" options="-1.5 -Xlint:error"/>
2610	<run class="B27">
2611	<stdout>
2612	<line text="@anInterface()"/>
2613	</stdout>
2614	</run>
2615	</ajc-test>
2616
2617	<ajc-test dir="bugs150/pr98901" title="public ITD-on-itself field with declare @field">
2618	<compile files="Case28.aj" options="-1.5 -Xlint:error"/>
2619	<run class="B28">
2620	<stdout>
2621	<line text="@anInterface()"/>
2622	</stdout>
2623	</run>
2624	</ajc-test>
2625
2626	<ajc-test dir="bugs150/pr98901" title="public annotated ITD-on-itself field">
2627	<compile files="Case29.aj" options="-1.5 -Xlint:error"/>
2628	<run class="B29">
2629	<stdout>
2630	<line text="@anInterface()"/>
2631	</stdout>
2632	</run>
2633	</ajc-test>
2634
2373	</suite>	2635	</suite>

Added Link Here

(-)bugs150/pr98901/Case01.aj (+28 lines)
1	// "public method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A01{
10	public void a(){}
11	}
12
13	aspect B01 {
14	declare @method : void A01.a(..) : @anInterface;
15
16	public static void main(String [] args){
17	Class c = A01.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case02.aj (+25 lines)
1	//"public method on the aspect that declares @method on it"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B02 {
10	public void a(){}
11	declare @method : void B02.a(..) : @anInterface;
12
13	public static void main(String [] args){
14	Class c = B02.class;
15	try {
16	Method m = c.getDeclaredMethod("a", new Class [0]);
17	Annotation [] anns = m.getDeclaredAnnotations();
18	for (int i = 0;i < anns.length;i++){
19	System.out.println(anns[i]);
20	}
21	} catch (Exception e){
22	System.out.println("exceptional!");
23	}
24	}
25	}

Added Link Here

(-)bugs150/pr98901/Case03.aj (+28 lines)
1	//"public annotated method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A03{
10	@anInterface
11	public void a(){}
12	}
13
14	aspect B03 {
15
16	public static void main(String [] args){
17	Class c = A03.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case04.aj (+29 lines)
1	// "public ITD method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A04{
10	}
11
12	aspect B04 {
13
14	public void A04.a(){}
15	declare @method : void A04.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A04.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case05.aj (+29 lines)
1	// "public annotated ITD method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A05{
10	}
11
12	aspect B05 {
13
14	@anInterface
15	public void A05.a(){}
16
17	public static void main(String [] args){
18	Class c = A05.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case06.aj (+26 lines)
1	// "public ITD-on-itself method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B06 {
10
11	public void B06.a(){}
12	declare @method : void B06.a(..) : @anInterface;
13
14	public static void main(String [] args){
15	Class c = B06.class;
16	try {
17	Method m = c.getDeclaredMethod("a", new Class [0]);
18	Annotation [] anns = m.getDeclaredAnnotations();
19	for (int i = 0;i < anns.length;i++){
20	System.out.println(anns[i]);
21	}
22	} catch (Exception e){
23	System.out.println("exceptional!");
24	}
25	}
26	}

Added Link Here

(-)bugs150/pr98901/Case07.aj (+26 lines)
1	//"public annotated ITD-on-itself method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B07 {
10
11	@anInterface
12	public void B07.a(){}
13
14	public static void main(String [] args){
15	Class c = B07.class;
16	try {
17	Method m = c.getDeclaredMethod("a", new Class [0]);
18	Annotation [] anns = m.getDeclaredAnnotations();
19	for (int i = 0;i < anns.length;i++){
20	System.out.println(anns[i]);
21	}
22	} catch (Exception e){
23	System.out.println("exceptional!");
24	}
25	}
26	}

Added Link Here

(-)bugs150/pr98901/Case08.aj (+29 lines)
1	// "public method on an Interface with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A08{
10	public void a();
11	}
12
13	aspect B08 {
14
15	declare @method : void A08.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A08.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case09.aj (+28 lines)
1	// "public annotated method on an Interface"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A09{
10	@anInterface
11	public void a();
12	}
13
14	aspect B09 {
15
16	public static void main(String [] args){
17	Class c = A09.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case10.aj (+29 lines)
1	// "public ITD method onto an Interface with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A10{
10	}
11
12	aspect B10 {
13
14	public void A10.a(){}
15	declare @method : void A10.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A10.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case11.aj (+29 lines)
1	//"public annotated ITD method onto an Interface"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A11{
10	}
11
12	aspect B11 {
13
14	@anInterface
15	public void A11.a(){}
16
17	public static void main(String [] args){
18	Class c = A11.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case12.aj (+29 lines)
1	// "public abstract method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract class A12{
10	public abstract void a();
11	}
12
13	aspect B12 {
14
15	declare @method : abstract void A12.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A12.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case13.aj (+28 lines)
1	// "public abstract method on the aspect that declares @method on it"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract aspect A13{
10	public abstract void a();
11	declare @method : abstract void A13.a(..) : @anInterface;
12	}
13
14	aspect B13 {
15
16	public static void main(String [] args){
17	Class c = A13.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case14.aj (+28 lines)
1	// "public abstract annotated method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract class A14{
10	@anInterface
11	public abstract void a();
12	}
13
14	aspect B14 {
15
16	public static void main(String [] args){
17	Class c = A14.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case15.aj (+29 lines)
1	// "public abstract ITD method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract class A15{
10	}
11
12	aspect B15 {
13
14	public abstract void A15.a();
15	declare @method : abstract void A15.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A15.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case16.aj (+29 lines)
1	// "public abstract annotated ITD method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract class A16{
10	}
11
12	aspect B16 {
13
14	@anInterface
15	public abstract void A16.a();
16
17	public static void main(String [] args){
18	Class c = A16.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case17.aj (+28 lines)
1	// "public abstract ITD-on-itself method with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract aspect A17 {
10	public abstract void A17.a();
11	declare @method : abstract void A17.a(..) : @anInterface;
12	}
13
14	aspect B17 {
15
16	public static void main(String [] args){
17	Class c = A17.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case18.aj (+28 lines)
1	// "public abstract annotated ITD-on-itself method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	abstract aspect A18 {
10	@anInterface
11	public abstract void A18.a();
12	}
13
14	aspect B18 {
15
16	public static void main(String [] args){
17	Class c = A18.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case19.aj (+29 lines)
1	//"public abstract method on an Interface with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A19 {
10	public abstract void a();
11	}
12
13	aspect B19 {
14
15	declare @method : abstract void A19.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A19.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case20.aj (+28 lines)
1	// "public abstract annotated method on an Interface"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A20 {
10	@anInterface
11	public abstract void a();
12	}
13
14	aspect B20 {
15
16	public static void main(String [] args){
17	Class c = A20.class;
18	try {
19	Method m = c.getDeclaredMethod("a", new Class [0]);
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case21.aj (+29 lines)
1	// "public abstract ITD method onto an Interface with declare @method"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A21 {
10	}
11
12	aspect B21 {
13
14	public abstract void A21.a();
15	declare @method : abstract void A21.a(..) : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A21.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case22.aj (+29 lines)
1	// "public abstract annotated ITD method onto an Interface"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Method;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	interface A22 {
10	}
11
12	aspect B22 {
13
14	@anInterface
15	public abstract void A22.a();
16
17	public static void main(String [] args){
18	Class c = A22.class;
19	try {
20	Method m = c.getDeclaredMethod("a", new Class [0]);
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case23.aj (+29 lines)
1	// "public field with declare @field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A23 {
10	public int a;
11	}
12
13	aspect B23 {
14
15	declare @field : int A23.a : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A23.class;
19	try {
20	Field m = c.getDeclaredField("a");
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case24.aj (+26 lines)
1	// "public field on the aspect that declares @field on it"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B24 {
10
11	public int a;
12	declare @field : int B24.a : @anInterface;
13
14	public static void main(String [] args){
15	Class c = B24.class;
16	try {
17	Field m = c.getDeclaredField("a");
18	Annotation [] anns = m.getDeclaredAnnotations();
19	for (int i = 0;i < anns.length;i++){
20	System.out.println(anns[i]);
21	}
22	} catch (Exception e){
23	System.out.println("exceptional!");
24	}
25	}
26	}

Added Link Here

(-)bugs150/pr98901/Case25.aj (+28 lines)
1	// "public annotated field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A25{
10	@anInterface
11	public int a;
12	}
13
14	aspect B25 {
15
16	public static void main(String [] args){
17	Class c = A25.class;
18	try {
19	Field m = c.getDeclaredField("a");
20	Annotation [] anns = m.getDeclaredAnnotations();
21	for (int i = 0;i < anns.length;i++){
22	System.out.println(anns[i]);
23	}
24	} catch (Exception e){
25	System.out.println("exceptional!");
26	}
27	}
28	}

Added Link Here

(-)bugs150/pr98901/Case26.aj (+29 lines)
1	// "public ITD field with declare @field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A26{
10	}
11
12	aspect B26 {
13
14	public int A26.a;
15	declare @field : int A26.a : @anInterface;
16
17	public static void main(String [] args){
18	Class c = A26.class;
19	try {
20	Field m = c.getDeclaredField("a");
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case27.aj (+29 lines)
1	// "public annotated ITD field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	class A27{
10	}
11
12	aspect B27 {
13
14	@anInterface
15	public int A27.a;
16
17	public static void main(String [] args){
18	Class c = A27.class;
19	try {
20	Field m = c.getDeclaredField("a");
21	Annotation [] anns = m.getDeclaredAnnotations();
22	for (int i = 0;i < anns.length;i++){
23	System.out.println(anns[i]);
24	}
25	} catch (Exception e){
26	System.out.println("exceptional!");
27	}
28	}
29	}

Added Link Here

(-)bugs150/pr98901/Case28.aj (+26 lines)
1	// "public ITD-on-itself field with declare @field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B28 {
10
11	public int B28.a;
12	declare @field : int B28.a : @anInterface;
13
14	public static void main(String [] args){
15	Class c = B28.class;
16	try {
17	Field m = c.getDeclaredField("a");
18	Annotation [] anns = m.getDeclaredAnnotations();
19	for (int i = 0;i < anns.length;i++){
20	System.out.println(anns[i]);
21	}
22	} catch (Exception e){
23	System.out.println("exceptional!");
24	}
25	}
26	}

Added Link Here

(-)bugs150/pr98901/Case29.aj (+26 lines)
1	// "public annotated ITD-on-itself field"
2
3	import java.lang.annotation.*;
4	import java.lang.reflect.Field;
5
6	@Retention(RetentionPolicy.RUNTIME)
7	@interface anInterface{}
8
9	aspect B29 {
10
11	@anInterface
12	public int B29.a;
13
14	public static void main(String [] args){
15	Class c = B29.class;
16	try {
17	Field m = c.getDeclaredField("a");
18	Annotation [] anns = m.getDeclaredAnnotations();
19	for (int i = 0;i < anns.length;i++){
20	System.out.println(anns[i]);
21	}
22	} catch (Exception e){
23	System.out.println("exceptional!");
24	}
25	}
26	}