TestCActionCollectionList.java

Go to the documentation of this file.

/*
 * @cond LICENSE
 * ######################################################################################
 * # LGPL License                                                                       #
 * #                                                                                    #
 * # This file is part of the LightJason AgentSpeak(L++)                                #
 * # Copyright (c) 2015-19, LightJason (info@lightjason.org)                            #
 * # This program is free software: you can redistribute it and/or modify               #
 * # it under the terms of the GNU Lesser General Public License as                     #
 * # published by the Free Software Foundation, either version 3 of the                 #
 * # License, or (at your option) any later version.                                    #
 * #                                                                                    #
 * # This program is distributed in the hope that it will be useful,                    #
 * # but WITHOUT ANY WARRANTY; without even the implied warranty of                     #
 * # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                      #
 * # GNU Lesser General Public License for more details.                                #
 * #                                                                                    #
 * # You should have received a copy of the GNU Lesser General Public License           #
 * # along with this program. If not, see http://www.gnu.org/licenses/                  #
 * ######################################################################################
 * @endcond
 */

package org.lightjason.agentspeak.action.builtin;

import com.google.common.collect.Lists;
import org.apache.commons.lang3.RandomStringUtils;
import org.junit.Assert;
import org.junit.Test;
import org.lightjason.agentspeak.IBaseTest;
import org.lightjason.agentspeak.action.builtin.collection.list.CAdd;
import org.lightjason.agentspeak.action.builtin.collection.list.CComplement;
import org.lightjason.agentspeak.action.builtin.collection.list.CCreate;
import org.lightjason.agentspeak.action.builtin.collection.list.CFlat;
import org.lightjason.agentspeak.action.builtin.collection.list.CFlatConcat;
import org.lightjason.agentspeak.action.builtin.collection.list.CGet;
import org.lightjason.agentspeak.action.builtin.collection.list.CRange;
import org.lightjason.agentspeak.action.builtin.collection.list.CRemove;
import org.lightjason.agentspeak.action.builtin.collection.list.CReverse;
import org.lightjason.agentspeak.action.builtin.collection.list.CSet;
import org.lightjason.agentspeak.action.builtin.collection.list.CSubList;
import org.lightjason.agentspeak.action.builtin.collection.list.CUnique;
import org.lightjason.agentspeak.action.builtin.collection.list.CZip;
import org.lightjason.agentspeak.language.CCommon;
import org.lightjason.agentspeak.language.CRawTerm;
import org.lightjason.agentspeak.language.ITerm;
import org.lightjason.agentspeak.language.execution.IContext;

