Particle_test.cpp

/**
 * DESCRIPTION OF THE CLASS
 *
 * @author David Vojtek
 * @date 2018
 */

#define BOOST_TEST_MODULE Particle_test

#ifdef _WINDOWS
#include <boost/test/included/unit_test.hpp>
#else

#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

#ifndef BOOST_TEST_NO_MAIN
#define BOOST_TEST_NO_MAIN
#endif
#include <turtle/mock.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/test/output_test_stream.hpp>

#endif

#include "../LearningMethods/ParticleSwarm.h"

MOCK_BASE_CLASS( mock_Error, lib4neuro::ErrorFunction)
{
MOCK_METHOD(eval, 1)
MOCK_METHOD(calculate_error_gradient, 3)
MOCK_METHOD(get_parameters, 0)
MOCK_METHOD(get_dataset, 0)
MOCK_METHOD(get_dimension, 0)
};

/**
 * Boost testing suite for testing ParticleSwarm.h
 * TODO
 */
BOOST_AUTO_TEST_SUITE(Particle_test)

BOOST_AUTO_TEST_CASE(Particle_construction_test) {
        std::vector<double> domain_bound{1, 2, 3, 4, 5};
        mock_Error error;
        MOCK_EXPECT(error.get_dimension).once().returns(5);
        MOCK_EXPECT(error.eval).once().returns(0.8);
        BOOST_CHECK_NO_THROW(Particle(&error, &domain_bound));
        mock::verify( error );
}

BOOST_AUTO_TEST_CASE(Particle_get_coordinate_test) {
        std::vector<double> domain_bound{1, 2, 3, 4, 5};
        mock_Error error;

        MOCK_EXPECT(error.get_dimension).returns(5);
        MOCK_EXPECT(error.eval).returns(0.8);

        Particle particle1(&error, &domain_bound);
        Particle particle2(&error, &domain_bound);

        BOOST_CHECK(*particle1.get_coordinate() != *particle2.get_coordinate());
        mock::verify( error );
}

//Random
//TODO
/*
BOOST_AUTO_TEST_CASE(particle_change_coordiante_test) {
    double domain_bound[5] = {1,2,3,4,5};
    Neuron *n1 = new NeuronLinear(1, 1);
    Neuron *n2 = new NeuronLinear(2, 2);
    NeuralNetwork network;
    std::vector<std::pair<std::vector<double>, std::vector<double>>> data_vec;
    std::vector<double> inp, out;

    for (int i = 0; i < 1; i++) {
        inp.push_back(i);
        out.push_back(i + 4);
    }

    data_vec.emplace_back(std::make_pair(inp, out));
    network.add_neuron(n1);
    network.add_neuron(n2);
    network.add_connection_simple(0, 1, 0, 2.5);
    network.randomize_weights();

    std::vector<size_t> net_input_neurons_indices(1);
    std::vector<size_t> net_output_neurons_indices(1);
    net_input_neurons_indices[0] = 0;

    net_output_neurons_indices[0] = 1;

    network.specify_input_neurons(net_input_neurons_indices);
    network.specify_output_neurons(net_output_neurons_indices);



    DataSet dataSet(&data_vec);
    ErrorFunction *error = new MSE(&network, &dataSet);
    Particle particle(error, &domain_bound[0]);
    particle.change_coordinate(1.0, 2.0, 2.0, &domain_bound[1], 1);


    BOOST_CHECK_EQUAL(1.32664, *particle.get_coordinate());
}

BOOST_AUTO_TEST_CASE(particle_optimal_value_test){
    double domain_bound[5] = {1,2,3,4,5};
    Neuron *n1 = new NeuronLinear(1, 1);
    Neuron *n2 = new NeuronLinear(2, 2);
    NeuralNetwork network;
    std::vector<std::pair<std::vector<double>, std::vector<double>>> data_vec;
    std::vector<double> inp, out;

    for (int i = 0; i < 1; i++) {
        inp.push_back(i);
        out.push_back(i + 4);
    }

    data_vec.emplace_back(std::make_pair(inp, out));
    network.add_neuron(n1);
    network.add_neuron(n2);
    network.add_connection_simple(0, 1, 0, 2.5);
    network.randomize_weights();

    std::vector<size_t> net_input_neurons_indices(1);
    std::vector<size_t> net_output_neurons_indices(1);
    net_input_neurons_indices[0] = 0;

    net_output_neurons_indices[0] = 1;

    network.specify_input_neurons(net_input_neurons_indices);
    network.specify_output_neurons(net_output_neurons_indices);

    DataSet dataSet(&data_vec);
    ErrorFunction *error = new MSE(&network, &dataSet);
    Particle particle(error, &domain_bound[0]);
    BOOST_CHECK_CLOSE(1.789708839, particle.get_optimal_value(), 0.00001 );
}
*/


BOOST_AUTO_TEST_SUITE_END()