Testing Refactorings

[dormaayan]

List of steps for test refactoring:

1. Convert simple non fluent Junit to simple assertions (TODO: add list)
2. Convert harmcrest to arithmetical expressions
3. Consolidate consequtive assertions
4. Consolidate methods with common setup and different tests
5. Remove verification of non-exception
6. Use expected exception instead of try \ catch
7. Split independent tests
8. Sane paramatrization of tests

[yossigil]

import java.math.BigInteger;
import java.util.*;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.IntFunction;
import java.util.function.BiConsumer;

interface Selfie<Self extends Selfie<Self>> {
}

class OO<_1, _2> {
	_1 _1;
	_2 _2;

	public OO(_1 _1, _2 _2) {
		this._1 = _1;
		this._2 = _2;
	}
}

class OI<_1> {
	_1 _1;
	int _2;

	public OI(_1 _1, int _2) {
		this._1 = _1;
		this._2 = _2;
	}
}

class OOs<_1, _2> extends ArrayList<OO<_1, _2>> implements Selfie<OOs<_1, _2>> {
	private static final long serialVersionUID = 1L;
	private List<BiConsumer<_1, _2>> tests = new ArrayList<>();

	public OOs(BiConsumer<_1, _2> f) {
		tests.add(f);

	}

	OOs<_1, _2> against(_1 _1, _2 _2) {
		add(new OO<>(_1, _2));
		return this;
	}

	OOs<_1, _2> and(_1 _1, _2 _2) {
		return against(_1, _2);
	}

	public OOs<_1, _2> go() {
		return this;
	}

	public OOs<_1, _2> to(BiConsumer<A, B> f) {
		return this;
	}
}

class OIs<_1, _2> extends ArrayList<OI<_1>> {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	OIs<_1, _2> $(_1 _1, int _2) {
		add(new OI<>(_1, _2));
		return this;
	}

	public OIs<_1, _2> to(BiConsumer<A, B> f, BiConsumer<A, B>... fs) {
		// TODO Auto-generated method stub
		return this;
	}
}

class A {
}

class B {
}

class Main {
	public static void testFib(Integer n, BigInteger b) {
		assert fib(n).equals(b);
	}

	public static BigInteger fib(Integer n) {
		if (n == null)
			return BigInteger.ZERO;
		return fib1(n.intValue());
	}

	public static BigInteger sqrt(Integer n) {
		if (n == null)
			return BigInteger.ZERO;
		return fib1(n.intValue());
	}

	public static BigInteger fib1(int n) {
		if (n <= 1)
			return BigInteger.ZERO;
		else
			return fib1(n - 1).add(fib1(n - 2));
	}

	static int inc(int a) {
		return a + 1;
	}

	public static void main(String[] args) {
		Tuples.to(Main::testFib).against(12, BigInteger.ZERO).and(3, BigInteger.valueOf(3))
				.and(4, BigInteger.valueOf(4)).go();
		Tuples.to(Main::inc).of(0, 1).of(1, 2).of(1, 2);
	}

	static void f(A a, B b) {
	}

	static void g(A a, B b) {
	};

	static B h(A a) {
		return null;
	};
}

class Tuples {
	static <A, B> OOs<A, B> to(BiConsumer<A, B> f) {
		return new OOs<A, B>(f);
	}

	static <A> Os<A> to2(Consumer<A> f) {
		return new Os<A>();
	}

	static IIs to(IntFunction f) {
		return new IIs(f);
	}

}

class IIs {

	private IntFunction f;

	public IIs(IntFunction f) {
		this.f = f;
	}

	public IIs of(int a, int b) {
		return this;
	}

}

class Os<O> {
}

class MapTest {
	static {
		Tuples.to2(MapTest::MapTest);
	}

	private Map<String, String> map;

	MapTest(Map<String, String> map) {
		this.map = map;
	}
}
`