TestHashLongMap (stSoftware API)

java.lang.Object
- TestCase
- - com.aspc.remote.memory.selftest.TestHashLongMap

```
public class TestHashLongMap
extends TestCase
```
check HashLongMap logic
THREAD MODE: SINGLE-THREADED self test unit

Since:

17 October 2009

Author:

Nigel Leck

Constructor Summary

Constructors
Constructor and Description

TestHashLongMap(java.lang.String testName)
Constructor for the test unit.

Constructors
Constructor and Description
`TestHashLongMap(java.lang.String testName)` Constructor for the test unit.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`main(java.lang.String[] args)` The main for the program
`void`	`runBare()` Runs the bare test sequence.
`static Test`	`suite()` Creates the test suite.
`void`	`testAddAndRemoveOneWithoutInitialize()` check that we can add one without putting everything into elements.
`void`	`testAddAndRemoveOneWithoutInitializeClone()` check that we can add and remove one without putting everything into elements.
`void`	`testClearOverflow()` should clear the overflow value.
`void`	`testFirstGet()` first get without any put
`void`	`testGetKeyArrayOverflowWithUnkownSort()` NPE from getKeyArray
`void`	`testGetOverflow()` should get a the overflow value.
`void`	`testGetSortKey()` getKey is causing an issue
`void`	`testInitContainsKey()` getKey is causing an issue
`void`	`testInitContainsKey2()` getKey is causing an issue
`void`	`testIsSorted()` check is sorted.
`void`	`testKeySortedArray()` check is sorted.
`void`	`testLargeSmallPutAll()` should not initialize if large and small
`void`	`testLazyAddIsSorted()` check that the lazy add handles sort.
`void`	`testLazyAddIsSorted2()` check that the lazy add handles sort.
`void`	`testLazyBrief()` check that we can add one without putting everything into elements.
`void`	`testLazyCloneInitializePutAll()` Check that we are not initialized first off.
`void`	`testLazyInitialize()` Check that we are not initialized first off.
`void`	`testLazyInitializePutAll()` Check that we are not initialized first off.
`void`	`testLazyInitializeRemove()` Check the remove.
`void`	`testLazySort()` Check that we do not change the orginal list ( maybe used by another thread somewhere else)
`void`	`testLazySortClone()` Check that we do not change the orginal list ( maybe used by another thread somewhere else)
`void`	`testMarkSmallAsSorted()` if it only has < 2 rows then it's is sorted.
`void`	`testPutAllCheckSorted()` Check that we detect that the rows are sorted.
`void`	`testPutAllReplace()` check that we replace one va
`void`	`testPutGetSortedArrayGetKeyArray()` put, getSortedKeyArray, put
`void`	`testPutMultipleThenTwoPuts()` put multiple.
`void`	`testPutMultiWithDuplicates()` check that we can put in duplicates and they get sorted out
`void`	`testPutNullPutValue()` put NULL and then put value
`void`	`testPutReturnValue()` check the return value of the put.
`void`	`testPutThenPutMultiple()` put and then put multiple.
`void`	`testPutThenPutMultipleDiff()` put and then put multiple with different values
`void`	`testReplace()` check that we replace one va
`void`	`testSecondGet()` second get with first put
`void`	`testShared()` don't give out shared arrays.
`void`	`testShared2()` don't give out shared arrays.
`void`	`testShared3()` don't give out shared arrays.
`void`	`testShouldBeAbleToAddOne()` check that we can add one without putting everything into elements.
`void`	`testShouldBeAbleToAddOneClone()` check that we can add one without putting everything into elements.
`void`	`testShouldSortIfNeededContains()` check that a number of calls to contains will sort.
`void`	`testShouldSortIfNeededGet()` check that a number of calls to get will sort.
`void`	`testShouldSortIfNeededRemove()` check that a number of calls to get will sort.
`void`	`testTwoPutAll()` Check that we are not initialized first off.
`void`	`testVeryLargeUnionUnSorted()` check we can handle very large sets.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - TestHashLongMap
```
public TestHashLongMap(java.lang.String testName)
```
    Constructor for the test unit.
    
    Parameters:
    
    testName - The name of the test unit
