Why is this test for my quick sort failing?

Question

I'm trying to implement quicksort using the median of three algo and it fails a unit test I wrote related to a small partition. I changed my earlier partition and now it passes one of the tests it used to fail, but still fails the one at the bottom:

My code is:

public class QuickSort {

    static void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }

static final int LIMIT = 15;

static int partition(int[] a, int left, int right){
    int center = (left + right) / 2;
    if(a[center] < (a[left]))
        swap(a,left,center);
    if(a[right-1] < a[left])
        swap(a,left,right);
    if(a[right-1] < a[center])
        swap(a,center,right);

    swap(a,center,right - 1);
    return a[right - 1];
}


static void quicksort(int[] a, int left, int right){
    if(left + LIMIT <= right){
        int pivot = partition(a,left,right);

        int i = left;
        int j = right - 1;

        for(;;){
            while(a[++i] < pivot){}
            while(a[--j] > pivot){}
            if(i < j)
                swap(a,i,j);
            else
                break;
        }
        swap(a,i,right - 1);
        quicksort(a,left,i-1);
        quicksort(a,i+1,right);
    }
    else{
        insertionSort(a);
    }
}

public static void insertionSort(int[] a){
    int j;

    for(int p = 1; p < a.length; p++){
        int tmp = a[p];
        for(j = p; j > 0 && tmp < a[j-1]; j--)
            a[j] = a[j-1];
        a[j] = tmp;
    }
}

}

This test fails:

  public void smalltest() throws Exception {
    int[] Arr_orig = {3,9,8,2,4,6,7,5};
    int[] Arr = Arr_orig.clone();
    int pivot = QuickSort.partition(Arr, 0, Arr.length);
    for (int i = 0; i != pivot; ++i) 
        assertTrue(Arr[i] <= Arr[pivot]); //fails!
    for (int i = pivot + 1; i != Arr.length; ++i)
        assertTrue(Arr[pivot] < Arr[i]);
}

Answer 1

There is a conflict between using right-1 and right in this sequence:

    if(a[right-1] < a[left])
        swap(a,left,right);

You need to decide if right is going to be the index to the last element, or 1 + index to the last element (an "ending" index).

There may be other problems, but this is the first one I noticed.