PermutationTest.java

import java.util.LinkedList;
import java.util.Arrays;

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class PermutationTest {
	PermutationVariation p1;
	PermutationVariation p2;
	public int n1;
	public int n2;
	int cases=1;

	void initialize() {
		n1=4;
		n2=6;
		Cases c= new Cases();
		p1= c.switchforTesting(cases, n1);
		p2= c.switchforTesting(cases, n2);
	}


	@Test
	void testPermutation() {
		initialize();
		// TODO

		//fuer beide?? und was machen wenn sie nicht korrekt sind? exeption?

		//erste permutetion constructor testen

		//laenge korrekt?
		if (n1 != p1.original.length)
			throw new RuntimeException("Die Laenge der ersten Permutation ist nicht korrekt");

		// wie oft eine zahl vorkommt - machen erstmal wie in count sort - dafuer erstmal maximum finden
		int max1 = -100;
		for (int i = 0; i<n1; i++){
			if (p1.original[i] > max1) max1 = p1.original[i];
		}
		int[] count_array = new int[max1];
		for (int j = 0; j<n1; j++){
			int pos = p1.original[j];
			count_array[pos]++;
			if(count_array[pos] > 1) throw new RuntimeException("Die Zahlen der Permutation 1 kommen mindestens doppelt vor");
		}

		//ob die allDerangements mit einer leeren Liste initialisiert ist
		if(!p1.allDerangements.isEmpty())
			throw new RuntimeException("allDerangements der ersten Permutation nicht mit der leeren Liste initialisiert");

		//fuer die zweite analog??
	}

	@Test
	void testDerangements() {
		initialize();
		//in case there is something wrong with the constructor
		fixConstructor();
		// TODO

		//erste Permutation
		// dass die Anzahl der erzeugten Derangements korrekt ist

		// die Eigenschaft der Fixpunktfreiheit erfüllt <-> jeder zahl am anderen Platz als davor
		for (int[] derangement : p1.allDerangements){ //fuer jede Permutation
			//pruefen, ob keine Zahl an ihrem vorherigen platz steht
			for (int i = 0; i < n1; i++){
				if (derangement[i] == p1.original[i])
					throw new RuntimeException("allDeragements enthaelt mindestens eine nicht fixpunktfreie Permutation");
			}
		}

	}

	@Test
	void testsameElements() {
		initialize();
		//in case there is something wrong with the constructor
		fixConstructor();
		// TODO

		//  ob alle von der derangments()-Methode erzeugten Folgen tatsächlich Permutationen sind
		for (int[] derangement : p1.allDerangements){
			//pruefen erstmal, ob die laengen uebereinstimmen
			if(derangement.length != n1)
				throw new RuntimeException("allDeragements enthaelt Folge(n) unterschiedlicher Laenge als p1.original");
			//schauen, ob jedes element von p1.original im derangement drin ist

			//wollen die methode contains benutzen, also brauchen ein LinkedList derangement
			LinkedList<Integer> derangement_list = new LinkedList<Integer>(); //initialisieren, mit elementen befuellen
			for (int elem : derangement){
				derangement_list.add(elem);
			}
			//nun koennen wir contains anwenden, um zu ueberpruefen dass alle elemente p1.original da auch vorhanden
			for(int elem : p1.original){
				if (!derangement_list.contains(elem)) //wenn irgendein element nicht gefunden
					throw new RuntimeException("allDeragements enthaelt Folge(n) die gar keine Permutation(en) ist/sind");
			}
		}
	}

	void setCases(int c) {
		this.cases=c;
	}

	public void fixConstructor() {
		//in case there is something wrong with the constructor
		p1.allDerangements=new LinkedList<int[]>();
		for(int i=0;i<n1;i++)
			p1.original[i]=2*i+1;

		p2.allDerangements=new LinkedList<int[]>();
		for(int i=0;i<n2;i++)
			p2.original[i]=i+1;
	}
}