- Method Detail
  - main
```
public static void main(java.lang.String[] args)
```
    The main for the program
    
    Parameters:
    
    args - The command line arguments
  - suite
```
public static Test suite()
```
    Creates the test suite.
    
    Returns:
    
    The test suite
  - runBare
```
public void runBare()
             throws java.lang.Throwable
```
    Runs the bare test sequence.
    
    Throws:
    
    java.lang.Throwable - if any exception is thrown
  - testGetSortKey
```
public void testGetSortKey()
                    throws java.lang.Exception
```
    getKey is causing an issue
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testInitContainsKey
```
public void testInitContainsKey()
                         throws java.lang.Exception
```
    getKey is causing an issue
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testInitContainsKey2
```
public void testInitContainsKey2()
                          throws java.lang.Exception
```
    getKey is causing an issue
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShared3
```
public void testShared3()
                 throws java.lang.Exception
```
    don't give out shared arrays.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShared
```
public void testShared()
                throws java.lang.Exception
```
    don't give out shared arrays.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShared2
```
public void testShared2()
                 throws java.lang.Exception
```
    don't give out shared arrays.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutMultiWithDuplicates
```
public void testPutMultiWithDuplicates()
                                throws java.lang.Exception
```
    check that we can put in duplicates and they get sorted out
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutReturnValue
```
public void testPutReturnValue()
                        throws java.lang.Exception
```
    check the return value of the put.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testReplace
```
public void testReplace()
                 throws java.lang.Exception
```
    check that we replace one va
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutAllReplace
```
public void testPutAllReplace()
                       throws java.lang.Exception
```
    check that we replace one va
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutNullPutValue
```
public void testPutNullPutValue()
                         throws java.lang.Exception
```
    put NULL and then put value
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutGetSortedArrayGetKeyArray
```
public void testPutGetSortedArrayGetKeyArray()
                                      throws java.lang.Exception
```
    put, getSortedKeyArray, put
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutThenPutMultiple
```
public void testPutThenPutMultiple()
                            throws java.lang.Exception
```
    put and then put multiple.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutMultipleThenTwoPuts
```
public void testPutMultipleThenTwoPuts()
                                throws java.lang.Exception
```
    put multiple. then two puts.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutThenPutMultipleDiff
```
public void testPutThenPutMultipleDiff()
                                throws java.lang.Exception
```
    put and then put multiple with different values
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testFirstGet
```
public void testFirstGet()
                  throws java.lang.Exception
```
    first get without any put
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testSecondGet
```
public void testSecondGet()
                   throws java.lang.Exception
```
    second get with first put
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testGetKeyArrayOverflowWithUnkownSort
```
public void testGetKeyArrayOverflowWithUnkownSort()
                                           throws java.lang.Exception
```
    NPE from getKeyArray
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testGetOverflow
```
public void testGetOverflow()
                     throws java.lang.Exception
```
    should get a the overflow value.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testClearOverflow
```
public void testClearOverflow()
                       throws java.lang.Exception
```
    should clear the overflow value.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLargeSmallPutAll
```
public void testLargeSmallPutAll()
                          throws java.lang.Exception
```
    should not initialize if large and small
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyAddIsSorted
```
public void testLazyAddIsSorted()
                         throws java.lang.Exception
```
    check that the lazy add handles sort.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyAddIsSorted2
```
public void testLazyAddIsSorted2()
                          throws java.lang.Exception
```
    check that the lazy add handles sort.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyBrief
```
public void testLazyBrief()
                   throws java.lang.Exception
```
    check that we can add one without putting everything into elements.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShouldBeAbleToAddOne
```
public void testShouldBeAbleToAddOne()
                              throws java.lang.Exception
```
    check that we can add one without putting everything into elements.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShouldBeAbleToAddOneClone
```
public void testShouldBeAbleToAddOneClone()
                                   throws java.lang.Exception
```
    check that we can add one without putting everything into elements.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testAddAndRemoveOneWithoutInitialize
