package org.hamcrest.collection;

import org.hamcrest.AbstractMatcherTest;
import org.hamcrest.Matcher;

import static org.hamcrest.Matchers.lessThan;
import static org.hamcrest.collection.ArrayMatching.hasItemInArray;

public class HasItemInArrayTest extends AbstractMatcherTest {

    
@Override
    
protected Matcher<?> createMatcher() {
        
return hasItemInArray("irrelevant");
    
}

    
public void testMatchesAnArrayThatContainsAnElementMatchingTheGivenMatcher() {
        
assertMatches("should matches array that contains 'a'",
                
hasItemInArray("a"), new String[]{"a", "b", "c"});
    
}

    
public void testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher() {
        
assertDoesNotMatch("should not matches array that doesn't contain 'a'",
                
hasItemInArray("a"), new String[]{"b", "c"});
        
assertDoesNotMatch("should not matches empty array",
                
hasItemInArray("a"), new String[0]);
        
assertMismatchDescription(
              
"mismatches were: [<3> was greater than <2>, <4> was greater than <2>, <5> was greater than <2>]",
              
hasItemInArray(lessThan(2)), new Integer[] {3, 4, 5});
    
}

    
public void testDoesNotMatchNull() {
        
assertDoesNotMatch("should not matches null",
                
hasItemInArray("a"), null);
    
}

    
public void testHasAReadableDescription() {
        
assertDescription("an array containing a value less than <2>", hasItemInArray(lessThan(2)));
    
}

    
// Remaining code no longer compiles, thanks to generics. I think that's a good thing, but
    
// I still need to investigate how this behaves with code that doesn't use generics.
    
// I expect ClassCastExceptions will be thrown.
    
// -Joe.

//
    
public void testDoesNotMatchObjectThatIsNotAnArray() {
//
        
assertDoesNotMatch("should not matches empty list",
//
                
arrayContaining("a"), "not a collection");
//
    
}

//
    
public void testMatchesPrimitiveArrayElements() {
//
        
assertMatches("boolean", arrayContaining(true), new boolean[]{true, false});
//
        
assertDoesNotMatch("boolean", arrayContaining(false), new boolean[]{false});
//
//
        
assertMatches("byte", arrayContaining((byte) 1), new byte[]{1, 2, 3});
//
        
assertDoesNotMatch("byte", arrayContaining((byte) 0), new byte[]{1, 2, 3});
//
//
        
assertMatches("char", arrayContaining('a'), new char[]{'a', 'b', 'c'});
//
        
assertDoesNotMatch("char", arrayContaining('z'), new char[]{'a', 'b', 'c'});
//
//
        
assertMatches("short", arrayContaining((short) 1), new short[]{1, 2, 3});
//
        
assertDoesNotMatch("short", arrayContaining((short) 0), new short[]{1, 2, 3});
//
//
        
assertMatches("int", arrayContaining(1), new int[]{1, 2, 3});
//
        
assertDoesNotMatch("int", arrayContaining(0), new int[]{1, 2, 3});
//
//
        
assertMatches("long", arrayContaining(1L), new long[]{1, 2, 3});
//
        
assertDoesNotMatch("long", arrayContaining(0L), new long[]{1, 2, 3});
//
//
        
assertMatches("float", arrayContaining(1f), new float[]{1f, 2f, 3f});
//
        
assertDoesNotMatch("float", arrayContaining(0f), new float[]{1f, 2f, 3f});
//
//
        
assertMatches("double", arrayContaining(1.0), new double[]{1.0, 2.0, 3.0});
//
        
assertDoesNotMatch("double", arrayContaining(0.0), new double[]{1.0, 2.0, 3.0});
//
    
}

}