@Override
	public void checkForMutations()
	{
		// Convenience variables.
		ReplicatableCollection<ReplicatableInteger> replicateCollection = (replicationResult.getReplicate());
		Collection<ReplicatableInteger> original = collection.getSubcomponents();
		Collection<ReplicatableInteger> replicate = replicateCollection.getSubcomponents();
		
		// Look for addition and/or replacement mutations.
		if (original.size() == replicate.size() - 1)
		{
			incrementMutationCount(MutationType.ADDITION);
			
			// Ensure that we saw the appropriate number of addition mutations.
			assertThatMutationWasSeenOnce(MutationType.ADDITION);
			
			// Also look for replacement mutations by checking to see if all of the original subcomponents are in the replicate.
			// If this is the case then there were no replacements.
			// We can't generalize this because an addition may have also occurred.
			if (!replicate.containsAll(original))
			{
				incrementMutationCount(MutationType.REPLACEMENT);
				
				// Ensure that we saw the appropriate number of replacement mutations.
				assertThatMutationWasSeenOnce(MutationType.REPLACEMENT);
			}
		}
		// Look for deletion and/or replacement mutations.
		if (original.size() == replicate.size() + 1)
		{
			incrementMutationCount(MutationType.DELETION);
			
			// Ensure that we saw the appropriate number of deletion mutations.
			assertThatMutationWasSeenOnce(MutationType.DELETION);
			
			// Also look for replacement mutations by checking to see if all of the replicate subcomponents are in the original.
			// If this is the case then there were no replacements.
			// We can't generalize this because an addition may have also occurred.
			if (!original.containsAll(replicate))
			{
				incrementMutationCount(MutationType.REPLACEMENT);
				
				// Ensure that we saw the appropriate number of replacement mutations.
				assertThatMutationWasSeenOnce(MutationType.REPLACEMENT);
			}
		}
		// Look for replacements when the original is the same size as the replicate.
		if (replicate.size() == original.size() && !original.containsAll(replicate))
		{
			incrementMutationCount(MutationType.REPLACEMENT);
			
			// Ensure that we saw the appropriate number of replacement mutations.
			assertThatMutationWasSeenOnce(MutationType.REPLACEMENT);
		}
		// Check for any differences in mutation rates. If we see a difference, that means the mutation rate changed.
		for (MutationType type : MutationType.values())
		{
			if (collection.getMutationProbabilitySet().getProbability(type) != replicateCollection.getMutationProbabilitySet().getProbability(type))
			{
				incrementMutationCount(MutationType.MUTATION_RATE_CHANGE);
				break;
			}
		}
		
		// If the collections are grossly different then some unexpected mutation has occurred.
		if (Math.abs(original.size() - replicate.size()) > 1)
		{
			fail("Original subcomponent collection and replicate are greatly different. Original size: " + original.size() +"; replicate size: " + replicate.size());
		}
	}