Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 859 insertions, 0 deletions

diff --git a/src/libs/xpcom18a4/nsprpub/pr/tests/lltest.c b/src/libs/xpcom18a4/nsprpub/pr/tests/lltest.c
new file mode 100644
index 00000000..f8ce4c6a
--- /dev/null
+++ b/src/libs/xpcom18a4/nsprpub/pr/tests/lltest.c
@@ -0,0 +1,859 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape Portable Runtime (NSPR).
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+ 
+/*
+** testll.c -- test suite for 64bit integer (longlong) operations
+**
+** Summary: testll [-d] | [-h]
+**
+** Where:
+** -d       set debug mode on; displays individual test failures
+** -v       verbose mode; displays progress in test, plus -d
+** -h       gives usage message.
+**
+** Description:
+** lltest.c tests the functions defined in NSPR 2.0's prlong.h.
+** 
+** Successive tests begin to depend on other LL functions working
+** correctly. So, ... Do not change the order of the tests as run
+** from main().
+** 
+** Caveats:
+** Do not even begin to think that this is an exhaustive test!
+**
+** These tests try a little of everything, but not all boundary
+** conditions and limits are tested.
+** You want better coverage? ... Add it.
+**
+** ---
+** Author: Lawrence Hardiman <larryh@netscape.com>.
+** ---
+** Revision History:
+** 01-Oct-1997. Original implementation.
+**
+*/
+
+#include "nspr.h"
+#include "plgetopt.h"
+
+/* --- Local Definitions --- */
+#define ReportProgress(m) if (verboseMode) PR_fprintf(output, (m));
+
+
+/* --- Global variables --- */
+static PRIntn  failedAlready = 0;
+static PRFileDesc* output = NULL;
+static PRBool  debugMode = PR_FALSE;
+static PRBool  verboseMode = PR_FALSE;
+
+/*
+** Constants used in tests.
+*/
+const PRInt64 bigZero        = LL_INIT( 0, 0 );
+const PRInt64 bigOne         = LL_INIT( 0, 1 );
+const PRInt64 bigTwo         = LL_INIT( 0, 2 );
+const PRInt64 bigSixTeen     = LL_INIT( 0, 16 );        
+const PRInt64 bigThirtyTwo   = LL_INIT( 0, 32 );        
+const PRInt64 bigMinusOne    = LL_INIT( 0xffffffff, 0xffffffff );
+const PRInt64 bigMinusTwo    = LL_INIT( 0xffffffff, 0xfffffffe );
+const PRInt64 bigNumber      = LL_INIT( 0x7fffffff, 0xffffffff );
+const PRInt64 bigMinusNumber = LL_INIT( 0x80000000, 0x00000001 );
+const PRInt64 bigMaxInt32    = LL_INIT( 0x00000000, 0x7fffffff );
+const PRInt64 big2To31       = LL_INIT( 0x00000000, 0x80000000 );
+const PRUint64 bigZeroFox    = LL_INIT( 0x00000000, 0xffffffff );
+const PRUint64 bigFoxFox     = LL_INIT( 0xffffffff, 0xffffffff );
+const PRUint64 bigFoxZero    = LL_INIT( 0xffffffff, 0x00000000 );
+const PRUint64 bigEightZero  = LL_INIT( 0x80000000, 0x00000000 );
+const PRUint64 big64K        = LL_INIT( 0x00000000, 0x00010000 );
+const PRInt64 bigInt0        = LL_INIT( 0x01a00000, 0x00001000 );
+const PRInt64 bigInt1        = LL_INIT( 0x01a00000, 0x00001100 );
+const PRInt64 bigInt2        = LL_INIT( 0x01a00000, 0x00000100 );
+const PRInt64 bigInt3        = LL_INIT( 0x01a00001, 0x00001000 );
+const PRInt64 bigInt4        = LL_INIT( 0x01a00001, 0x00001100 );
+const PRInt64 bigInt5        = LL_INIT( 0x01a00001, 0x00000100 );
+const PRInt64 bigInt6        = LL_INIT( 0xb1a00000, 0x00001000 );
+const PRInt64 bigInt7        = LL_INIT( 0xb1a00000, 0x00001100 );
+const PRInt64 bigInt8        = LL_INIT( 0xb1a00000, 0x00000100 );
+const PRInt64 bigInt9        = LL_INIT( 0xb1a00001, 0x00001000 );
+const PRInt64 bigInt10       = LL_INIT( 0xb1a00001, 0x00001100 );
+const PRInt64 bigInt11       = LL_INIT( 0xb1a00001, 0x00000100 );
+const PRInt32 one = 1l;
+const PRInt32 minusOne = -1l;
+const PRInt32 sixteen  = 16l;
+const PRInt32 thirtyTwo = 32l;
+const PRInt32   sixtyThree = 63l;
+
+/*
+** SetFailed() -- Report individual test failure
+**
+*/
+static void
+SetFailed( char *what, char *how )
+{
+    failedAlready = 1;
+    if ( debugMode )
+        PR_fprintf(output, "%s: failed: %s\n", what, how );
+    return;
+}
+
+static void
+ResultFailed( char *what, char *how, PRInt64 expected, PRInt64 got)
+{
+    if ( debugMode)
+    {
+        SetFailed( what, how );
+        PR_fprintf(output, "Expected: 0x%llx   Got: 0x%llx\n", expected, got );
+    }
+    return;
+}    
+
+
+/*
+** TestAssignment() -- Test the assignment
+*/
+static void TestAssignment( void )
+{
+    PRInt64 zero = LL_Zero();
+    PRInt64 min = LL_MinInt();
+    PRInt64 max = LL_MaxInt();
+    if (!LL_EQ(zero, bigZero))
+        SetFailed("LL_EQ(zero, bigZero)", "!=");
+    if (!LL_CMP(max, >, min))
+        SetFailed("LL_CMP(max, >, min)", "!>");
+}
+
+/*
+** TestComparisons() -- Test the longlong comparison operations
+*/
+static void    
+TestComparisons( void )
+{
+    ReportProgress("Testing Comparisons Operations\n");
+         
+    /* test for zero */   
+    if ( !LL_IS_ZERO( bigZero ))
+        SetFailed( "LL_IS_ZERO", "Zero is not zero" );
+        
+    if ( LL_IS_ZERO( bigOne ))
+        SetFailed( "LL_IS_ZERO", "One tests as zero" );
+    
+    if ( LL_IS_ZERO( bigMinusOne ))
+        SetFailed( "LL_IS_ZERO", "Minus One tests as zero" );
+        
+    /* test equal */
+    if ( !LL_EQ( bigZero, bigZero ))
+        SetFailed( "LL_EQ", "zero EQ zero");
+        
+    if ( !LL_EQ( bigOne, bigOne ))
+        SetFailed( "LL_EQ", "one EQ one" );
+        
+    if ( !LL_EQ( bigNumber, bigNumber ))
+        SetFailed( "LL_EQ", "bigNumber EQ bigNumber" );
+        
+    if ( !LL_EQ( bigMinusOne, bigMinusOne ))
+        SetFailed( "LL_EQ", "minus one EQ minus one");
+    
+    if ( LL_EQ( bigZero, bigOne ))
+        SetFailed( "LL_EQ", "zero EQ one");
+        
+    if ( LL_EQ( bigOne, bigZero ))
+        SetFailed( "LL_EQ", "one EQ zero" );
+        
+    if ( LL_EQ( bigMinusOne, bigOne ))
+        SetFailed( "LL_EQ", "minus one EQ one");
+        
+    if ( LL_EQ( bigNumber, bigOne ))
+        SetFailed( "LL_EQ", "bigNumber EQ one");
+    
+    /* test not equal */
+    if ( LL_NE( bigZero, bigZero ))
+        SetFailed( "LL_NE", "0 NE 0");
+    
+    if ( LL_NE( bigOne, bigOne ))
+        SetFailed( "LL_NE", "1 NE 1");
+    
+    if ( LL_NE( bigMinusOne, bigMinusOne ))
+        SetFailed( "LL_NE", "-1 NE -1");
+    
+    if ( LL_NE( bigNumber, bigNumber ))
+        SetFailed( "LL_NE", "n NE n");
+    
+    if ( LL_NE( bigMinusNumber, bigMinusNumber ))
+        SetFailed( "LL_NE", "-n NE -n");
+        
+    if ( !LL_NE( bigZero, bigOne))
+        SetFailed( "LL_NE", "0 NE 1");
+    
+    if ( !LL_NE( bigOne, bigMinusNumber))
+        SetFailed( "LL_NE", "1 NE -n");
+        
+    /* Greater than or equal to zero */
+    if ( !LL_GE_ZERO( bigZero ))
+        SetFailed( "LL_GE_ZERO", "0");
+    
+    if ( !LL_GE_ZERO( bigOne ))
+        SetFailed( "LL_GE_ZERO", "1");
+    
+    if ( !LL_GE_ZERO( bigNumber ))
+        SetFailed( "LL_GE_ZERO", "n");
+    
+    if ( LL_GE_ZERO( bigMinusOne ))
+        SetFailed( "LL_GE_ZERO", "-1");
+        
+    if ( LL_GE_ZERO( bigMinusNumber ))
+        SetFailed( "LL_GE_ZERO", "-n");
+        
+    /* Algebraic Compare two values */
+    if ( !LL_CMP( bigZero, ==, bigZero ))
+        SetFailed( "LL_CMP", "0 == 0");
+    
+    if ( LL_CMP( bigZero, >, bigZero ))
+        SetFailed( "LL_CMP", "0 > 0");
+        
+    if ( LL_CMP( bigZero, <, bigZero ))
+        SetFailed( "LL_CMP", "0 < 0");
+        
+    if ( LL_CMP( bigNumber, <, bigOne ))
+        SetFailed( "LL_CMP", "n < 1");
+        
+    if ( !LL_CMP( bigNumber, >, bigOne ))
+        SetFailed( "LL_CMP", "n <= 1");
+        
+    if ( LL_CMP( bigOne, >, bigNumber ))
+        SetFailed( "LL_CMP", "1 > n");
+        
+    if ( LL_CMP( bigMinusNumber, >, bigNumber ))
+        SetFailed( "LL_CMP", "-n > n");
+        
+    if ( LL_CMP( bigNumber, !=, bigNumber))
+        SetFailed( "LL_CMP", "n != n");
+
+    if ( !LL_CMP( bigMinusOne, >, bigMinusTwo ))
+        SetFailed( "LL_CMP", "-1 <= -2");
+
+    if ( !LL_CMP( bigMaxInt32, <, big2To31 ))
+        SetFailed( "LL_CMP", "Max 32-bit signed int >= 2^31");
+
+    /* Two positive numbers */
+    if ( !LL_CMP( bigInt0, <=, bigInt0 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt0, <=, bigInt1 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( LL_CMP( bigInt0, <=, bigInt2 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt0, <=, bigInt3 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt0, <=, bigInt4 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt0, <=, bigInt5 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    /* Two negative numbers */
+    if ( !LL_CMP( bigInt6, <=, bigInt6 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt6, <=, bigInt7 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( LL_CMP( bigInt6, <=, bigInt8 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt6, <=, bigInt9 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt6, <=, bigInt10 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( !LL_CMP( bigInt6, <=, bigInt11 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    /* One positive, one negative */
+    if ( LL_CMP( bigInt0, <=, bigInt6 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( LL_CMP( bigInt0, <=, bigInt7 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    if ( LL_CMP( bigInt0, <=, bigInt8 ))
+        SetFailed( "LL_CMP", "LL_CMP(<=) failed");
+
+    /* Bitwise Compare two numbers */
+    if ( !LL_UCMP( bigZero, ==, bigZero ))
+        SetFailed( "LL_UCMP", "0 == 0");
+    
+    if ( LL_UCMP( bigZero, >, bigZero ))
+        SetFailed( "LL_UCMP", "0 > 0");
+        
+    if ( LL_UCMP( bigZero, <, bigZero ))
+        SetFailed( "LL_UCMP", "0 < 0");
+        
+    if ( LL_UCMP( bigNumber, <, bigOne ))
+        SetFailed( "LL_UCMP", "n < 1");
+        
+    if ( !LL_UCMP( bigNumber, >, bigOne ))
+        SetFailed( "LL_UCMP", "n < 1");
+        
+    if ( LL_UCMP( bigOne, >, bigNumber ))
+        SetFailed( "LL_UCMP", "1 > n");
+        
+    if ( LL_UCMP( bigMinusNumber, <, bigNumber ))
+        SetFailed( "LL_UCMP", "-n < n");
+
+    /* Two positive numbers */
+    if ( !LL_UCMP( bigInt0, <=, bigInt0 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt1 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( LL_UCMP( bigInt0, <=, bigInt2 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt3 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt4 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt5 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    /* Two negative numbers */
+    if ( !LL_UCMP( bigInt6, <=, bigInt6 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt6, <=, bigInt7 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( LL_UCMP( bigInt6, <=, bigInt8 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt6, <=, bigInt9 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt6, <=, bigInt10 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt6, <=, bigInt11 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    /* One positive, one negative */
+    if ( !LL_UCMP( bigInt0, <=, bigInt6 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt7 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    if ( !LL_UCMP( bigInt0, <=, bigInt8 ))
+        SetFailed( "LL_UCMP", "LL_UCMP(<=) failed");
+
+    return;
+}
+
+/*
+**  TestLogicalOperations() -- Tests for AND, OR, ...
+**
+*/
+static void
+TestLogicalOperations( void )
+{
+    PRUint64    result, result2;
+    
+    ReportProgress("Testing Logical Operations\n");
+    
+    /* Test AND */
+    LL_AND( result, bigZero, bigZero );
+    if ( !LL_IS_ZERO( result ))
+        ResultFailed( "LL_AND", "0 & 0", bigZero, result );
+    
+    LL_AND( result, bigOne, bigOne );
+    if ( LL_IS_ZERO( result ))
+        ResultFailed( "LL_AND", "1 & 1", bigOne, result );
+
+    LL_AND( result, bigZero, bigOne );
+    if ( !LL_IS_ZERO( result ))
+        ResultFailed( "LL_AND", "1 & 1", bigZero, result );
+
+    LL_AND( result, bigMinusOne, bigMinusOne );
+    if ( !LL_UCMP( result, ==, bigMinusOne ))
+        ResultFailed( "LL_AND", "-1 & -1", bigMinusOne, result );
+        
+    /* test OR */
+    LL_OR( result, bigZero, bigZero );
+    if ( !LL_IS_ZERO( result ))
+        ResultFailed( "LL_OR", "0 | 1", bigZero, result);
+    
+    LL_OR( result, bigZero, bigOne );
+    if ( LL_IS_ZERO( result ))
+        ResultFailed( "LL_OR", "0 | 1", bigOne, result );
+    
+    LL_OR( result, bigZero, bigMinusNumber );
+    if ( !LL_UCMP( result, ==, bigMinusNumber ))
+        ResultFailed( "LL_OR", "0 | -n", bigMinusNumber, result);
+    
+    LL_OR( result, bigMinusNumber, bigZero );
+    if ( !LL_UCMP( result, ==, bigMinusNumber ))
+        ResultFailed( "LL_OR", "-n | 0", bigMinusNumber, result );
+    
+    /* test XOR */
+    LL_XOR( result, bigZero, bigZero );
+    if ( LL_UCMP( result, !=, bigZero ))
+        ResultFailed( "LL_XOR", "0 ^ 0", bigZero, result);
+    
+    LL_XOR( result, bigOne, bigZero );
+    if ( LL_UCMP( result, !=, bigOne ))
+        ResultFailed( "LL_XOR", "1 ^ 0", bigZero, result );
+        
+    LL_XOR( result, bigMinusNumber, bigZero );
+    if ( LL_UCMP( result, !=, bigMinusNumber ))
+        ResultFailed( "LL_XOR", "-n ^ 0", bigMinusNumber, result );
+    
+    LL_XOR( result, bigMinusNumber, bigMinusNumber );
+    if ( LL_UCMP( result, !=, bigZero ))
+        ResultFailed( "LL_XOR", "-n ^ -n", bigMinusNumber, result);
+        
+    /* test OR2.  */
+    result = bigZero;
+    LL_OR2( result, bigOne );
+    if ( LL_UCMP( result, !=, bigOne ))
+        ResultFailed( "LL_OR2", "(r=0) |= 1", bigOne, result);
+        
+    result = bigOne;
+    LL_OR2( result, bigNumber );
+    if ( LL_UCMP( result, !=, bigNumber ))
+        ResultFailed( "LL_OR2", "(r=1) |= n", bigNumber, result);
+
+    result = bigMinusNumber;
+    LL_OR2( result, bigMinusNumber );
+    if ( LL_UCMP( result, !=, bigMinusNumber ))
+        ResultFailed( "LL_OR2", "(r=-n) |= -n", bigMinusNumber, result);
+
+    /* test NOT */
+    LL_NOT( result, bigMinusNumber);
+    LL_NOT( result2, result);
+    if ( LL_UCMP( result2, !=, bigMinusNumber ))
+        ResultFailed( "LL_NOT", "r != ~(~-n)", bigMinusNumber, result);
+            
+    /* test Negation */
+    LL_NEG( result, bigMinusNumber );
+    LL_NEG( result2, result );
+    if ( LL_CMP( result2, !=, bigMinusNumber ))
+        ResultFailed( "LL_NEG", "r != -(-(-n))", bigMinusNumber, result);
+
+    return;
+}
+
+
+
+/*
+**  TestConversion() -- Test Conversion Operations
+**
+*/
+static void
+TestConversion( void )
+{
+    PRInt64     result;
+    PRInt64     resultU;
+    PRInt32     result32;
+    PRUint32    resultU32;
+    float       resultF;
+    PRFloat64   resultD;
+    
+    ReportProgress("Testing Conversion Operations\n");
+    
+    /* LL_L2I  -- Convert to signed 32bit */
+    LL_L2I(result32, bigOne );
+    if ( result32 != one )  
+        SetFailed( "LL_L2I", "r != 1");
+    
+    LL_L2I(result32, bigMinusOne );
+    if ( result32 != minusOne )  
+        SetFailed( "LL_L2I", "r != -1");
+    
+    /* LL_L2UI -- Convert 64bit to unsigned 32bit */
+    LL_L2UI( resultU32, bigMinusOne );
+    if ( resultU32 != (PRUint32) minusOne )
+        SetFailed( "LL_L2UI", "r != -1");
+    
+    LL_L2UI( resultU32, bigOne );
+    if ( resultU32 != (PRUint32) one )
+        SetFailed( "LL_L2UI", "r != 1");
+        
+    /* LL_L2F  -- Convert to 32bit floating point */
+    LL_L2F( resultF, bigOne );
+    if ( resultF != 1.0 )
+        SetFailed( "LL_L2F", "r != 1.0");
+        
+    LL_L2F( resultF, bigMinusOne );
+    if ( resultF != -1.0 )
+        SetFailed( "LL_L2F", "r != 1.0");
+    
+    /* LL_L2D  -- Convert to 64bit floating point */
+    LL_L2D( resultD, bigOne );
+    if ( resultD != 1.0L )
+        SetFailed( "LL_L2D", "r != 1.0");
+        
+    LL_L2D( resultD, bigMinusOne );
+    if ( resultD != -1.0L )
+        SetFailed( "LL_L2D", "r != -1.0");
+        
+    /* LL_I2L  -- Convert 32bit signed to 64bit signed */
+    LL_I2L( result, one );
+    if ( LL_CMP(result, !=, bigOne ))
+        SetFailed( "LL_I2L", "r != 1");
+        
+    LL_I2L( result, minusOne );
+    if ( LL_CMP(result, !=, bigMinusOne ))
+        SetFailed( "LL_I2L", "r != -1");
+        
+    /* LL_UI2L -- Convert 32bit unsigned to 64bit unsigned */
+    LL_UI2L( resultU, (PRUint32) one );
+    if ( LL_CMP(resultU, !=, bigOne ))
+        SetFailed( "LL_UI2L", "r != 1");
+        
+    /* [lth.] This did not behave as expected, but it is correct 
+    */
+    LL_UI2L( resultU, (PRUint32) minusOne );
+    if ( LL_CMP(resultU, !=, bigZeroFox ))
+        ResultFailed( "LL_UI2L", "r != -1", bigZeroFox, resultU);
+        
+    /* LL_F2L  -- Convert 32bit float to 64bit signed */
+    LL_F2L( result, 1.0 );
+    if ( LL_CMP(result, !=, bigOne ))
+        SetFailed( "LL_F2L", "r != 1");
+        
+    LL_F2L( result, -1.0 );
+    if ( LL_CMP(result, !=, bigMinusOne ))
+        SetFailed( "LL_F2L", "r != -1");
+    
+    /* LL_D2L  -- Convert 64bit Float to 64bit signed */
+    LL_D2L( result, 1.0L );
+    if ( LL_CMP(result, !=, bigOne ))
+        SetFailed( "LL_D2L", "r != 1");
+        
+    LL_D2L( result, -1.0L );
+    if ( LL_CMP(result, !=, bigMinusOne ))
+        SetFailed( "LL_D2L", "r != -1");
+
+    return;
+}
+
+static void ShiftCompileOnly()
+{
+    /*
+    ** This function is only compiled, never called.
+    ** The real test is to see if it compiles w/o
+    ** warnings. This is no small feat, by the way.
+    */
+    PRInt64 ia, ib;
+    PRUint64 ua, ub;
+    LL_SHR(ia, ib, 32);
+    LL_SHL(ia, ib, 32);
+
+    LL_USHR(ua, ub, 32);
+    LL_ISHL(ia, 49, 32);
+
+}  /* ShiftCompileOnly */
+   
+
+/*
+**  TestShift() -- Test Shifting Operations
+**
+*/
+static void
+TestShift( void )
+{
+    static const PRInt64 largeTwoZero = LL_INIT( 0x00000002, 0x00000000 );
+    PRInt64     result;
+    PRUint64    resultU;
+
+    ReportProgress("Testing Shifting Operations\n");
+    
+    /* LL_SHL  -- Shift left algebraic */
+    LL_SHL( result, bigOne, one );
+    if ( LL_CMP( result, !=, bigTwo ))
+        ResultFailed( "LL_SHL", "r != 2", bigOne, result );
+    
+    LL_SHL( result, bigTwo, thirtyTwo );
+    if ( LL_CMP( result, !=, largeTwoZero ))
+        ResultFailed( "LL_SHL", "r != twoZero", largeTwoZero, result);
+    
+    /* LL_SHR  -- Shift right algebraic */
+    LL_SHR( result, bigFoxZero, thirtyTwo );
+    if ( LL_CMP( result, !=, bigMinusOne ))
+        ResultFailed( "LL_SHR", "r != -1", bigMinusOne, result);
+    
+    LL_SHR( result, bigTwo, one );
+    if ( LL_CMP( result, !=, bigOne ))
+        ResultFailed( "LL_SHR", "r != 1", bigOne, result);
+
+    LL_SHR( result, bigFoxFox, thirtyTwo );
+    if ( LL_CMP( result, !=, bigMinusOne ))
+        ResultFailed( "LL_SHR", "r != -1 (was ff,ff)", bigMinusOne, result);
+    
+    /* LL_USHR -- Logical shift right */
+    LL_USHR( resultU, bigZeroFox, thirtyTwo );
+    if ( LL_UCMP( resultU, !=, bigZero ))
+        ResultFailed( "LL_USHR", "r != 0 ", bigZero, result);
+    
+    LL_USHR( resultU, bigFoxFox, thirtyTwo );
+    if ( LL_UCMP( resultU, !=, bigZeroFox ))
+        ResultFailed( "LL_USHR", "r != 0 ", bigZeroFox, result);
+    
+    /* LL_ISHL -- Shift a 32bit integer into a 64bit result */
+    LL_ISHL( resultU, minusOne, thirtyTwo );
+    if ( LL_UCMP( resultU, !=, bigFoxZero ))
+        ResultFailed( "LL_ISHL", "r != ff,00 ", bigFoxZero, result);
+    
+    LL_ISHL( resultU, one, sixtyThree );
+    if ( LL_UCMP( resultU, !=, bigEightZero ))
+        ResultFailed( "LL_ISHL", "r != 80,00 ", bigEightZero, result);
+    
+    LL_ISHL( resultU, one, sixteen );
+    if ( LL_UCMP( resultU, !=, big64K ))
+        ResultFailed( "LL_ISHL", "r != 64K ", big64K, resultU);
+    
+    return;
+}    
+
+
+/*
+**  TestArithmetic() -- Test arithmetic operations.
+**
+*/
+static void
+TestArithmetic( void )
+{
+    PRInt64 largeVal          = LL_INIT( 0x00000001, 0xffffffff );
+    PRInt64 largeValPlusOne   = LL_INIT( 0x00000002, 0x00000000 );
+    PRInt64 largeValTimesTwo  = LL_INIT( 0x00000003, 0xfffffffe );
+    PRInt64 largeMultCand     = LL_INIT( 0x00000000, 0x7fffffff );
+    PRInt64 largeMinusMultCand = LL_INIT( 0xffffffff, 0x10000001 );
+    PRInt64 largeMultCandx64K = LL_INIT( 0x00007fff, 0xffff0000 );
+    PRInt64 largeNumSHL5      = LL_INIT( 0x0000001f, 0xffffffe0 );        
+    PRInt64 result, result2;
+
+    /* Addition */    
+    LL_ADD( result, bigOne, bigOne );
+    if ( LL_CMP( result, !=, bigTwo ))
+        ResultFailed( "LL_ADD", "r != 1 + 1", bigTwo, result);
+
+    LL_ADD( result, bigMinusOne, bigOne );
+    if ( LL_CMP( result, !=, bigZero ))
+        ResultFailed( "LL_ADD", "r != -1 + 1", bigOne, result);
+
+    LL_ADD( result, largeVal, bigOne );
+    if ( LL_CMP( result, !=, largeValPlusOne ))
+        ResultFailed( "LL_ADD", "lVP1 != lV + 1", largeValPlusOne, result);
+            
+    /* Subtraction */
+    LL_SUB( result, bigOne, bigOne );
+    if ( LL_CMP( result, !=, bigZero ))
+        ResultFailed( "LL_SUB", "r != 1 - 1", bigZero, result);
+            
+    LL_SUB( result, bigTwo, bigOne );
+    if ( LL_CMP( result, !=, bigOne ))
+        ResultFailed( "LL_SUB", "r != 2 - 1", bigOne, result);
+            
+    LL_SUB( result, largeValPlusOne, bigOne );
+    if ( LL_CMP( result, !=, largeVal ))
+        ResultFailed( "LL_SUB", "r != lVP1 - 1", largeVal, result);
+            
+    
+    /* Multiply */
+    LL_MUL( result, largeVal, bigTwo );
+    if ( LL_CMP( result, !=, largeValTimesTwo ))
+        ResultFailed( "LL_MUL", "r != lV*2", largeValTimesTwo, result);
+    
+    LL_MUL( result, largeMultCand, big64K );
+    if ( LL_CMP( result, !=, largeMultCandx64K ))
+        ResultFailed( "LL_MUL", "r != lV*64K", largeMultCandx64K, result);
+        
+    LL_NEG( result2, largeMultCand );
+    LL_MUL( result, largeMultCand, bigMinusOne );
+    if ( LL_CMP( result, !=, result2  ))
+        ResultFailed( "LL_MUL", "r != -lMC", result2, result);
+
+    LL_SHL( result2, bigZeroFox, 5);
+    LL_MUL( result, bigZeroFox, bigThirtyTwo );
+    if ( LL_CMP( result, !=, largeNumSHL5  ))
+        ResultFailed( "LL_MUL", "r != 0f<<5", largeNumSHL5, result );
+
+    
+
+    /* LL_DIV() Division */
+    LL_DIV( result, bigOne, bigOne);
+    if ( LL_CMP( result, !=, bigOne ))
+        ResultFailed( "LL_DIV", "1 != 1", bigOne, result);
+    
+    LL_DIV( result, bigNumber, bigOne );
+    if ( LL_CMP( result, !=, bigNumber  ))
+        ResultFailed( "LL_DIV", "r != n / 1", bigNumber, result);
+
+    LL_DIV( result, bigNumber, bigMinusOne );
+    if ( LL_CMP( result, !=, bigMinusNumber  ))
+        ResultFailed( "LL_DIV", "r != n / -1", bigMinusNumber, result);
+
+    LL_DIV( result, bigMinusNumber, bigMinusOne );
+    if ( LL_CMP( result, !=, bigNumber  ))
+        ResultFailed( "LL_DIV", "r != -n / -1", bigNumber, result);
+        
+    LL_SHL( result2, bigZeroFox, 5 );
+    LL_DIV( result, result2, bigOne );
+    if ( LL_CMP( result, !=, result2  ))
+        ResultFailed( "LL_DIV", "0f<<5 != 0f<<5", result2, result);
+    
+    LL_SHL( result2, bigZeroFox, 5 );
+    LL_NEG( result2, result2 );
+    LL_DIV( result, result2, bigOne );
+    if ( LL_CMP( result, !=, result2  ))
+        ResultFailed( "LL_DIV", "-0f<<5 != -0f<<5", result2, result);
+    
+    LL_SHL( result2, bigZeroFox, 17 );
+    LL_DIV( result, result2, bigMinusOne );
+    LL_NEG( result2, result2 );
+    if ( LL_CMP( result, !=, result2  ))
+        ResultFailed( "LL_DIV", "-0f<<17 != -0f<<17", result2, result);
+    
+    
+    /* LL_MOD() Modulo Division */
+    LL_ADD( result2, bigThirtyTwo, bigOne );
+    LL_MOD( result, result2, bigSixTeen );
+    if ( LL_CMP( result, !=, bigOne ))
+        ResultFailed( "LL_MOD", "r != 1", bigSixTeen, result);
+    
+    
+    LL_MUL( result2, bigZeroFox, bigThirtyTwo );
+    LL_ADD( result2, result2, bigSixTeen);
+    LL_MOD( result, result2, bigThirtyTwo );
+    if ( LL_CMP( result, !=, bigSixTeen ))
+        ResultFailed( "LL_MOD", "r != 16", bigSixTeen, result);
+
+    /* LL_UDIVMOD */
+    LL_DIV( result, bigOne, bigOne);
+    if ( LL_CMP( result, !=, bigOne ))
+        ResultFailed( "LL_DIV", "r != 16", bigSixTeen, result);
+    
+
+    return;
+} 
+
+static void TestWellknowns(void)
+{
+    PRInt64 max = LL_MAXINT, min = LL_MININT, zero = LL_ZERO;
+    PRInt64 mmax = LL_MaxInt(), mmin = LL_MinInt(), mzero = LL_Zero();
+    if (LL_NE(max, mmax))
+        ResultFailed( "max, mmax", "max != mmax", max, mmax);
+    if (LL_NE(min, mmin))
+        ResultFailed( "min, mmin", "min != mmin", max, mmin);
+    if (LL_NE(zero, mzero))
+        ResultFailed( "zero, mzero", "zero != mzero", zero, mzero);
+}  /* TestWellknowns */ 
+
+/*
+** Initialize() -- Initialize the test case
+**
+** Parse command line options
+**
+*/
+static PRIntn
+Initialize( PRIntn argc, char **argv )
+{
+    PLOptState *opt = PL_CreateOptState(argc, argv, "dvh");
+    PLOptStatus os;
+
+    /*
+    ** Parse command line options
+    */    
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    {
+        if (PL_OPT_BAD == os) continue;
+        switch (opt->option)
+        {
+        case 'd':  /* set debug mode */
+            debugMode = PR_TRUE;
+            break;
+            
+        case 'v':  /* set verbose mode */
+            verboseMode = PR_TRUE;
+            debugMode = PR_TRUE;
+            break;
+            
+        case 'h':  /* user wants some guidance */
+        default:
+            PR_fprintf(output, "You get help.\n");
+            return(1);
+        }
+    }
+    PL_DestroyOptState(opt);
+    return(0);
+}    
+
+PRIntn main( int argc, char **argv )
+{
+    PR_STDIO_INIT();
+    output = PR_GetSpecialFD(PR_StandardError);
+
+    if ( Initialize( argc, argv ))
+        return(1);
+
+    TestAssignment();
+    TestComparisons();
+    TestLogicalOperations();
+    TestConversion();
+    TestShift();
+    TestArithmetic();
+    TestWellknowns();
+    
+    /*
+    ** That's all folks!
+    */
+    if ( failedAlready )
+    {
+        PR_fprintf(output, "FAIL\n");\
+    } 
+    else
+    {
+        PR_fprintf(output, "PASS\n");\
+    }
+    return failedAlready;
+} /* end main() */