private void useTestData(int timeBetweenTraces){
		/*
		 * First part are performance tests for runtime-efficiency
		 */
		
		// different setups for time evaluation 
		// this was for explicit packetnumber, hops and time
//		int[] traceNumbers = new int[]{100,1000,5000,10000,20000};
//		int[] hops = new int[]{2,10,20};
//		int[] seconds = new int[]{30,600,7200};
		
		// this setup was for explicit packetnumber and hops, but seconds is packets per second
		int[] traceNumbers = new int[]{1000,5000,10000,15000,20000,25000,30000};
		int[] hops = new int[]{2};
		int[] seconds = new int[]{100,250,500};
		
		//do some runs to warm up the JIT-compiler
		for(int l = 0; l < 50 ; l++){
			TestDataCreator creator = new TestDataCreator();
			creator.createTimeTraces(666, 7, 666);
			packets = creator.getPackets();
			Collections.sort(packets);
			nodes = creator.getNodes();
			//Get and Sort all packets to traces by double-linking between packets, nodes and traces
			TraceAnalyzer analyzer = new TraceAnalyzer(timeBetweenTraces);	
			Date before = new Date();
			traces = analyzer.setUpTraces(packets, nodes);
			//... and after analyze check the runtime
			Date after = new Date();
			after.compareTo(before);
			int differenceInMS = (int)(after.getTime() - before.getTime()); 
			System.out.println("Iteration "+l+" takes: "+differenceInMS+" ms to calculate.");
		}
		
		//start the runs for time evaluation
		for(int i = 0; i < traceNumbers.length; i++){
			for(int j = 0; j < hops.length; j++){
				for (int k = 0; k < seconds.length; k++){
					//10 runs for the average
					int averageTime = 0;
					for(int l = 0; l < 10 ; l++){
						System.gc();
						TestDataCreator creator = new TestDataCreator();
//						creator.createTimeTraces(traceNumbers[i], hops[j], seconds[k]); //to test packets over explicit time
						creator.createTimeTraces(traceNumbers[i], hops[j], traceNumbers[i]/seconds[k]); //to test packets per second
						packets = creator.getPackets();
						Collections.sort(packets);
						nodes = creator.getNodes();
						//Get and Sort all packets to traces by double-linking between packets, nodes and traces
						TraceAnalyzer analyzer = new TraceAnalyzer(timeBetweenTraces);	
						Date before = new Date();
						traces = analyzer.setUpTraces(packets, nodes);
						//... and after analyze
						Date after = new Date();
						after.compareTo(before);
						int differenceInMS = (int)(after.getTime() - before.getTime()); 
						System.out.println("Iteration "+l+" with "+traceNumbers[i]+" traces, "+hops[j]+" hops in "+seconds[k]+" seconds takes: "+differenceInMS+" ms to calculate.");
						averageTime += differenceInMS;
					}
					//get average:
//					System.out.println("Average of 10 iterations with "+traceNumbers[i]+" traces, "+hops[j]+" hops in "+seconds[k]+" seconds is: "+averageTime/10);
					System.out.println("Average of 10 iterations with "+traceNumbers[i]+" traces, "+hops[j]+" hops in "+traceNumbers[i]/seconds[k]+" seconds is: "+averageTime/10);
					System.out.println("\n");
				}
			}
		}
		
		/*
		 * Second part are functionality tests to check correct tracking behaviour
		 */
		
		/*
		//test-parameters to create traces in explicit time interval
		int[] seconds = new int[]{1,10,30,60};
		int[] traceNumbers = new int[]{12,100,500,1000,4000};
		
		for(int i = 0; i < seconds.length; i++){
			for(int j = 0; j < traceNumbers.length; j++){
				//get all the needed testData
				TestDataCreator creator = new TestDataCreator();
				//create packets with different information
				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesFull(seconds[i], traceNumbers[j]);
//				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesFullFrag(seconds[i], traceNumbers[j]);
//				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesFlow(seconds[i], traceNumbers[j]);
//				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesStartEnd(seconds[i], traceNumbers[j]);
//				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesStartEndFrag(seconds[i], traceNumbers[j]);
//				ArrayList<MultihopPacketTrace> compareTraces = creator.createGoodTracesNothing(seconds[i], traceNumbers[j]);
				packets = creator.getPackets();
				
				nodes = creator.getNodes();
				Collections.sort(packets);
				
				//Get and Sort all packets to traces by double-linking between packets, nodes and traces
				TraceAnalyzer analyzer = new TraceAnalyzer(timeBetweenTraces);	
				traces = analyzer.setUpTraces(packets, nodes);
				
				//Short Statuscheck
				System.out.println("\n//////////////////////////////////////////");
				System.out.println("Systemstatus after complete object creation: ");
				System.out.println("Number of Nodes: " + nodes.size());
				System.out.println("Number of Packets: " + packets.size());
				System.out.println("Number of Traces: " + traces.size());	
				System.out.println("//////////////////////////////////////////");
				
				// check correctness of the results
				// comparing all packets of the traces for a match
				for(MultihopPacketTrace t : traces){
					MultihopPacketTrace matchingCompareTrace = null;
					for(MultihopPacketTrace ct: compareTraces){
						boolean traceMatching = true;
						if(t.getPacketList().size() == ct.getPacketList().size()){
							for(MACPacket p : t.getPacketList()){
								boolean packetMatchFound = false;
								for(MACPacket cp : ct.getPacketList()){
									//match to packet found ? good, continue with next packet
									if(cp.equals(p)){
										packetMatchFound = true;
										break;
									} //else ... continue search for a matching packet
								}
								//no match to a packet found ? search next trace, this trace is no match
								if(!packetMatchFound){	
									traceMatching = false;
									break;
								} //else ... see if all other packets also match
							}
						}
						else{
							traceMatching = false;
						}
						//all packets matched ?
						if(traceMatching == true){
							matchingCompareTrace = ct;
							break;
						} // else ... continue search for a matching trace
					}
					//if a compareTrace was found, remove it from list
					if(matchingCompareTrace != null){
						compareTraces.remove(matchingCompareTrace);
					} // else ... no matching trace was found, the analyzer did bad here
				}
				
				//Every trace left in compareTraces is an undetected trace
				System.out.println("Traces were sent in time interval of "+ seconds[i]+ " seconds.");
				System.out.println(traceNumbers[j]-compareTraces.size() + " of "+ traceNumbers[j] +" traces were correctly found.");
			}
		} /**/
	}