// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft;

import java.io.*;
import java.util.*;

import junit.framework.*;

import org.litesoft.core.typeutils.Objects;
import org.litesoft.core.typeutils.*;

@SuppressWarnings("UnusedDeclaration")
public class TestCasePlus extends TestCase
{
    public TestCasePlus()
    {
    }

    public TestCasePlus( String name )
    {
        super( name );
    }

    @SuppressWarnings({"ResultOfMethodCallIgnored"})
    public static void removeTempDirectoryHeirarchy( File pDir )
    {
        File[] zFiles = pDir.listFiles();
        if ( zFiles != null )
        {
            for ( int i = zFiles.length - 1; i >= 0; i-- )
            {
                removeTempDirectoryHeirarchy( zFiles[i] );
            }
        }
        pDir.delete();
    }

    public static void assertInstanceOf( Class pClass, Object pObject )
    {
        if ( !pClass.isAssignableFrom( pObject.getClass() ) )
        {
            Assert.fail( "Expected " + pClass.getName() + " (or subclass), but was " + pObject.getClass().getName() );
        }
    }

    public static void assertInstanceOf( String pFailureComment, Class pClass, Object pObject )
    {
        if ( !pClass.isAssignableFrom( pObject.getClass() ) )
        {
            Assert.fail( pFailureComment + " expected " + pClass.getName() + " (or subclass), but was " + pObject.getClass().getName() );
        }
    }

    public static void assertArraysEquals( String pMessage, Object[] pActual, Object... pExpected )
    {
        assertObjectArraysEquals( pMessage, pExpected, pActual );
    }

    public static void assertArraysEquals( Object[] pActual, Object... pExpected )
    {
        assertArraysEquals( null, pActual, pExpected );
    }

    public static void assertArraysEquals( String pMessage, String[] pActual, String... pExpected )
    {
        assertObjectArraysEquals( pMessage, pExpected, pActual );
    }

    public static void assertArraysEquals( String[] pActual, String... pExpected )
    {
        assertArraysEquals( null, pActual, pExpected );
    }

    public static void assertLinesAreEqual( String pActual, String pExpectedLine1, String... pExpectedRestLines )
    {
        StringBuilder zExpected = new StringBuilder( pExpectedLine1 ).append( '\n' );
        for ( String zLine : pExpectedRestLines )
        {
            zExpected.append( zLine ).append( '\n' );
        }
        assertEquals( zExpected.toString(), pActual );
    }

    public static void assertArraysAreEqual( String[] pActual, String... pExpected )
    {
        assertArraysAreEqual( "Array ", pActual, pExpected );
    }

    public static void assertArraysAreEqual( String pMessagePrefix, String[] pActual, String... pExpected )
    {
        assertEquals( pMessagePrefix + "Lengths", pExpected.length, pActual.length );
        for ( int i = 0; i < pActual.length; i++ )
        {
            assertEquals( pMessagePrefix + "Entry: " + i, pExpected[i], pActual[i] );
        }
    }

    public static void assertContains( String message, String searchIn, String expectedSubString )
    {
        if ( !searchIn.contains( expectedSubString ) )
        {
            String formatted = "";
            if ( message != null )
            {
                formatted = message + " ";
            }
            Assert.fail( formatted + "'" + expectedSubString + "' not found in: <" + searchIn + ">" );
        }
    }

    public static void assertContains( String searchIn, String expectedSubString )
    {
        assertContains( null, searchIn, expectedSubString );
    }

    public static void assertEquals( String message, String expected, String actual )
    {
        if ( expected != null || actual != null )
        {
            if ( expected == null || !expected.equals( actual ) )
            {
                String formatted = "";
                if ( message != null )
                {
                    formatted = "\n  " + message;
                }
                throw new AssertionFailedError( formatted + "\n    expected:<" + expected + ">" + "\n     but was:<" + actual + ">" );
            }
        }
    }

    public static void assertEquals( String expected, String actual )
    {
        assertEquals( null, expected, actual );
    }

    public static void assertEqualsIgnorecase( String message, String expected, String actual )
    {
        if ( expected != null || actual != null )
        {
            if ( expected == null || !expected.equalsIgnoreCase( actual ) )
            {
                assertEquals( message, expected, actual );
            }
        }
    }

    public static void assertEqualsIgnorecase( String expected, String actual )
    {
        assertEqualsIgnorecase( null, expected, actual );
    }

    /**
     * Asserts that a condition is true. If it isn't it throws
     * an AssertionFailedError with the given message.
     */
    public static void assertFalse( String message, boolean condition )
    {
        if ( condition )
        {
            Assert.fail( message );
        }
    }

    /**
     * Asserts that a condition is true. If it isn't it throws
     * an AssertionFailedError.
     */
    public static void assertFalse( boolean condition )
    {
        assertFalse( null, condition );
    }