```
public void testAddAndRemoveOneWithoutInitialize()
                                          throws java.lang.Exception
```
    check that we can add one without putting everything into elements.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testAddAndRemoveOneWithoutInitializeClone
```
public void testAddAndRemoveOneWithoutInitializeClone()
                                               throws java.lang.Exception
```
    check that we can add and remove one without putting everything into elements.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShouldSortIfNeededContains
```
public void testShouldSortIfNeededContains()
                                    throws java.lang.Exception
```
    check that a number of calls to contains will sort.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShouldSortIfNeededGet
```
public void testShouldSortIfNeededGet()
                               throws java.lang.Exception
```
    check that a number of calls to get will sort.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testMarkSmallAsSorted
```
public void testMarkSmallAsSorted()
                           throws java.lang.Exception
```
    if it only has < 2 rows then it's is sorted.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testShouldSortIfNeededRemove
```
public void testShouldSortIfNeededRemove()
                                  throws java.lang.Exception
```
    check that a number of calls to get will sort.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazySort
```
public void testLazySort()
                  throws java.lang.Exception
```
    Check that we do not change the orginal list ( maybe used by another thread somewhere else)
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazySortClone
```
public void testLazySortClone()
                       throws java.lang.Exception
```
    Check that we do not change the orginal list ( maybe used by another thread somewhere else)
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyInitializeRemove
```
public void testLazyInitializeRemove()
                              throws java.lang.Exception
```
    Check the remove.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testVeryLargeUnionUnSorted
```
public void testVeryLargeUnionUnSorted()
                                throws java.lang.Exception
```
    check we can handle very large sets.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyInitialize
```
public void testLazyInitialize()
                        throws java.lang.Exception
```
    Check that we are not initialized first off.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testPutAllCheckSorted
```
public void testPutAllCheckSorted()
                           throws java.lang.Exception
```
    Check that we detect that the rows are sorted.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testTwoPutAll
```
public void testTwoPutAll()
                   throws java.lang.Exception
```
    Check that we are not initialized first off.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyInitializePutAll
```
public void testLazyInitializePutAll()
                              throws java.lang.Exception
```
    Check that we are not initialized first off.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testLazyCloneInitializePutAll
```
public void testLazyCloneInitializePutAll()
                                   throws java.lang.Exception
```
    Check that we are not initialized first off.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testIsSorted
```
public void testIsSorted()
                  throws java.lang.Exception
```
    check is sorted.
    
    Throws:
    
    java.lang.Exception - a serious problem
  - testKeySortedArray
```
public void testKeySortedArray()
                        throws java.lang.Exception
```
    check is sorted.
    
    Throws:
    
    java.lang.Exception - a serious problem

Class TestHashLongMap

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TestHashLongMap

Method Detail

main

suite

runBare

testGetSortKey

testInitContainsKey

testInitContainsKey2

testShared3

testShared

testShared2

testPutMultiWithDuplicates

testPutReturnValue

testReplace

testPutAllReplace

testPutNullPutValue

testPutGetSortedArrayGetKeyArray

testPutThenPutMultiple

testPutMultipleThenTwoPuts

testPutThenPutMultipleDiff

testFirstGet

testSecondGet

testGetKeyArrayOverflowWithUnkownSort

testGetOverflow

testClearOverflow

testLargeSmallPutAll

testLazyAddIsSorted

testLazyAddIsSorted2

testLazyBrief

testShouldBeAbleToAddOne

testShouldBeAbleToAddOneClone

testAddAndRemoveOneWithoutInitialize

testAddAndRemoveOneWithoutInitializeClone

testShouldSortIfNeededContains

testShouldSortIfNeededGet

testMarkSmallAsSorted

testShouldSortIfNeededRemove

testLazySort

testLazySortClone

testLazyInitializeRemove

testVeryLargeUnionUnSorted

testLazyInitialize

testPutAllCheckSorted

testTwoPutAll

testLazyInitializePutAll

testLazyCloneInitializePutAll

testIsSorted

testKeySortedArray