// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.localstorage;

import java.util.*;

import junit.framework.*;

import org.litesoft.*;

public class LocalStorageTest extends TestCasePlus
{
    public static TestSuite suite()
    {
        return new TestSuite( LocalStorageTest.class );
    }

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

    public static void main( String[] args )
    {
        junit.textui.TestRunner.run( suite() );
    }

    @Override
    protected void setUp()
            throws Exception
    {
        mStorage = new LocalStorageImpl( new Html5LocalStorageTestImpl( 4 ) );
    }

    private LocalStorage mStorage;

    private List<String> keySet()
    {
        List<String> zList = new ArrayList<String>( mStorage.keySet() );
        Collections.sort( zList );
        return zList;
    }

    private List<Map.Entry<String, String>> entrySet()
    {
        List<Map.Entry<String, String>> zList = new ArrayList<Map.Entry<String, String>>( mStorage.entrySet() );
        Collections.sort( zList, new Comparator<Map.Entry<String, String>>()
        {
            @Override
            public int compare( Map.Entry<String, String> o1, Map.Entry<String, String> o2 )
            {
                return o1.getKey().compareTo( o2.getKey() );
            }
        } );
        return zList;
    }

    public void test_StorageOne()
            throws Exception
    {
        assertTrue( mStorage.isEmpty() );
        mStorage.put( "K1", "V1" );
        assertEquals( 1, mStorage.size() );
        assertEquals( "[K1]", mStorage.keySet().toString() );
        assertEquals( "V1", mStorage.get( "K1" ) );
        assertEquals( "[K1=V1]", mStorage.entrySet().toString() );
        assertEquals( "V1", mStorage.remove( "K1" ) );
        assertTrue( mStorage.isEmpty() );

        mStorage.put( "K1", "V1" );
        assertEquals( 1, mStorage.size() );
        assertEquals( "V1", mStorage.get( "K1" ) );
        mStorage.put( "K1", "V1B" );
        assertEquals( 1, mStorage.size() );
        assertEquals( "V1B", mStorage.get( "K1" ) );
        mStorage.clear();
        assertTrue( mStorage.isEmpty() );
    }

    public void test_StorageMany()
            throws Exception
    {
        assertTrue( mStorage.isEmpty() );
        mStorage.put( "K1", "V1" );
        mStorage.put( "K2", "V2" );
        mStorage.put( "K3", "V3" );
        mStorage.put( "K4", "V4" );
        assertEquals( 4, mStorage.size() );
        assertEquals( "[K1, K2, K3, K4]", keySet().toString() );
        assertEquals( "V1", mStorage.get( "K1" ) );
        assertEquals( "[K1=V1, K2=V2, K3=V3, K4=V4]", entrySet().toString() );
        assertEquals( "V1", mStorage.remove( "K1" ) );
        assertEquals( 3, mStorage.size() );
        assertEquals( "[K2=V2, K3=V3, K4=V4]", entrySet().toString() );
        assertEquals( "V2", mStorage.put( "K2", null ) );
        assertEquals( 2, mStorage.size() );
        assertEquals( "[K3=V3, K4=V4]", entrySet().toString() );
        mStorage.clear();
        assertTrue( mStorage.isEmpty() );
    }

    public void test_StorageTooMany()
            throws Exception
    {
        assertTrue( mStorage.isEmpty() );
        mStorage.put( "K1", "V1" );
        mStorage.put( "K2", "V2" );
        mStorage.put( "K3", "V3" );
        mStorage.put( "K4", "V4" );
        assertEquals( 4, mStorage.size() );
        assertEquals( "[K1=V1, K2=V2, K3=V3, K4=V4]", entrySet().toString() );

        try
        {
            mStorage.put( "K5", "V5" );
            fail( "Able to add the 5th entry" );
        }
        catch ( UnsupportedOperationException expected )
        {
            // expected
        }
        assertEquals( 4, mStorage.size() );
        assertEquals( "[K1=V1, K2=V2, K3=V3, K4=V4]", entrySet().toString() );
    }

    @SuppressWarnings({"RedundantCast", "SuspiciousMethodCalls"})
    public void test_StorageNullOrEmpties()
            throws Exception
    {
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.get( (Object) null );
            fail( "Able to get w/ null" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.get( (String) null );
            fail( "Able to get w/ null" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.get( "" );
            fail( "Able to get w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.put( null, "V0" );
            fail( "Able to put w/ null" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.put( "", "V0" );
            fail( "Able to put w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.remove( null );
            fail( "Able to remove w/ null" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.remove( "" );
            fail( "Able to remove w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
    }

    public void test_StorageTrimmed()
            throws Exception
    {
        assertTrue( mStorage.isEmpty() );
        mStorage.put( "   K1 ", "V1" );
        assertEquals( 1, mStorage.size() );
        assertEquals( "[K1]", mStorage.keySet().toString() );
        assertEquals( "V1", mStorage.get( " K1   " ) );
        assertEquals( "[K1=V1]", mStorage.entrySet().toString() );
        assertEquals( "V1", mStorage.remove( " K1 " ) );
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.get( " " );
            fail( "Able to get w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.put( " ", "V0" );
            fail( "Able to put w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
        try
        {
            mStorage.remove( " " );
            fail( "Able to remove w/ empty" );
        }
        catch ( IllegalArgumentException expected )
        {
            // expected
        }
        assertTrue( mStorage.isEmpty() );
    }
}