#include "../Tests.h"


namespace OverlappingNamespace {
enum ColorsEnum
{
    white,
    black,
    red,
    blue,
    green,
};

class DLL_API InBaseLib{};
} // namespace OverlappingNamespace


class DLL_API Base
{
public:
    Base(int i);
    Base();
    int parent();

private:
    int b;
};

class DLL_API Base2 : public Base
{
public:
    Base2(int i);
    Base2();
    virtual void parent(int i);
};

class DLL_API Abstract
{
public:
    virtual void abstractFunction() = 0;
};

template <typename T>
class TemplateClass
{
public:
    T getField() const;
    void setField(const T& value);

private:
    union
    {
        int i;
        float f;
    };
    T t;
};

template <typename T>
T TemplateClass<T>::getField() const
{
    return t;
}

template <typename T>
void TemplateClass<T>::setField(const T& value)
{
    t = value;
}

template <typename T>
class IndependentFields
{
public:
    class Nested
    {
    private:
        T field;
    };

private:
    union
    {
        int i;
        float* f;
    };
};

template <typename T>
class DependentFields
{
public:
    class Nested
    {
    };
    Nested useDependentPointer(const T* t);
    const T& constField() const;

private:
    T* t = new T;
    Nested nested;
};

template <typename T>
const T& DependentFields<T>::constField() const
{
    return *t;
}

template <typename T>
typename DependentFields<T>::Nested DependentFields<T>::useDependentPointer(const T* t)
{
    return Nested();
}

class DLL_API HasVirtualInCore
{
public:
    HasVirtualInCore();
    HasVirtualInCore(TemplateClass<HasVirtualInCore> t);
    virtual int virtualInCore(int parameter);
};

class DLL_API DerivedFromSecondaryBaseInDependency;
typedef DerivedFromSecondaryBaseInDependency RenameDerivedBeforeBase;

class DLL_API SecondaryBase
{
public:
    void function();
};