Add more test cases for GptInit() and fixed some bugs

src/platform/vboot_reference/cgptlib/quick_sort.c

+/* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "quick_sort.h"
+#include <stdint.h>
+#include "utility.h"
+
+/* Make sure we won't overflow the buffer. */
+#define SAFE_SIZE(size) \
+    ((size > MAX_QUICK_SORT_ELEMENT_SIZE) ? MAX_QUICK_SORT_ELEMENT_SIZE : size)
+
+/* Swap a and b. Since the type of 'a' and 'b' are unknown, caller must indicate
+ * 'size' bytes. */
+void Swap(void *a, void *b, int size) {
+  static uint8_t buffer[MAX_QUICK_SORT_ELEMENT_SIZE];
+  Memcpy(buffer, a, SAFE_SIZE(size));
+  Memcpy(a, b, SAFE_SIZE(size));
+  Memcpy(b, buffer, SAFE_SIZE(size));
+}
+
+/* Given a pivot and left/right boundary, this function returns a new pivot,
+ * and ensure the elements in the left-side of pivot are preceding elements,
+ * and elements in the right-side of pivot are following elements. */
+static int
+Partition(int (*compare_function)(const void *a, const void *b),
+          void *vp_elements, int size, int left, int right, int pivot) {
+  uint8_t *elements = vp_elements;
+  int i;
+
+  Swap(&elements[right * size], &elements[pivot * size], size);
+  for (i = left; i < right; ++i) {
+    if (compare_function(&elements[i * size], &elements[right * size])) {
+      Swap(&elements[left * size], &elements[i * size], size);
+      ++left;
+    }
+  }
+  Swap(&elements[left * size], &elements[right * size], size);
+  return left;
+}
+
+/* Given left and right boundary, this function returns a sorted elements in
+ * that range. */
+static void
+RecursiveQuickSort(void *elements, int left, int right, int size,
+                   int (*compare_function)(const void *a, const void *b)) {
+  int pivot;
+
+  if (right <= left) return;
+  pivot = (left + right) / 2;
+  pivot = Partition(compare_function, elements, size, left, right, pivot);
+  RecursiveQuickSort(elements, left, pivot - 1, size, compare_function);
+  RecursiveQuickSort(elements, pivot + 1, right, size, compare_function);
+}
+
+void QuickSort(void *elements, int number_of_elements, int size,
+               int (*compare_function)(const void *a, const void *b)) {
+  RecursiveQuickSort(elements, 0, number_of_elements - 1, size, compare_function);
+}