import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public final class TestCActionCollectionList extends IBaseTest
{

    @Test
    public final void createempty()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CCreate().execute(
            false, IContext.EMPTYPLAN,
            Collections.emptyList(),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertTrue( l_return.get( 0 ).raw() instanceof List<?> );
        Assert.assertTrue( l_return.get( 0 ).<List<?>>raw().isEmpty() );
    }


    @Test
    public final void createemptysynchronize()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CCreate().execute(
            true, IContext.EMPTYPLAN,
            Collections.emptyList(),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertTrue( l_return.get( 0 ).raw() instanceof List<?> );
        Assert.assertTrue( l_return.get( 0 ).<List<?>>raw().isEmpty() );
        Assert.assertEquals( l_return.get( 0 ).raw().getClass(), Collections.synchronizedList( Collections.emptyList() ).getClass() );
    }


    @Test
    public final void create()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CCreate().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( "a", 1, "b", true ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertTrue( l_return.get( 0 ).raw() instanceof List<?> );
        Assert.assertEquals( l_return.get( 0 ).<List<?>>raw().size(), 4 );

        final List<?> l_list = l_return.get( 0 ).raw();

        Assert.assertEquals( l_list.get( 0 ), "a" );
        Assert.assertEquals( l_list.get( 1 ), 1 );
        Assert.assertEquals( l_list.get( 2 ), "b" );
        Assert.assertEquals( l_list.get( 3 ), true );
    }


    @Test
    public final void complement()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CComplement().execute(
            false, IContext.EMPTYPLAN,
            Stream.of(
                CRawTerm.from( Stream.of( "a", "b", 1, 2 ).collect( Collectors.toList() ) ),
                CRawTerm.from( Stream.of( "x", "y", 4, "a", 5, 1 ).collect( Collectors.toList() ) )
            ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertTrue( CCommon.rawvalueAssignableTo( l_return.get( 0 ), List.class ) );
        Assert.assertEquals( l_return.get( 0 ).<List<?>>raw().get( 0 ), "b" );
        Assert.assertEquals( l_return.get( 0 ).<List<?>>raw().get( 1 ), 2 );
    }


    @Test
    public final void get()
    {
        final List<ITerm> l_return = new ArrayList<>();
        final List<?> l_list = Stream.of( "a", 1, "b", true, "foobar", 56.78 ).collect( Collectors.toList() );

        new CGet().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( CRawTerm.from( l_list ), CRawTerm.from( 1 ), CRawTerm.from( 4 ), CRawTerm.from( 5 ) ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 3 );
        Assert.assertEquals( l_return.get( 0 ).<Number>raw(), 1 );
        Assert.assertEquals( l_return.get( 1 ).raw(), "foobar" );
        Assert.assertEquals( l_return.get( 2 ).<Number>raw(), 56.78 );
    }

    @Test
    public final void reverse()
    {
        final List<ITerm> l_return = new ArrayList<>();
        final List<?> l_list = IntStream.range( 0, 10 ).mapToObj( i -> Math.random() ).collect( Collectors.toList() );

        new CReverse().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( CRawTerm.from( l_list ) ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertArrayEquals( l_return.stream().map( ITerm::raw ).toArray(), Lists.reverse( l_list ).toArray() );
    }


    @Test
    public final void remove()
    {
        final Random l_random = new Random();

        final List<?> l_elements = IntStream.range( 0, l_random.nextInt( 100 ) + 1 ).map( i -> l_random.nextInt() ).boxed().collect( Collectors.toList() );
        final List<?> l_list = new ArrayList<>( l_elements );
        final List<Integer> l_index = new ArrayList<>(
                                        IntStream.range( 0, l_list.size() / 3 )
                                                 .map( i ->  l_random.nextInt( l_list.size() ) )
                                                 .boxed()
                                                 .collect( Collectors.toSet() )
                                      );

        final int l_startsize = l_list.size();
        final List<ITerm> l_return = new ArrayList<>();

        new CRemove().execute(
            false, IContext.EMPTYPLAN,
            Stream.concat(
                Stream.of( l_list ),
                l_index.stream()
            ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_startsize, l_list.size() + l_index.size() );
        Assert.assertTrue(
            l_index.parallelStream()
                   .map( l_elements::get )
                   .allMatch( i -> l_return.parallelStream().map( ITerm::<Number>raw ).anyMatch( j -> j.equals( i ) ) )
        );
    }


    @Test
    public final void set()
    {
        final List<?> l_list1 = Stream.of( "" ).collect( Collectors.toList() );
        final List<?> l_list2 = Stream.of( "abc", 123, true ).collect( Collectors.toList() );

        new CSet().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( CRawTerm.from( 0 ), CRawTerm.from( "xxx" ), CRawTerm.from( l_list1 ), CRawTerm.from( l_list2 ) ).collect( Collectors.toList() ),
            Collections.emptyList()
        );

        Assert.assertEquals( l_list1.size(), 1 );
        Assert.assertEquals( l_list1.get( 0 ), "xxx" );

        Assert.assertEquals( l_list2.size(), 3 );
        Assert.assertEquals( l_list2.get( 0 ), "xxx" );
    }


    @Test
    public final void add()
    {
        final List<?> l_list = new ArrayList<>();

        new CAdd().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( CRawTerm.from( "xyz" ), CRawTerm.from( l_list ) ).collect( Collectors.toList() ),
            Collections.emptyList()
        );

        Assert.assertEquals( l_list.size(), 1 );
        Assert.assertEquals( l_list.get( 0 ), "xyz" );
    }


    @Test
    public final void rangeerror()
    {
        Assert.assertFalse(
            new CRange().execute(
                false, IContext.EMPTYPLAN,
                Stream.of().map( CRawTerm::from ).collect( Collectors.toList() ),
                Collections.emptyList()
            ).value()
        );
    }


    @Test
    public final void range()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CRange().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( 0, 5, 7, 9 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        new CRange().execute(
            true, IContext.EMPTYPLAN,
            Stream.of( 1, 7 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 3 );

        Assert.assertArrayEquals( l_return.get( 0 ).<List<?>>raw().toArray(), IntStream.range( 0, 5 ).boxed().toArray() );
        Assert.assertArrayEquals( l_return.get( 1 ).<List<?>>raw().toArray(), IntStream.range( 7, 9 ).boxed().toArray() );

        Assert.assertArrayEquals( l_return.get( 2 ).<List<?>>raw().toArray(), IntStream.range( 1, 7 ).boxed().toArray() );
        Assert.assertEquals( l_return.get( 2 ).<List<?>>raw().getClass(), Collections.synchronizedList( Collections.emptyList() ).getClass() );
    }

    @Test
    public final void sublisterror()
    {
        Assert.assertFalse(
            new CSubList().execute(
                false, IContext.EMPTYPLAN,
                Stream.of( new ArrayList<>() ).map( CRawTerm::from ).collect( Collectors.toList() ),
                Collections.emptyList()
            ).value()
        );
    }

    @Test
    public final void sublist()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CSubList().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( Stream.of( "ax", "bx", "c", 1, 2, 3 ).collect( Collectors.toList() ), 0, 2, 2, 4 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        new CSubList().execute(
            true, IContext.EMPTYPLAN,
            Stream.of( Stream.of( 8, 9, 10 ).collect( Collectors.toList() ), 1, 2 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 3 );

        Assert.assertArrayEquals( l_return.get( 0 ).<List<?>>raw().toArray(), Stream.of( "ax", "bx" ).toArray() );
        Assert.assertArrayEquals( l_return.get( 1 ).<List<?>>raw().toArray(), Stream.of( "c", 1 ).toArray() );
        Assert.assertArrayEquals( l_return.get( 2 ).<List<?>>raw().toArray(), Stream.of( 9 ).toArray() );
    }


    @Test
    public final void flat()
    {
        final Random l_random = new Random();

        final List<ITerm> l_return = new ArrayList<>();
        final List<?> l_list = IntStream.range( 0, l_random.nextInt( 100 ) + 1 )
                                        .mapToObj( i -> RandomStringUtils.random( l_random.nextInt( 100 ) + 1 ) )
                                        .collect( Collectors.toList() );

        new CFlat().execute(
            false, IContext.EMPTYPLAN,
            l_list.stream().map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), l_list.size() );
        Assert.assertArrayEquals( l_return.stream().map( ITerm::raw ).toArray(), l_list.toArray() );
    }


    @Test
    public final void flatconcat()
    {
        final Random l_random = new Random();

        final List<ITerm> l_return = new ArrayList<>();
        final List<?> l_list = IntStream.range( 0, l_random.nextInt( 100 ) + 1 )
                                        .mapToObj( i -> RandomStringUtils.random( l_random.nextInt( 100 ) + 1 ) )
                                        .collect( Collectors.toList() );

        new CFlatConcat().execute(
            false, IContext.EMPTYPLAN,
            l_list.stream().map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertArrayEquals( l_return.get( 0 ).<List<?>>raw().toArray(), l_list.toArray() );
    }


    @Test
    public final void ziperror()
    {
        Assert.assertFalse(
            new CZip().execute(
                false, IContext.EMPTYPLAN,
                Stream.of( "" ).map( CRawTerm::from ).collect( Collectors.toList() ),
                Collections.emptyList()
            ).value()
        );
    }


    @Test
    public final void zip()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CZip().execute(
            false, IContext.EMPTYPLAN,
            IntStream.range( 0, 6 ).boxed().map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertEquals( l_return.get( 0 ).<List<?>>raw().size(), 3 );

        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 0 ).getKey(), 0 );
        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 0 ).getValue(), 3 );

        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 1 ).getKey(), 1 );
        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 1 ).getValue(), 4 );

        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 2 ).getKey(), 2 );
        Assert.assertEquals( l_return.get( 0 ).<List<AbstractMap.SimpleEntry<?, ?>>>raw().get( 2 ).getValue(), 5 );



        new CZip().execute(
            true, IContext.EMPTYPLAN,
            Stream.of( 1, 2 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 2 );
        Assert.assertEquals( l_return.get( 1 ).<List<?>>raw().getClass(), Collections.synchronizedList( Collections.emptyList() ).getClass() );

    }


    @Test
    public final void unique()
    {
        final List<ITerm> l_return = new ArrayList<>();

        new CUnique().execute(
            false, IContext.EMPTYPLAN,
            Stream.of( 1, 1, 3, 4, 5, 5 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 1 );
        Assert.assertEquals( l_return.get( 0 ).<List<?>>raw().size(), 4 );
        Assert.assertArrayEquals( l_return.get( 0 ).<List<?>>raw().toArray(), Stream.of( 1, 3, 4, 5 ).toArray() );

        new CUnique().execute(
            true, IContext.EMPTYPLAN,
            Stream.of( 1 ).map( CRawTerm::from ).collect( Collectors.toList() ),
            l_return
        );

        Assert.assertEquals( l_return.size(), 2 );
        Assert.assertEquals( l_return.get( 1 ).<List<?>>raw().getClass(), Collections.synchronizedList( Collections.emptyList() ).getClass() );
    }

}