Index: core/src/org/netbeans/core/NbErrorManager.java
===================================================================
RCS file: /cvs/core/src/org/netbeans/core/NbErrorManager.java,v
retrieving revision 1.49.2.1
diff -u -r1.49.2.1 NbErrorManager.java
--- core/src/org/netbeans/core/NbErrorManager.java	11 Mar 2003 21:16:20 -0000	1.49.2.1
+++ core/src/org/netbeans/core/NbErrorManager.java	9 Apr 2003 15:38:27 -0000
@@ -530,11 +530,19 @@
 
         /** @return message */
         String getMessage () {
+            String m = t.getMessage();
+            if (m != null) {
+                return m;
+            }
             return (String)find (1);
         }
 
         /** @return localized message */
         String getLocalizedMessage () {
+            String m = t.getLocalizedMessage();
+            if (m != null && !m.equals(t.getMessage())) {
+                return m;
+            }
             if (arrAll == null) {
                 // arrAll not filled --> use the old non recursive variant
                 return (String)find(2);
@@ -545,16 +553,25 @@
                     return s;
                 }
             }
-            return t.getLocalizedMessage();
+            return m;
         }
 	
         boolean isLocalized() {
-	    if (find(2, false) == null) {
-		String locMsg = getLocalizedMessage();
-		return locMsg != null && !locMsg.equals(getMessage());
-	    } 
-	    else
-		return true;	
+            String m = t.getLocalizedMessage();
+            if (m != null && !m.equals(t.getMessage())) {
+                return true;
+            }
+            if (arrAll == null) {
+                // arrAll not filled --> use the old non recursive variant
+                return (String)find(2) != null;
+            }
+            for (int i = 0; i < arrAll.length; i++) {
+                String s = arrAll[i].getLocalizedMessage ();
+                if (s != null) {
+                    return true;
+                }
+            }
+            return false;
 	}
 
         /** @return class name of the exception */
@@ -568,8 +585,9 @@
                 return severity;
             }
 
-            for (int i = 0; i < arr.length; i++) {
-                int s = arr[i].getSeverity ();
+            Annotation[] anns = (arrAll != null) ? arrAll : arr;
+            for (int i = 0; i < anns.length; i++) {
+                int s = anns[i].getSeverity ();
                 if (s > severity) {
                     severity = s;
                 }
Index: core/test/unit/src/org/netbeans/core/NbErrorManagerTest.java
===================================================================
RCS file: /cvs/core/test/unit/src/org/netbeans/core/NbErrorManagerTest.java,v
retrieving revision 1.2
diff -u -r1.2 NbErrorManagerTest.java
--- core/test/unit/src/org/netbeans/core/NbErrorManagerTest.java	27 Feb 2003 22:09:56 -0000	1.2
+++ core/test/unit/src/org/netbeans/core/NbErrorManagerTest.java	9 Apr 2003 15:38:27 -0000
@@ -191,4 +191,70 @@
         // could do more here...
     }
     
+    /**
+     * Check that UNKNOWN works.
+     * @see "#30947"
+     */
+    public void testUnknownSeverity() throws Exception {
+        
+        // Simple exception is EXCEPTION.
+        Throwable t = new IOException("unloc msg");
+        NbErrorManager.Exc x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.EXCEPTION, x.getSeverity());
+        assertEquals("unloc msg", x.getMessage());
+        assertEquals("unloc msg", x.getLocalizedMessage());
+        assertTrue(!x.isLocalized());
+        
+        // Same when there is unloc debug info attached.
+        t = new IOException("unloc msg");
+        err.annotate(t, ErrorManager.UNKNOWN, "some debug info", null, null, null);
+        x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.EXCEPTION, x.getSeverity());
+        assertEquals("unloc msg", x.getMessage());
+        assertEquals("unloc msg", x.getLocalizedMessage());
+        assertTrue(!x.isLocalized());
+        
+        // Nested exceptions don't necessarily change anything severity-wise.
+        t = new IOException("unloc msg");
+        Throwable t2 = new IOException("unloc msg #2");
+        err.annotate(t, ErrorManager.UNKNOWN, null, null, t2, null);
+        x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.EXCEPTION, x.getSeverity());
+        assertEquals("unloc msg", x.getMessage());
+        assertEquals("unloc msg", x.getLocalizedMessage());
+        assertTrue(!x.isLocalized());
+        
+        // But annotations at a particular severity level (usually localized) do
+        // set the severity for the exception.
+        t = new IOException("unloc msg");
+        err.annotate(t, ErrorManager.USER, null, "loc msg", null, null);
+        x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.USER, x.getSeverity());
+        assertEquals("unloc msg", x.getMessage());
+        assertEquals("loc msg", x.getLocalizedMessage());
+        assertTrue(x.isLocalized());
+        
+        // And that works even if you are just rethrowing someone else's exception.
+        t = new IOException("unloc msg");
+        t2 = new IOException("unloc msg #2");
+        err.annotate(t2, ErrorManager.USER, null, "loc msg", null, null);
+        err.annotate(t, ErrorManager.UNKNOWN, null, null, t2, null);
+        x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.USER, x.getSeverity());
+        assertEquals("unloc msg", x.getMessage());
+        assertEquals("loc msg", x.getLocalizedMessage());
+        assertTrue(x.isLocalized());
+        // Almost the same test to mimic #31254:
+        t2 = new IOException("loc msg");
+        err.annotate(t2, ErrorManager.USER, null, "loc msg", null, null);
+        t = new IOException("loc msg");
+        err.annotate(t, ErrorManager.USER, null, null, t2, null);
+        x = err.createExc(t, ErrorManager.UNKNOWN);
+        assertEquals(ErrorManager.USER, x.getSeverity());
+        assertEquals("loc msg", x.getMessage());
+        assertEquals("loc msg", x.getLocalizedMessage());
+        assertTrue(x.isLocalized());
+        
+    }
+    
 }