package reflectiontest.bean;

public class TestUser {
  private String name;
  private int age;
  public  String gender;

  // Getter and Setter
}

@Test
public void get_class_field() {
Field[] fields = TestUser.class.getFields();
System.out.println("Output of getFields...");
for (Field f : fields) {
    System.out.println(f);
}
System.out.println("\n");

Field[] declareFields = TestUser.class.getDeclaredFields();
System.out.println("Output of getDeclaredFields...");
for (Field f : declareFields) {
    System.out.println(f);
}
}

// Output of getFields...
// public java.lang.String reflectiontest.bean.TestUser.gender


// Output of getDeclaredFields...
// private java.lang.String reflectiontest.bean.TestUser.name
// private int reflectiontest.bean.TestUser.age
// public java.lang.String reflectiontest.bean.TestUser.gender

@DataProvider(name = "singleParam")
public Object[][] singleParam() {
    return new Object[][]{
            {"Jerry"},
            {"Tom"},
    };
}

@Test(dataProvider = "singleParam")
public void single_data(String username) {
    System.out.println("Get username: " + username);
}

@org.testng.annotations.DataProvider(name = "$DATA_PROVIDER_NAME$")
public Object[][] $METHOD_NAME$() {
    return new Object[][]{
            {$OBJECT$}
    };
}

@DataProvider(name = "multiParam")
public Object[][] multiParam() {
    return new Object[][]{
            {"Jerry", 12},
            {"Tom", 11},
    };
}

@Test(dataProvider = "multiParam")
public void single_data(String username, int age) {
    System.out.println("Get username: " + username + ", age: " + age);
}

public class ClientIPUtils {
  private static String token = null;

  static {
    token = someService.getToken();
  }
}

@BeforeClass
public static void before() {
  new MockUp<VaultUtil>() {
    @Mock
    void $clinit() {
    }
  };
}

@Test
public void test1() {
  new Expectations() {
    {
      someService.getToken();
      result = "fake";
    }
  };
}

@Test
public void test2() {
  new Expectations() {
    {
      someService.getToken();
      result = "fake";
    }
  };
}

class Teacher{
  public String name = "unnamed";

  public Teacher(String name) {
    this.name = name;
  }
}

@Mocked Teacher teacher;
@Test
public void test() { System.out.println(teacher.name); } //output: null

@Test
public void test02 () { System.out.println(new Teacher("Jack").name); } //output: null

@Test
public void test(@Mocked Teacher teacher) { System.out.println(teacher.name); } // null

@Test
public void test02 () { System.out.println(new Teacher("Jack").name); } // Jack

public class CompatibleTest {
  @Test
  public void test(@Mocked UserBean userBean) {}
}

//output:
// org.testng.internal.reflect.MethodMatcherException:
// Data provider mismatch
// Method: test([Parameter{index=0, type=com.objects.UserBean, declaredAnnotations=[@mockit.Mocked(stubOutClassInitialization=false)]}])
// Arguments: []

public class CompatibleTest {
  @Mocked UserBean userBean;
  
  @Test
  public void test() {}
}

// 测试对象
class Dog{
  private String name;

  public Dog(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }
}

public class CompatibleTest {
  @Tested Dog dog;
  @Injectable String name;
  
  @Test
  public void test() { dog.getName(); }
}

// 如果没加的话抛出异常
// java.lang.IllegalArgumentException: No constructor in tested class that can be satisfied by available injectables
//   public com.successfactors.legacy.service.provisioning.impl.Dog(String)
//     disregarded because no injectable was found for parameter "name"

/**
* new object + mockup, new object 发生在 mock 之后，所以 mock 生效
*/
@Test
public void mock_factory_using_mockup() {
    new MockUp<NPCFactory>() {
        @Mock
        public Person getNPC() {
            return new Person("mock", 1);
        }
    };

    ClassRoom classRoom = new ClassRoom();
    assertEquals("mock", classRoom.getNPCName());
}

public class ClassRoom {
    private Person npc = NPCFactory.getNPC();
    public String getNPCName() { return npc.getName(); }
}

/**
* new object + expectations, new object 发生在 mock 之后，所以 mock 生效
*/
@Test
public void mock_factory_using_deencapsulation(@Mocked final Person person) {
    new Expectations() {{
        person.getName();
        result = "deenMock";
    }};

    Deencapsulation.setField(room, "npc", person);
    assertEquals("deenMock", room.getNPCName());
}

/**
* new object + expectations, new object 发生在 mock 之后，所以 mock 生效
*/
@Test
public void mock_factory_using_expectations() {
new Expectations(NPCFactory.class) {{
    NPCFactory.getNPC();
    result = new Person("expMock", 2);
}};

ClassRoom classRoom = new ClassRoom();
assertEquals("expMock", classRoom.getNPCName());
}

@Tested Person person;

@Test
public void person_name_jack() {
    new Expectations(person) {{
        person.getName();
        result = "jack";
    }};

    assertEquals("jack", person.getName());
    assertEquals(0, person.getAge());
}

// Tested Class
public class MySubscriber {

  private static final Logger LOGGER = LogManager.getLogger(MySubscriber.class);

  @Override
  public void onEvent(Event event) {
    if (LOGGER.isInfoEnabled()) {
      LOGGER.info("Start Process MySubscriber...");
      LOGGER.info("End...");
    }
  }
}

// In UT
@Capturing
private Logger logger;

@Test
public void test_capturing_anno() {
  new Expectations(ReadAuditSwitchHelper.class) {{
    logger.isInfoEnabled();
    result = true;
  }};

  subscriber.onEvent(context, event);

  new Verifications() {{
    logger.isInfoEnabled(); times=1;
    List<String> capturedInfos = new ArrayList<>();
    logger.info(withCapture(capturedInfos));

    capturedInfos.stream().forEach(System.out::println);
  }};
}

// 如果是单个参数
new Verifications() {{
  double d;
  String s;
  mock.doSomething(d = withCapture(), null, s = withCapture());

  assertTrue(d > 0.0);
  assertTrue(s.length() > 1);
}};

// 如果是多个参数
new Verifications() {{
  List<DataObject> dataObjects = new ArrayList<>();
  mock.doSomething(withCapture(dataObjects));

  assertEquals(2, dataObjects.size());
  DataObject data1 = dataObjects.get(0);
  DataObject data2 = dataObjects.get(1);
  // Perform arbitrary assertions on data1 and data2.
}};

public class MyBean {
    private MyField field = new MyField();

    // getter/setter

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyBean myBean = (MyBean) o;
        return Objects.equals(field, myBean.field);
    }

    @Override
    public int hashCode() {
        return Objects.hash(field);
    }
}

public class MyField {
    private String name;

    // getter/setter

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyField myField = (MyField) o;
        return Objects.equals(name, myField.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

public class TestMockedAnno01 {
  // @Mocked MyField field;

  @Test
  public void test() {
    MyBean bean1 = new MyBean();
    MyBean bean2 = new MyBean();

    Assert.assertEquals(bean1, bean2);

  }
}