| /* -*- 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); |
| } |
| |
| int 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() */ |
