/*
* Copyright (c) 2010, Rickard Öberg. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.qi4j.functional;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.List;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
import static java.util.Collections.*;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
/**
* Test of Iterables utility methods
*/
public class IterablesTest
{
private List<String> numbers = Arrays.asList( "1", "2", "3" );
private Iterable<Long> numberLongs = Arrays.asList( 1L, 2L, 3L );
private Iterable<Integer> numberIntegers = Arrays.asList( 1, 2, 3 );
@Test
public void testConstant()
{
String str = "";
for( String string : Iterables.limit( 3, Iterables.constant( "123" ) ) )
{
str += string;
}
assertThat( str, CoreMatchers.equalTo( "123123123" ) );
}
@Test
public void testUnique()
{
String str = "";
for( String string : Iterables.unique( Iterables.<String>flatten( numbers, numbers, numbers ) ) )
{
str += string;
}
assertThat( str, CoreMatchers.equalTo( "123" ) );
}
@Test
public void testAddAll()
{
List<String> strings = Iterables.toList( numbers );
assertThat( strings.toString(), equalTo( "[1, 2, 3]" ) );
assertThat( Iterables.toList( numberLongs ).toString(), equalTo( "[1, 2, 3]" ) );
}
@Test
public void testCount()
{
assertThat( Iterables.count( numbers ), equalTo( 3L ) );
}
@Test
public void testFilter()
{
assertThat( Iterables.first( Iterables.filter( Specifications.in( "2" ), numbers ) ), equalTo( "2" ) );
}
@Test
public void testFirst()
{
assertThat( Iterables.first( numbers ), equalTo( "1" ) );
assertThat( Iterables.first( emptyList() ), nullValue() );
}
@Test
public void testLast()
{
assertThat( Iterables.last( numbers ), equalTo( "3" ) );
assertThat( Iterables.last( emptyList() ), nullValue() );
}
@Test
public void testFolding()
{
assertThat( Iterables.fold( new Function<Integer, Integer>()
{
int sum = 0;
@Override
public Integer map( Integer number )
{
return sum += number;
}
}, numberIntegers ), equalTo( 6 ) );
}
@Test
public void testAppend()
{
assertThat( Iterables.toList( Iterables.append( "C", Iterables.iterable( "A", "B" ) ) ).toString(),
equalTo( "[A, B, C]" ) );
}
@Test
public void testReverse()
{
assertThat( Iterables.reverse( numbers ).toString(), equalTo( "[3, 2, 1]" ) );
assertThat( Iterables.reverse( emptyList() ), equalTo( (Object) emptyList() ) );
}
@Test
public void testMatchesAny()
{
assertThat( Iterables.matchesAny( Specifications.in( "2" ), numbers ), equalTo( true ) );
assertThat( Iterables.matchesAny( Specifications.in( "4" ), numbers ), equalTo( false ) );
}
@Test
public void testMatchesAll()
{
assertThat( Iterables.matchesAll( Specifications.in( "1", "2", "3" ), numbers ), equalTo( true ) );
assertThat( Iterables.matchesAll( Specifications.in( "2", "3", "4" ), numbers ), equalTo( false ) );
}
@Test
public void testFlatten()
{
assertThat( Iterables.toList( Iterables.flatten( numbers, numbers ) ).toString(),
equalTo( "[1, 2, 3, 1, 2, 3]" ) );
Iterable<? extends Number> flatten = Iterables.flatten( numberIntegers, numberLongs );
assertThat( Iterables.toList( flatten ).toString(), equalTo( "[1, 2, 3, 1, 2, 3]" ) );
}
@Test
public void testFlattenIterables()
{
Iterable<List<String>> iterable = Iterables.iterable( numbers, numbers );
assertThat( Iterables.toList( Iterables.flattenIterables( iterable ) ).toString(),
equalTo( "[1, 2, 3, 1, 2, 3]" ) );
}
@Test
public void testMix()
{
assertThat( Iterables.toList( Iterables.mix( Iterables.iterable( "A", "B", "C" ),
Iterables.iterable( "1", "2", "3", "4", "5" ),
Iterables.iterable( "X", "Y", "Z" ) ) ).toString(),
equalTo( "[A, 1, X, B, 2, Y, C, 3, Z, 4, 5]" ) );
}
@Test
public void testMap()
{
assertThat( Iterables.toList( Iterables.map( new Function<String, String>()
{
public String map( String s )
{
return s + s;
}
}, numbers ) ).toString(), equalTo( "[11, 22, 33]" ) );
Iterable<List<String>> numberIterable = Iterables.iterable( numbers, numbers, numbers );
assertThat( Iterables.toList( Iterables.map( new Function<Collection, Integer>()
{
@Override
public Integer map( Collection collection )
{
return collection.size();
}
}, numberIterable ) ).toString(), equalTo( "[3, 3, 3]" ) );
}
@Test
public void testIterableEnumeration()
{
Enumeration<String> enumeration = enumeration( numbers );
assertThat( Iterables.toList( Iterables.iterable( enumeration ) ).toString(),
equalTo( "[1, 2, 3]" ) );
}
@Test
public void testIterableVarArg()
{
assertThat( Iterables.toList( Iterables.iterable( "1", "2", "3" ) ).toString(),
equalTo( "[1, 2, 3]" ) );
}
@Test
public void testCast()
{
Iterable<Long> values = numberLongs;
Iterable<Number> numbers = Iterables.cast( values );
}
@Test
public void testDebug()
{
assertThat( Iterables.first( Iterables.debug( "Filtered number:{0}",
Iterables.filter( Specifications.in( "2" ),
Iterables.debug( "Number:{0}", numbers ) ) ) ),
equalTo( "2" ) );
}
@Test
public void testDebugWithFunctions()
{
Function<String, String> fun = new Function<String, String>()
{
@Override
public String map( String s )
{
return s + ":" + s.length();
}
};
assertThat( Iterables.first( Iterables.debug( "Filtered number:{0}",
Iterables.filter( Specifications.in( "2" ),
Iterables.debug( "Number:{0}", numbers, fun ) ) ) ),
equalTo( "2" ) );
}
@Test
public void testCache()
{
final int[] count = new int[ 1 ];
Iterable<String> b = Iterables.cache( Iterables.filter( Specifications.and( new Specification<String>()
{
@Override
public boolean satisfiedBy( String item )
{
count[ 0] = count[ 0] + 1;
return true;
}
}, Specifications.in( "B" ) ), Iterables.iterable( "A", "B", "C" ) ) );
assertThat( count[ 0], equalTo( 0 ) );
Iterables.toList( b );
assertThat( count[ 0], equalTo( 3 ) );
Iterables.toList( b );
assertThat( count[ 0], equalTo( 3 ) );
}
@Test
public void testSort()
{
assertThat( Iterables.sort( Iterables.reverse( numberLongs ) ).toString(), equalTo( "[1, 2, 3]" ) );
Comparator<Long> inverseLongComparator = new Comparator<Long>()
{
@Override
public int compare( Long left, Long right )
{
return left.compareTo( right ) * -1;
}
};
assertThat( Iterables.sort( inverseLongComparator, numberLongs ).toString(), equalTo( "[3, 2, 1]" ) );
}
}