Added missing GetPriorityClass(), SetPriorityClass(), GetThreadPriori…

…ty() and SetThreadPriority() methods to Kernel32 class.

Added test cases for Kernel32.SetPriorityClass(), Kernel32.GetPriorityClass(), Kernel32.GetThreadPriority() and Kernel32.SetThreadPriority().

Also added some useful helper methods to Kernel32Util class, including tests.

contrib/platform/src/com/sun/jna/platform/win32/Kernel32.java

@@ -68,6 +68,40 @@ public interface Kernel32 extends StdCallLibrary, WinNT, Wincon {
      */
     int LOAD_LIBRARY_AS_DATAFILE = 0x2;
 
+    /**
+     * Process priority classes
+     */
+    DWORD NORMAL_PRIORITY_CLASS         = new DWORD(0x00000020L);
+    DWORD IDLE_PRIORITY_CLASS           = new DWORD(0x00000040L);
+    DWORD HIGH_PRIORITY_CLASS           = new DWORD(0x00000080L);
+    DWORD REALTIME_PRIORITY_CLASS       = new DWORD(0x00000100L);
+    DWORD BELOW_NORMAL_PRIORITY_CLASS   = new DWORD(0x00004000L);
+    DWORD ABOVE_NORMAL_PRIORITY_CLASS   = new DWORD(0x00008000L);
+    DWORD PROCESS_MODE_BACKGROUND_BEGIN = new DWORD(0x00100000L);
+    DWORD PROCESS_MODE_BACKGROUND_END   = new DWORD(0x00200000L);
+
+    /**
+     * Thread priorities
+     */
+    int THREAD_PRIORITY_IDLE          = -15;
+    int THREAD_PRIORITY_LOWEST        =  -2;
+    int THREAD_PRIORITY_BELOW_NORMAL  =  -1;
+    int THREAD_PRIORITY_NORMAL        =   0;
+    int THREAD_PRIORITY_ABOVE_NORMAL  =   1;
+    int THREAD_PRIORITY_HIGHEST       =   2;
+    int THREAD_PRIORITY_TIME_CRITICAL =  15;
+
+    /**
+     * Thread mode flags
+     */
+    int THREAD_MODE_BACKGROUND_BEGIN = 0x10000;
+    int THREAD_MODE_BACKGROUND_END   = 0x20000;
+
+    /**
+     * Thread priority error code
+     */
+    int THREAD_PRIORITY_ERROR_RETURN = 0x7FFFFFFF;
+
     /**
      * Reads data from the specified file or input/output (I/O) device. Reads
      * occur at the position specified by the file pointer if supported by the
@@ -4152,6 +4186,45 @@ Pointer VirtualAllocEx(HANDLE hProcess, Pointer lpAddress, SIZE_T dwSize,
      */
     boolean GetExitCodeThread(HANDLE hThread, IntByReference exitCode);
 
+    /**
+     * Gets the priority class of the specified process.
+     * 
+     * @param hProcess A handle to the process.
+     * @return If the function succeeds, the return value is the priority class of
+     *                  the specified process.
+     * <p>If the function fails, the return value is zero.</p>
+     */
+    DWORD GetPriorityClass(HANDLE hProcess);
+
+    /**
+     * Sets the priority class for the specified process.
+     * 
+     * @param hProcess A handle to the process.
+     * @param dwPriorityClass The priority class for the process.
+     * @return If the function succeeds, the return value is nonzero.
+     */
+    boolean SetPriorityClass(HANDLE hProcess, DWORD dwPriorityClass);
+
+    /**
+     * Gets the priority value of the specified thread.
+     * 
+     * @param hProcess A handle to the process.
+     * @return If the function succeeds, the return value is the priority class of
+     *                  the specified thread.
+     * <p>If the function fails, the return value is
+     *                  THREAD_PRIORITY_ERROR_RETURN.</p>
+     */
+    int GetThreadPriority(HANDLE hProcess);
+
+    /**
+     * Sets the priority value for the specified thread.
+     * 
+     * @param hThread A handle to the thread whose priority value is to be set.
+     * @param nPriority The priority value for the thread. 
+     * @return If the function succeeds, the return value is nonzero.
+     */
+    boolean SetThreadPriority(HANDLE hThread, int nPriority);
+
     /**
      * Releases, decommits, or releases and decommits a region of memory within
      * the virtual address space of a specified process.

contrib/platform/src/com/sun/jna/platform/win32/Kernel32Util.java

@@ -1258,6 +1258,160 @@ public static String expandEnvironmentStrings(String input) {
         }
     }
 
+    /**
+     * Gets the priority class of the current process.
+     * 
+     * @return The priority class of the current process.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static DWORD getCurrentProcessPriority() {
+        final DWORD dwPriorityClass = Kernel32.INSTANCE.GetPriorityClass(Kernel32.INSTANCE.GetCurrentProcess());
+        if (dwPriorityClass.longValue() == 0L) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+        return dwPriorityClass;
+    }
+
+    /**
+     * Sets the priority class for the current process.
+     * 
+     * @param dwPriorityClass The priority class for the process.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static void setCurrentProcessPriority(final DWORD dwPriorityClass) {
+        if (!Kernel32.INSTANCE.SetPriorityClass(Kernel32.INSTANCE.GetCurrentProcess(), dwPriorityClass)) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+    }
+
+    /**
+     * Gets the priority value of the current thread.
+     * 
+     * @return The priority value of the current thread.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static int getCurrentThreadPriority() {
+        final int nPriority = Kernel32.INSTANCE.GetThreadPriority(Kernel32.INSTANCE.GetCurrentThread());
+        if (nPriority == THREAD_PRIORITY_ERROR_RETURN) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+        return nPriority;
+    }
+
+    /**
+     * Sets the priority value for the current thread.
+     * 
+     * @param nPriority The priority value for the thread.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static void setCurrentThreadPriority(final int nPriority) {
+        if (!Kernel32.INSTANCE.SetThreadPriority(Kernel32.INSTANCE.GetCurrentThread(), nPriority)) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+    }
+
+    /**
+     * Gets the priority class of the specified process.
+     * 
+     * @param pid Identifier for the running process.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static DWORD getProcessPriority(final int pid) {
+        final HANDLE hProcess = Kernel32.INSTANCE.OpenProcess(WinNT.PROCESS_QUERY_INFORMATION , false, pid);
+        if (hProcess == null) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+
+        Win32Exception we = null;
+        try {
+            final DWORD dwPriorityClass = Kernel32.INSTANCE.GetPriorityClass(hProcess);
+            if (dwPriorityClass.longValue() == 0L) {
+                throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+            }
+            return dwPriorityClass;
+        } catch (final Win32Exception e) {
+            we = e;
+        } finally {
+            cleanUp(hProcess, we);
+        }
+    }
+
+    /**
+     * Sets the priority class for the specified process.
+     * 
+     * @param pid Identifier for the running process.
+     * @param dwPriorityClass The priority class for the process.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static void setProcessPriority(final int pid, final DWORD dwPriorityClass) {
+        final HANDLE hProcess = Kernel32.INSTANCE.OpenProcess(WinNT.PROCESS_SET_INFORMATION, false, pid);
+        if (hProcess == null) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+
+        Win32Exception we = null;
+        try {
+            if (!Kernel32.INSTANCE.SetPriorityClass(hProcess, dwPriorityClass)) {
+                throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+            }    
+        } catch (final Win32Exception e) {
+            we = e;
+        } finally {
+            cleanUp(hProcess, we);
+        }
+    }
+
+    /**
+     * Gets the priority value of the specified thread.
+     * 
+     * @param tid Identifier for the running thread.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static int getThreadPriority(final int tid) {
+        final HANDLE hThread = Kernel32.INSTANCE.OpenThread(WinNT.THREAD_QUERY_INFORMATION, false, tid);
+        if (hThread == null) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+
+        Win32Exception we = null;
+        try {
+            final int nPriority = Kernel32.INSTANCE.GetThreadPriority(hThread);
+            if (nPriority == Kernel32.THREAD_PRIORITY_ERROR_RETURN) {
+                throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+            }
+            return nPriority;
+        } catch (final Win32Exception e) {
+            we = e;
+        } finally {
+            cleanUp(hThread, we);
+        }
+    }
+
+    /**
+     * Sets the priority value for the specified thread.
+     * 
+     * @param tid Identifier for the running thread.
+     * @param nPriority The priority value for the thread.
+     * @throws Win32Exception if an error occurs.
+     */
+    public static void setThreadPriority(final int tid, final int nPriority) {
+        final HANDLE hThread = Kernel32.INSTANCE.OpenThread(WinNT.THREAD_SET_INFORMATION, false, tid);
+        if (hThread == null) {
+            throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+        }
+
+        Win32Exception we = null;
+        try {
+            if (!Kernel32.INSTANCE.SetThreadPriority(hThread, nPriority)) {
+                throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
+            }    
+        } catch (final Win32Exception e) {
+            we = e;
+        } finally {
+            cleanUp(hThread, we);
+        }
+    }
+
     private static void cleanUp(final HANDLE h, Win32Exception we) {
         try {
             closeHandle(h);

contrib/platform/test/com/sun/jna/platform/win32/Kernel32Test.java

@@ -2099,4 +2099,24 @@ public void testVirtualLockUnlock() {
         // Unlocking an unlocked region should fail
         assertFalse(Kernel32.INSTANCE.VirtualUnlock(mem, new SIZE_T(4096)));
     }
+
+    public void testGetPriorityClass() {
+        final HANDLE selfHandle = Kernel32.INSTANCE.GetCurrentProcess();
+        assertFalse(Kernel32.INSTANCE.GetPriorityClass(selfHandle).longValue() == 0L);
+    }
+
+    public void testSetPriorityClass() {
+        final HANDLE selfHandle = Kernel32.INSTANCE.GetCurrentProcess();
+        assertTrue(Kernel32.INSTANCE.SetPriorityClass(selfHandle, Kernel32.HIGH_PRIORITY_CLASS));
+    }
+
+    public void testGetThreadPriority() {
+        final HANDLE selfHandle = Kernel32.INSTANCE.GetCurrentProcess();
+        assertFalse(Kernel32.INSTANCE.GetThreadPriority(selfHandle) == Kernel32.THREAD_PRIORITY_ERROR_RETURN);
+    }
+
+    public void testSetThreadPriority() {
+        final HANDLE selfHandle = Kernel32.INSTANCE.GetCurrentThread();
+        assertTrue(Kernel32.INSTANCE.SetThreadPriority(selfHandle, Kernel32.THREAD_PRIORITY_ABOVE_NORMAL));
+    }
 }

contrib/platform/test/com/sun/jna/platform/win32/Kernel32UtilTest.java

@@ -513,4 +513,40 @@ public void testGetLogicalProcessorInformationEx() {
             assertTrue(cache.associativity == WinNT.CACHE_FULLY_ASSOCIATIVE || cache.associativity > 0);
         }
     }
+
+    public void testGetCurrentProcessPriority() {
+        Kernel32Util.getCurrentProcessPriority();
+    }
+
+    public void testSetCurrentProcessPriority() {
+        Kernel32Util.setCurrentProcessPriority(Kernel32.HIGH_PRIORITY_CLASS);
+    }
+
+    public void testGetCurrentThreadPriority() {
+        Kernel32Util.getCurrentThreadPriority();
+    }
+
+    public void testSetCurrentThreadPriority() {
+        Kernel32Util.setCurrentThreadPriority(Kernel32.THREAD_PRIORITY_ABOVE_NORMAL);
+    }
+
+    public void testGetProcessPriority() {
+        final int pid = Kernel32.INSTANCE.GetCurrentProcessId();
+        Kernel32Util.getProcessPriority(pid);
+    }
+
+    public void testSetProcessPriority() {
+        final int pid = Kernel32.INSTANCE.GetCurrentProcessId();
+        Kernel32Util.setProcessPriority(pid, Kernel32.HIGH_PRIORITY_CLASS);
+    }
+
+    public void testGetThreadPriority() {
+        final int tid = Kernel32.INSTANCE.GetCurrentThreadId();
+        Kernel32Util.getThreadPriority(tid);
+    }
+
+    public void testSetThreadPriority() {
+        final int tid = Kernel32.INSTANCE.GetCurrentThreadId();
+        Kernel32Util.setThreadPriority(tid, Kernel32.THREAD_PRIORITY_ABOVE_NORMAL);
+    }
 }