package org.junit.tests.running.methods;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.Collections;
import java.util.List;

import junit.framework.JUnit4TestAdapter;
import junit.framework.TestResult;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.InitializationError;

public class TestMethodTest {

	@SuppressWarnings("all")  
	public static class EverythingWrong {
		private EverythingWrong() {}
		@BeforeClass public void notStaticBC() {}
		@BeforeClass static void notPublicBC() {}
		@BeforeClass public static int nonVoidBC() { return 0; }
		@BeforeClass public static void argumentsBC(int i) {}
		@BeforeClass public static void fineBC() {}
		@AfterClass public void notStaticAC() {}
		@AfterClass static void notPublicAC() {}
		@AfterClass public static int nonVoidAC() { return 0; }
		@AfterClass public static void argumentsAC(int i) {}
		@AfterClass public static void fineAC() {}
		@After public static void staticA() {}
		@After void notPublicA() {}
		@After public int nonVoidA() { return 0; }
		@After public void argumentsA(int i) {}
		@After public void fineA() {}
		@Before public static void staticB() {}
		@Before void notPublicB() {}
		@Before public int nonVoidB() { return 0; }
		@Before public void argumentsB(int i) {}
		@Before public void fineB() {}
		@Test public static void staticT() {}
		@Test void notPublicT() {}
		@Test public int nonVoidT() { return 0; }
		@Test public void argumentsT(int i) {}
		@Test public void fineT() {}
	}
	
	@Test public void testFailures() throws Exception {
		List<Throwable> problems= validateAllMethods(EverythingWrong.class);
		int errorCount= 1 + 4 * 5; // missing constructor plus four invalid methods for each annotation */
		assertEquals(errorCount, problems.size());
	}

	static public class SuperWrong {
		@Test void notPublic() {
		}
	}

	static public class SubWrong extends SuperWrong {
		@Test public void justFine() {
		}
	}

	@Test public void validateInheritedMethods() throws Exception {
		List<Throwable> problems= validateAllMethods(SubWrong.class);
		assertEquals(1, problems.size());
	}

	static public class SubShadows extends SuperWrong {
		@Override
		@Test public void notPublic() {
		}
	}

	@Test public void dontValidateShadowedMethods() throws Exception {
		List<Throwable> problems= validateAllMethods(SubShadows.class);
		assertTrue(problems.isEmpty());
	}

	private List<Throwable> validateAllMethods(Class<?> clazz) {
		try {
			new BlockJUnit4ClassRunner(clazz);
		} catch (InitializationError e) {
			return e.getCauses();
		}
		return Collections.emptyList();
	}

	static public class IgnoredTest {
		@Test public void valid() {}
		@Ignore @Test public void ignored() {}
		@Ignore("For testing purposes") @Test public void withReason() {}
	}

	@Test public void ignoreRunner() {
		JUnitCore runner= new JUnitCore();
		Result result= runner.run(IgnoredTest.class);
		assertEquals(2, result.getIgnoreCount());
		assertEquals(1, result.getRunCount());
	}

	@Test public void compatibility() {
		TestResult result= new TestResult();
		new JUnit4TestAdapter(IgnoredTest.class).run(result);
		assertEquals(1, result.runCount());
	}
	
	public static class Confused {
		@Test public void a(Object b) {
		}
		
		@Test public void a() {
		}
	}
	
	@Test(expected=InitializationError.class) public void overloaded() throws InitializationError {
		new BlockJUnit4ClassRunner(Confused.class);
	}
	
	public static class ConstructorParameter {
		public ConstructorParameter(Object something) {
		}
		
		@Test public void a() {
		}
	}
	
	@Test(expected=InitializationError.class) public void constructorParameter() throws InitializationError {
		new BlockJUnit4ClassRunner(ConstructorParameter.class);
	}
	
	public static class OnlyTestIsIgnored {
		@Ignore @Test public void ignored() {}
	}
	
	@Test public void onlyIgnoredMethodsIsStillFineTestClass() {
		Result result= JUnitCore.runClasses(OnlyTestIsIgnored.class);
		assertEquals(0, result.getFailureCount());
		assertEquals(1, result.getIgnoreCount());
	}
}