    /**
     * Asserts that two objects are equal. If they are not
     * an AssertionFailedError is thrown.
     */
    public static void assertNotEquals( String message, Object notExpected, Object actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two objects are equal. If they are not
     * an AssertionFailedError is thrown.
     */
    public static void assertNotEquals( Object notExpected, Object actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two longs are equal.
     */
    public static void assertNotEquals( String message, long notExpected, long actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two longs are equal.
     */
    public static void assertNotEquals( long notExpected, long actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two booleans are equal.
     */
    public static void assertNotEquals( String message, boolean notExpected, boolean actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two booleans are equal.
     */
    public static void assertNotEquals( boolean notExpected, boolean actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two bytes are equal.
     */
    public static void assertNotEquals( String message, byte notExpected, byte actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two bytes are equal.
     */
    public static void assertNotEquals( byte notExpected, byte actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two chars are equal.
     */
    public static void assertNotEquals( String message, char notExpected, char actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two chars are equal.
     */
    public static void assertNotEquals( char notExpected, char actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two shorts are equal.
     */
    public static void assertNotEquals( String message, short notExpected, short actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two shorts are equal.
     */
    public static void assertNotEquals( short notExpected, short actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    /**
     * Asserts that two ints are equal.
     */
    public static void assertNotEquals( String message, int notExpected, int actual )
    {
        assertObjectsNotEquals( message, notExpected, actual );
    }

    /**
     * Asserts that two ints are equal.
     */
    public static void assertNotEquals( int notExpected, int actual )
    {
        assertNotEquals( null, notExpected, actual );
    }

    public static void assertAreEqual( String pFailureLabel, String[] pExpectedLines, String[] pActualLines )
    {
        if ( !Arrays.equals( pExpectedLines, pActualLines ) )
        {
            failNotAreEqual( pFailureLabel, Strings.combineAsLines( pExpectedLines ), Strings.combineAsLines( pActualLines ) );
        }
    }

    public static void assertAreEqual( String pFailureLabel, String[] pExpectedLines, String pActual )
    {
        String expected = Strings.combineAsLines( pExpectedLines );
        if ( !Objects.areEqual( pActual, expected ) )
        {
            failNotAreEqual( pFailureLabel, expected, pActual );
        }
    }

    /**
     * Asserts that an object is null.
     */
    public static void assertNull( Object object )
    {
        assertNull( null, object );
    }

    /**
     * Asserts that an object is null.  If it is not
     * an AssertionFailedError is thrown with the given message.
     */
    public static void assertNull( String pFailureLabel, Object object )
    {
        if ( object != null )
        {
            String formatted = "";
            if ( pFailureLabel != null )
            {
                formatted = pFailureLabel + " ";
            }
            Assert.fail( formatted + "expected: null but was:<" + object + ">" );
        }
    }

    public static void assertToString( Object pObject, String... pExpectedLines )
    {
        assertToString( null, pObject, pExpectedLines );
    }

    public static void assertToString( String pFailureLabel, Object pObject, String... pExpectedLines )
    {
        assertEquals( pFailureLabel, Strings.combine( '\n', pExpectedLines ), pObject.toString() );
    }

    private static void markActual( String pExpected, StringBuilder pActual )
    {
        int expectedLen = pExpected.length();
        int actualLen = pActual.length();
        int maxLength = Math.min( expectedLen, actualLen );
        int at = 0;
        for (; at < maxLength; at++ )
        {
            if ( pExpected.charAt( at ) != pActual.charAt( at ) )
            {
                pActual.insert( at, "<***Difference starts here***>" );
                return;
            }
        }
        if ( actualLen > maxLength )
        {
            pActual.insert( at, "<***Additional starts here***>" );
            return;
        }
        pActual.append( "<***More Expected starts here***>" );
    }

    protected static String format( String message, Object[] expected, Object[] actual )
    {
        String formatted = "";
        if ( message != null )
        {
            formatted = message + " ";
        }
        return formatted + "expected:<" + toString( expected ) + "> but was:<" + toString( actual ) + ">";
    }

    protected static String toString( Object[] objects )
    {
        return (objects == null) ? "null" : Arrays.asList( objects ).toString();
    }

    protected static void failArraysNotEquals( String message, Object[] expected, Object[] actual )
    {
        Assert.fail( format( message, expected, actual ) );
    }

    protected static void failNotAreEqual( String pFailureLabel, String pExpected, String pActual )
    {
        StringBuilder actual = new StringBuilder( pActual );
        markActual( pExpected, actual );

        System.out.println( pFailureLabel + "\n" + actual );
        Assert.fail( pFailureLabel );
    }

    private static void assertObjectsNotEquals( String message, Object notExpected, Object actual )
    {
        if ( (notExpected == actual) || (notExpected != null && notExpected.equals( actual )) )
        {
            String formatted = "";
            if ( message != null )
            {
                formatted = message + " ";
            }
            Assert.fail( formatted + "Is Equal to NotExpected: <" + actual + ">" );
        }
    }

    private static void assertObjectArraysEquals( String message, Object[] pExpected, Object[] pActual )
    {
        if ( !Arrays.equals( pExpected, pActual ) )
        {
            throw new ComparisonFailure( message, toString( pExpected ), toString( pActual ) );
        }
    }
}