Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unimi.dsi.sux4j.util;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 
 import org.junit.Test;
 
 public class ZFastTrieTest {
 
 
 	public static String binaryint l ) {
 		String s = "0000000000000000000000000000000000000000000000000000000000000000000000000" + Integer.toBinaryStringl );
 		return s.substrings.length() - 32 );
 	}
 
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testEmpty() throws IOExceptionClassNotFoundException {
 		String[] s = {};
 		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
 		assertFalsezft.contains"" ) );
 		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
 		temp.deleteOnExit();
 		BinIO.storeObjectzfttemp );
 		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
 		assertFalsezft.contains"" ) );
 	}
 
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testSingleton() throws IOExceptionClassNotFoundException {
 		String[] s = { "a" };
 		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruesi ], zft.containssi ] ) );
 		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
 		temp.deleteOnExit();
 		BinIO.storeObjectzfttemp );
 		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruezft.containssi ] ) );
 
 		zft.remove"a" );
 		assertFalsezft.contains"a" ) );
 
 		assertFalseiterator.hasNext() );
 		assertFalseiterator.hasPrevious() );
 	}
 
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testDoubleton() throws IOExceptionClassNotFoundException {
 		String[] s = { "a""c" };
 		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruesi ], zft.containssi ] ) );
 		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
 		temp.deleteOnExit();
 		BinIO.storeObjectzfttemp );
 		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruezft.containssi ] ) );
 
 		for ( int i = s.lengthi-- != 0; ) {
 			assertTruezft.removesi ] ) );
 			assertFalsezft.containssi ] ) );
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testDoubleton2() throws IOExceptionClassNotFoundException {
 		String[] s = { "c""a" };
 		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruesi ], zft.containssi ] ) );
 		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
 		temp.deleteOnExit();
 		BinIO.storeObjectzfttemp );
 		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
 		for ( int i = s.lengthi-- != 0; )
 			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
	public void testTriple() throws IOExceptionClassNotFoundException {
		String[] s = { "a""b""c" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
	public void testTriple2() throws IOExceptionClassNotFoundException {
		String[] s = { "c""b""a" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
		String[] s = { "a""aa""aaa" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
		String[] s = { "a""aa""aaa" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
	public void testSmallest() throws IOExceptionClassNotFoundException {
		String[] s = { "a""b""c""d""e""f""g" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
	public void testSmallest2() throws IOExceptionClassNotFoundException {
		String[] s = { "g""f""e""d""c""b""a" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	@SuppressWarnings("unchecked")
	public void testSmall() throws IOExceptionClassNotFoundException {
		String[] s = { "-""0""1""4""5""a""b""c""d""e""f""g""}" };
		ZFastTrie<Stringzft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
		for ( int i = s.lengthi-- != 0; )
			assertTruesi ], zft.containssi ] ) );
		File temp = File.createTempFilegetClass().getSimpleName(), "test" );
		BinIO.storeObjectzfttemp );
		zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
		for ( int i = s.lengthi-- != 0; )
			assertTruezft.containssi ] ) );
		for ( int i = s.lengthi-- != 0; ) {
			assertTruezft.removesi ] ) );
			assertFalsezft.containssi ] ) );
		}
	}
	public void testEmptyLcp() {
		ZFastTrie<BitVectorzft = new ZFastTrie<BitVector>( TransformationStrategies.identity() );
		assertTruezft.add( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.contains( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.contains( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 0, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.contains( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.contains( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 0 ) ) );
		assertTruezft.add( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 1 ) ) );
		assertTruezft.remove( LongArrayBitVector.of( 1, 0 ) ) );
	}
	public void testManyBranches() {
		ZFastTrie<BitVectorzft = new ZFastTrie<BitVector>( TransformationStrategies.identity() );
		for ( int p = 0; p < 10; p++ ) {
			for ( int i = 0; i < ( 1 << p ); i++ )
				assertTruezft.add( LongArrayBitVector.getInstance().appendip ) ) );
			for ( int i = 0; i < ( 1 << p ); i++ )
				assertTruezft.contains( LongArrayBitVector.getInstance().appendip ) ) );
			for ( int i = 0; i < ( 1 << p ); i++ )
				assertTruezft.remove( LongArrayBitVector.getInstance().appendip ) ) );
			for ( int i = 0; i < ( 1 << p ); i++ )
				assertTruezft.add( LongArrayBitVector.getInstance().appendip ) ) );
			for ( int i = ( 1 << p ); i-- != 0; )
				assertTruezft.remove( LongArrayBitVector.getInstance().appendip ) ) );
		}
	}
	public void testLinear() {
		ZFastTrie<BitVectorzft = new ZFastTrie<BitVector>( TransformationStrategies.identity() );
		for ( int p = 0; p < 20; p++ )
			assertTruezft.add( LongArrayBitVector.getInstance().append( 1 << pp + 1 ) ) );
		for ( int p = 0; p < 20; p++ )
			assertTruezft.contains( LongArrayBitVector.getInstance().append( 1 << pp + 1 ) ) );
		for ( int p = 0; p < 20; p++ )
			assertTruezft.remove( LongArrayBitVector.getInstance().append( 1 << pp + 1 ) ) );
		for ( int p = 0; p < 20; p++ )
			assertTruezft.add( LongArrayBitVector.getInstance().append( 1 << pp + 1 ) ) );
		for ( int p = 20; p-- != 0; )
			assertTruezft.remove( LongArrayBitVector.getInstance().append( 1 << pp + 1 ) ) );
	}
	public void testExtent() {
		ZFastTrie<LongArrayBitVectorzft = new ZFastTrie<LongArrayBitVector>( TransformationStrategies.identity() );
		LongArrayBitVector v = LongArrayBitVector.getInstance();
		v.add( 0 );
		v.add( 1 );
		zft.addv );
		LongArrayBitVector w = LongArrayBitVector.getInstance();
		w.add( 0 );
		w.add( 0 );
		zft.addw );
		LongArrayBitVector q = LongArrayBitVector.getInstance();
		q.add( 0 );
		zft.containsq );
	}
	@SuppressWarnings("unchecked")
	public void testNumbers() throws IOExceptionClassNotFoundException {
		File temp;
		for ( int d = 10; d < 10000; d *= 10 ) {
			String[] s = new Stringd ];
			for ( int rand = 0; rand < 2; rand++ ) {
				for ( int i = s.lengthi-- != 0; )
					si ] = binaryi );
				for ( int pass = 0; pass < 2; pass++ ) {
					zft = new ZFastTrie<String>( Arrays.asLists ), TransformationStrategies.prefixFreeIso() );
					for ( int i = s.lengthi-- != 0; )
						assertTruesi ], zft.containssi ] ) );
					// Exercise code for negative results
					for ( int i = 1000; i-- != 0; )
						zft.containsbinaryi * i + d ) );
					temp = File.createTempFilegetClass().getSimpleName(), "test" );
					BinIO.storeObjectzfttemp );
					zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
					for ( int i = s.lengthi-- != 0; )
						assertTruesi ], zft.containssi ] ) );
					zft = new ZFastTrie<String>( Arrays.asLists ), new HuTuckerTransformationStrategy( Arrays.asLists ), true ) );
					for ( int i = s.lengthi-- != 0; )
						assertTruesi ], zft.containssi ] ) );
					temp = File.createTempFilegetClass().getSimpleName(), "test" );
					BinIO.storeObjectzfttemp );
					zft = (ZFastTrie<String>)BinIO.loadObjecttemp );
					for ( int i = s.lengthi-- != 0; )
						assertTruesi ], zft.containssi ] ) );
					Collections.sort( Arrays.asLists ) );
					int p = 0;
					for ( iterator = zft.iterator(); iterator.hasNext(); )
						assertEqualsiterator.next(), sp++ ] );
					while ( iterator.hasPrevious() )
						assertEqualsiterator.previous(), s[ --p ] );
					for ( int i = 0; i < s.length / 100; i++ ) {
						p = i;
						for ( iterator = zft.iteratorsi ] ); iterator.hasNext(); )
							assertEqualsiterator.next(), sp++ ] );
						while ( iterator.hasPrevious() )
							assertEqualsiterator.previous(), s[ --p ] );
					}
					for ( int i = s.lengthi-- != 0; ) {
						assertTruezft.removesi ] ) );
						assertFalsezft.containssi ] ) );
					}
					Collections.shuffle( Arrays.asLists ), new XorShift1024StarRandom( 1 ) );
				}
			}
			for ( int i = s.lengthi-- != 0; )
				si ] = binaryrandom.nextInt. ) );
		}
	}
New to GrepCode? Check out our FAQ X