/*
    * Copyright 2007-2008 Naoki NOSE.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package jp.liq.container.util;
  
  import static java.lang.reflect.Modifier.*;
  import static org.junit.Assert.*;
  import static jp.liq.container.ContainerVocabulary.*;
  
  import java.util.HashSet;
  import java.util.Set;
  
  import jp.liq.container.reflect.ConstructorWrapper;
  import jp.liq.container.reflect.FieldWrapper;
  import jp.liq.container.reflect.ReflectException;
  import jp.liq.container.reflect.MethodWrapper;
  
  import org.junit.Test;
  
  /**
   * @author nosen
   *
   */
  public class IntrospectorTest {
  
      @Test
      public void getConstructor() throws Exception {
          ConstructorWrapper<?> cw = ctor.of(Ctor1.class);
          Object obj = cw.createObject(new Object[]{});
          assertTrue(obj instanceof Ctor1);
      }
  
      public static class Ctor1 {
          
      }
  
      @Test
      public void getConstructorWithArgs() throws Exception {
          ConstructorWrapper<Ctor2> cw = ctor.of(Ctor2.class, String.class);
          Ctor2 obj = cw.createObject(new Object[]{"hoge"});
          assertEquals("hoge", obj.arg1);
      }
  
  
      public static class Ctor2 {
          String arg1;
          public Ctor2(String arg1) {
              this.arg1 = arg1;
          }
      }
  
      @Test
      public void ctorInvocationErrorException() throws Exception {
          ConstructorWrapper<?> cw = ctor.of(Ctor3.class);
          try {
              cw.createObject(new Object[]{});
              fail();
          } catch (RuntimeException e) {
          }
  
      }
  
      public static class Ctor3 {
          public Ctor3() {
              throw new RuntimeException("ctor3");
          }
      }
  
      public class Method1 {
          public void m1(){}
          public void m2(){}
          public void m3(){}
      }
  
      @Test
      public void findAllMethods() {
          Set<String> s = new HashSet<String>();
          s.add("m1");
          s.add("m2");
          s.add("m3");
          for(MethodWrapper m : methods.of(Method1.class)){
              s.remove(m.name());
          }
          assertEquals(0, s.size());
      }
  
      public static void method1() {
     }
 
     public static void method2() {
     }
 
     @Ann1
     public void method3() {
     }
     
     @Ann1
     public void method4() {
     }
 
     public void p1Foo() {
     }
 
     public void p1Bar() {
     }
 
     @Ann2
     public void p2Foo() {
     }
 
     @Ann2
     public void p2Bar() {
         
     }
 
     public void p2FooBar() {
         
     }
 
     @Test
     public void findMethodsByModifier() throws Exception{
         int cnt = 0;
         Set<String> s = new HashSet<String>();
         s.add("method1");
         s.add("method2");
         for(MethodWrapper m : methods.of(this.getClass()).withModifier(STATIC)){
             cnt++;
             assertTrue(s.contains(m.name()));
         }
         
         assertEquals(s.size(), cnt);
     }
 
     @Test
     public void findMethodsByAnnotation() throws Exception{
         int cnt = 0;
         Set<String> s = new HashSet<String>();
         s.add("method3");
         s.add("method4");
         for(MethodWrapper m : methods.of(this.getClass()).withAnnotation(Ann1.class)){
             cnt++;
             assertTrue(s.contains(m.name()));
         }
 
         assertEquals(s.size(), cnt);
     }
     
     @Test
     public void findMethodsByPrefix() throws Exception{
         int cnt = 0;
         Set<String> s = new HashSet<String>();
         s.add("p1Foo");
         s.add("p1Bar");
         for(MethodWrapper m : methods.of(this.getClass()).withPrefix("p1")){
             cnt++;
             assertTrue(s.contains(m.name()));
         }
 
         assertEquals(s.size(), cnt);
     }
 
     @Test
     public void findMethodsByAnnotationAndPrefix() throws Exception{
         int cnt = 0;
         Set<String> s = new HashSet<String>();
         s.add("p2Foo");
         s.add("p2Bar");
         for(MethodWrapper m : methods.of(this.getClass()).withPrefix("p2").withAnnotation(Ann2.class)){
             cnt++;
             assertTrue(s.contains(m.name()));
         }
 
         assertEquals(s.size(), cnt);
     }
 
     @Test
     public void methodInvocationError() {
         for(MethodWrapper m : methods.of(this.getClass()).withPrefix("throw")) {
             try {
                 m.invoke(this, new Object[]{});
                 fail();
             } catch (ReflectException e) {
             }
         }
     }
 
     public void throwException() {
         throw new RuntimeException();
     }
 
     public class Fields {
         public String f1;
         @Ann1
         public String f2;
         @Ann1
         public String f3;
     }
 
     @Test
     public void findFieldsByModifier() {
         int cnt = 0;
 
         Set<String> s = new HashSet<String>();
         s.add("f2");
         s.add("f3");
 
         for(FieldWrapper f : fields.of(Fields.class).withAnnotation(Ann1.class)){
             cnt++;
             assertTrue(s.contains(f.name()));
         }
 
         assertEquals(s.size(), cnt);
     }
 
     
 }