xfarrow
/
lasd
mirror of https://github.com/xfarrow/lasd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Library 2 

Added template
This commit is contained in:
Alessandro Ferro 2021-04-10 13:34:50 +02:00
parent d68ff24f42
commit 2941c1d298
36 changed files with 2799 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
librerie/Ferro-Alessandro-N86002853(Esercizio1).zip
View File

Binary file not shown.

BIN
librerie/exercise2/Exercise2.pdf Executable file
View File

Binary file not shown.

8
librerie/exercise2/build.sh Executable file
View File

@ -0,0 +1,8 @@
#! /bin/bash
g++ -O3 -o main \
zlasdtest/exercise1/simpletest.cpp zlasdtest/exercise1/fulltest.cpp \
zlasdtest/exercise2/simpletest.cpp zlasdtest/exercise2/fulltest.cpp \
zlasdtest/container/container.cpp \
zlasdtest/test.cpp main.cpp

10
librerie/exercise2/container/container.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

318
librerie/exercise2/container/container.hpp Executable file
View File

@ -0,0 +1,318 @@
#ifndef CONTAINER_HPP
#define CONTAINER_HPP
/* ************************************************************************** */
#include <stdexcept>
#include <functional>
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
class Container {
private:
// ...
protected:
// ...
public:
// Destructor
// ~Container() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// type Empty() specifiers; // (concrete function should not throw exceptions)
// type Size() specifiers; // (concrete function should not throw exceptions)
// type Clear() specifiers;
};
/* ************************************************************************** */
template <typename Data>
class LinearContainer { // Must extend Container
private:
// ...
protected:
// ...
public:
// Destructor
// ~LinearContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// type Front() specifiers; // (concrete function must throw std::length_error when empty)
// type Back() specifiers; // (concrete function must throw std::length_error when empty)
// type operator[](argument) specifiers; // (concrete function must throw std::out_of_range when out of range)
};
/* ************************************************************************** */
template <typename Data>
class TestableContainer { // Must extend Container
private:
// ...
protected:
// ...
public:
// Destructor
// ~TestableContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// type Exists(argument) specifiers; // (concrete function should not throw exceptions)
};
/* ************************************************************************** */
template <typename Data>
class MappableContainer { // Must extend Container
private:
// ...
protected:
// ...
public:
// Destructor
// ~MappableContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// typedef std::function<void(Data&, void*)> MapFunctor;
// type MapPreOrder(arguments) specifiers;
// type MapPostOrder(arguments) specifiers;
};
/* ************************************************************************** */
template <typename Data>
class FoldableContainer { // Must extend TestableContainer
private:
// ...
protected:
// ...
public:
// Destructor
// ~FoldableContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// typedef std::function<void(const Data&, const void*, void*) noexcept> FoldFunctor;
// type FoldPreOrder(arguments) specifiers;
// type FoldPostOrder(arguments) specifiers;
// type Exists(argument) specifiers; // Override TestableContainer member
};
/* ************************************************************************** */
template <typename Data>
class BreadthMappableContainer { // Must extend MappableContainer
private:
// ...
protected:
// ...
public:
// Destructor
// ~BreadthMappableContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// using typename MappableContainer<Data>::MapFunctor;
// type MapBreadth(arguments) specifiers;
};
/* ************************************************************************** */
template <typename Data>
class BreadthFoldableContainer { // Must extend FoldableContainer
private:
// ...
protected:
// ...
public:
// Destructor
// ~BreadthFoldableContainer() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// using typename FoldableContainer<Data>::FoldFunctor;
// type FoldBreadth(arguments) specifiers;
};
/* ************************************************************************** */
}
#include "container.cpp"
#endif

10
librerie/exercise2/list/list.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

169
librerie/exercise2/list/list.hpp Executable file
View File

@ -0,0 +1,169 @@
#ifndef LIST_HPP
#define LIST_HPP
/* ************************************************************************** */
#include "../container/container.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class List { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
private:
// ...
protected:
// using LinearContainer<Data>::???;
struct Node
{
// Data
// ...
/* ********************************************************************** */
// Specific constructors
// ...
/* ********************************************************************** */
// Copy constructor
// ...
// Move constructor
// ...
/* ********************************************************************** */
// Destructor
// ...
/* ********************************************************************** */
// Comparison operators
// ...
/* ********************************************************************** */
// Specific member functions
// ...
};
// ...
public:
// Default constructor
// List() specifiers;
/* ************************************************************************ */
// Specific constructor
// List(argument) specifiers; // A list obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// List(argument) specifiers;
// Move constructor
// List(argument) specifiers;
/* ************************************************************************ */
// Destructor
// ~List() specifiers;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument) specifiers;
// Move assignment
// type operator=(argument) specifiers;
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions
// type InsertAtFront(argument) specifier; // Copy of the value
// type InsertAtFront(argument) specifier; // Move of the value
// type RemoveFromFront() specifier; // (must throw std::length_error when empty)
// type FrontNRemove() specifier; // (must throw std::length_error when empty)
// type InsertAtBack(argument) specifier; // Copy of the value
// type InsertAtBack(argument) specifier; // Move of the value
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Clear() specifiers; // Override Container member
/* ************************************************************************ */
// Specific member functions (inherited from LinearContainer)
// type Front() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
// type Back() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
// type operator[](argument) specifiers; // Override LinearContainer member (must throw std::out_of_range when out of range)
/* ************************************************************************ */
// Specific member functions (inherited from MappableContainer)
// using typename MappableContainer<Data>::MapFunctor;
// type MapPreOrder(arguments) specifiers; // Override MappableContainer member
// type MapPostOrder(arguments) specifiers; // Override MappableContainer member
/* ************************************************************************ */
// Specific member functions (inherited from FoldableContainer)
// using typename FoldableContainer<Data>::FoldFunctor;
// type FoldPreOrder(arguments) specifiers; // Override FoldableContainer member
// type FoldPostOrder(arguments) specifiers; // Override FoldableContainer member
protected:
// Auxiliary member functions (for MappableContainer)
// type MapPreOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
// type MapPostOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
/* ************************************************************************ */
// Auxiliary member functions (for FoldableContainer)
// type FoldPreOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
// type FoldPostOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
};
/* ************************************************************************** */
}
#include "list.cpp"
#endif

16
librerie/exercise2/main.cpp Executable file
View File

@ -0,0 +1,16 @@
#include "zlasdtest/test.hpp"
#include "zmytest/test.hpp"
/* ************************************************************************** */
#include <iostream>
/* ************************************************************************** */
int main() {
std::cout << "Lasd Libraries 2020" << std::endl;
lasdtest(); // To call in the menu of your library test!
return 0;
}

10
librerie/exercise2/queue/lst/queuelst.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

90
librerie/exercise2/queue/lst/queuelst.hpp Executable file
View File

@ -0,0 +1,90 @@
#ifndef QUEUELST_HPP
#define QUEUELST_HPP
/* ************************************************************************** */
#include "../queue.hpp"
#include "../../list/list.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class QueueLst { // Must extend Queue<Data> and List<Data>
private:
// ...
protected:
// using List<Data>::???;
// ...
public:
// Default constructor
// QueueLst() specifier;
/* ************************************************************************ */
// Specific constructor
// QueueLst(argument) specifiers; // A queue obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// QueueLst(argument);
// Move constructor
// QueueLst(argument);
/* ************************************************************************ */
// Destructor
// ~QueueLst() specifier;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument);
// Move assignment
// type operator=(argument);
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions (inherited from Queue)
// type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
// type Enqueue(argument) specifiers; // Override Queue member (move of the value)
// type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
// type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
// type HeadNDequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Clear() specifiers; // Override Container member
};
/* ************************************************************************** */
}
#include "queuelst.cpp"
#endif

61
librerie/exercise2/queue/queue.hpp Executable file
View File

@ -0,0 +1,61 @@
#ifndef QUEUE_HPP
#define QUEUE_HPP
/* ************************************************************************** */
#include "../container/container.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class Queue { // Must extend Container
private:
// ...
protected:
// ...
public:
// Destructor
// ~Queue() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// type Enqueue(argument) specifiers; // Copy of the value
// type Enqueue(argument) specifiers; // Move of the value
// type Head() specifiers; // (concrete function must throw std::length_error when empty)
// type Dequeue() specifiers; // (concrete function must throw std::length_error when empty)
// type HeadNDequeue() specifiers; // (concrete function must throw std::length_error when empty)
};
/* ************************************************************************** */
}
#endif

10
librerie/exercise2/queue/vec/queuevec.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

102
librerie/exercise2/queue/vec/queuevec.hpp Executable file
View File

@ -0,0 +1,102 @@
#ifndef QUEUEVEC_HPP
#define QUEUEVEC_HPP
/* ************************************************************************** */
#include "../queue.hpp"
#include "../../vector/vector.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class QueueVec { // Must extend Queue<Data> and Vector<Data>
private:
// ...
protected:
// using Vector<Data>::???;
// ...
public:
// Default constructor
// QueueVec() specifier;
/* ************************************************************************ */
// Specific constructor
// QueueVec(argument) specifiers; // A queue obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// QueueVec(argument);
// Move constructor
// QueueVec(argument);
/* ************************************************************************ */
// Destructor
// ~QueueVec() specifier;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument);
// Move assignment
// type operator=(argument);
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions (inherited from Queue)
// type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
// type Enqueue(argument) specifiers; // Override Queue member (move of the value)
// type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
// type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
// type HeadNDequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Empty() specifiers; // Override Container member
// type Size() specifiers; // Override Container member
// type Clear() specifiers; // Override Container member
protected:
// Auxiliary member functions
// type Expand() specifiers;
// type Reduce() specifiers;
// type SwapVectors(arguments) specifiers;
};
/* ************************************************************************** */
}
#include "queuevec.cpp"
#endif

10
librerie/exercise2/stack/lst/stacklst.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

90
librerie/exercise2/stack/lst/stacklst.hpp Executable file
View File

@ -0,0 +1,90 @@
#ifndef STACKLST_HPP
#define STACKLST_HPP
/* ************************************************************************** */
#include "../stack.hpp"
#include "../../list/list.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class StackLst { // Must extend Stack<Data> and List<Data>
private:
// ...
protected:
// using List<Data>::???;
// ...
public:
// Default constructor
// StackLst() specifier;
/* ************************************************************************ */
// Specific constructor
// StackLst(argument) specifiers; // A stack obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// StackLst(argument);
// Move constructor
// StackLst(argument);
/* ************************************************************************ */
// Destructor
// ~StackLst() specifier;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument);
// Move assignment
// type operator=(argument);
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions (inherited from Stack)
// type Push(argument) specifiers; // Override Stack member (copy of the value)
// type Push(argument) specifiers; // Override Stack member (move of the value)
// type Top() specifiers; // Override Stack member (must throw std::length_error when empty)
// type Pop() specifiers; // Override Stack member (must throw std::length_error when empty)
// type TopNPop() specifiers; // Override Stack member (must throw std::length_error when empty)
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Clear() specifiers; // Override Container member
};
/* ************************************************************************** */
}
#include "stacklst.cpp"
#endif

61
librerie/exercise2/stack/stack.hpp Executable file
View File

@ -0,0 +1,61 @@
#ifndef STACK_HPP
#define STACK_HPP
/* ************************************************************************** */
#include "../container/container.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class Stack { // Must extend Container
private:
// ...
protected:
// ...
public:
// Destructor
// ~Stack() specifiers
/* ************************************************************************ */
// Copy assignment
// type operator=(argument); // Copy assignment of abstract types should not be possible.
// Move assignment
// type operator=(argument); // Move assignment of abstract types should not be possible.
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
// type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
/* ************************************************************************ */
// Specific member functions
// type Push(argument) specifiers; // Copy of the value
// type Push(argument) specifiers; // Move of the value
// type Top() specifiers; // (concrete function must throw std::length_error when empty)
// type Pop() specifiers; // (concrete function must throw std::length_error when empty)
// type TopNPop() specifiers; // (concrete function must throw std::length_error when empty)
};
/* ************************************************************************** */
}
#endif

10
librerie/exercise2/stack/vec/stackvec.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

101
librerie/exercise2/stack/vec/stackvec.hpp Executable file
View File

@ -0,0 +1,101 @@
#ifndef STACKVEC_HPP
#define STACKVEC_HPP
/* ************************************************************************** */
#include "../stack.hpp"
#include "../../vector/vector.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class StackVec { // Must extend Stack<Data> and Vector<Data>
private:
// ...
protected:
// using Vector<Data>::???;
// ...
public:
// Default constructor
// StackVec() specifier;
/* ************************************************************************ */
// Specific constructor
// StackVec(argument) specifiers; // A stack obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// StackVec(argument);
// Move constructor
// StackVec(argument);
/* ************************************************************************ */
// Destructor
// ~StackVec() specifier;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument);
// Move assignment
// type operator=(argument);
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions (inherited from Stack)
// type Push(argument) specifiers; // Override Stack member (copy of the value)
// type Push(argument) specifiers; // Override Stack member (move of the value)
// type Top() specifiers; // Override Stack member (must throw std::length_error when empty)
// type Pop() specifiers; // Override Stack member (must throw std::length_error when empty)
// type TopNPop() specifiers; // Override Stack member (must throw std::length_error when empty)
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Empty() specifiers; // Override Container member
// type Size() specifiers; // Override Container member
// type Clear() specifiers; // Override Container member
protected:
// Auxiliary member functions
// type Expand() specifiers;
// type Reduce() specifiers;
};
/* ************************************************************************** */
}
#include "stackvec.cpp"
#endif

10
librerie/exercise2/vector/vector.cpp Executable file
View File

@ -0,0 +1,10 @@
namespace lasd {
/* ************************************************************************** */
// ...
/* ************************************************************************** */
}

113
librerie/exercise2/vector/vector.hpp Executable file
View File

@ -0,0 +1,113 @@
#ifndef VECTOR_HPP
#define VECTOR_HPP
/* ************************************************************************** */
#include "../container/container.hpp"
/* ************************************************************************** */
namespace lasd {
/* ************************************************************************** */
template <typename Data>
class Vector { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
private:
// ...
protected:
// using LinearContainer<Data>::???;
// ...
public:
// Default constructor
// Vector() specifiers;
/* ************************************************************************ */
// Specific constructors
// Vector(argument) specifiers; // A vector with a given initial dimension
// Vector(argument) specifiers; // A vector obtained from a LinearContainer
/* ************************************************************************ */
// Copy constructor
// Vector(argument) specifiers;
// Move constructor
// Vector(argument) specifiers;
/* ************************************************************************ */
// Destructor
// ~Vector() specifiers;
/* ************************************************************************ */
// Copy assignment
// type operator=(argument) specifiers;
// Move assignment
// type operator=(argument) specifiers;
/* ************************************************************************ */
// Comparison operators
// type operator==(argument) specifiers;
// type operator!=(argument) specifiers;
/* ************************************************************************ */
// Specific member functions
// type Resize(argument) specifiers; // Resize the vector to a given size
/* ************************************************************************ */
// Specific member functions (inherited from Container)
// type Clear() specifiers; // Override Container member
/* ************************************************************************ */
// Specific member functions (inherited from LinearContainer)
// type Front() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
// type Back() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
// type operator[](argument) specifiers; // Override LinearContainer member (must throw std::out_of_range when out of range)
/* ************************************************************************ */
// Specific member functions (inherited from MappableContainer)
// using typename MappableContainer<Data>::MapFunctor;
// type MapPreOrder(arguments) specifiers; // Override MappableContainer member
// type MapPostOrder(arguments) specifiers; // Override MappableContainer member
/* ************************************************************************ */
// Specific member functions (inherited from FoldableContainer)
// using typename FoldableContainer<Data>::FoldFunctor;
// type FoldPreOrder(arguments) specifiers; // Override FoldableContainer member
// type FoldPostOrder(arguments) specifiers; // Override FoldableContainer member
};
/* ************************************************************************** */
}
#include "vector.cpp"
#endif

49
librerie/exercise2/zlasdtest/container/container.cpp Executable file
View File

@ -0,0 +1,49 @@
#include <iostream>
/* ************************************************************************** */
#include "../../container/container.hpp"
/* ************************************************************************** */
// Container member functions!
void Empty(uint& testnum, uint& testerr, const lasd::Container& con, bool chk) {
bool tst;
testnum++;
std::cout << " " << testnum << " The container is " << ((tst = con.Empty()) ? "" : "not ") << "empty: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
testerr += (1 - (uint) tst);
}
void Size(uint& testnum, uint& testerr, const lasd::Container& con, bool chk, ulong siz) {
bool tst;
testnum++;
std::cout << " " << testnum << " The container has size " << con.Size() << ": ";
std::cout << ((tst = ((con.Size() == siz) == chk)) ? "Correct" : "Error") << "!" << std::endl;
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
// Auxiliary functions for MappableContainer!
void MapStringAppend(std::string& dat, void* par) {
dat.append(*((std::string*) par));
}
/* ************************************************************************** */
// Auxiliary functions for FoldableContainer!
void FoldParity(const int& dat, const void* _, void* acc) {
*((int*) acc) += dat;
*((int*) acc) %= 2;
}
void FoldStringConcatenate(const std::string& dat, const void* _, void* acc) {
((std::string*) acc)->append(dat);
}
/* ************************************************************************** */

301
librerie/exercise2/zlasdtest/container/container.hpp Executable file
View File

@ -0,0 +1,301 @@
#ifndef CONTAINERTEST_HPP
#define CONTAINERTEST_HPP
#include "../../container/container.hpp"
/* ************************************************************************** */
// Container member functions!
void Empty(uint&, uint&, const lasd::Container&, bool);
void Size(uint&, uint&, const lasd::Container&, bool, ulong);
/* ************************************************************************** */
// LinearContainer member functions!
template <typename Data>
void GetFront(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The front of the linear container is \"" << con.Front() << "\": ";
std::cout << ((tst = ((con.Front() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void SetFront(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Setting the front of the linear container to \"" << val << "\": ";
con.Front() = val;
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void GetBack(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The back of the linear container is \"" << con.Back() << "\": ";
std::cout << ((tst = ((con.Back() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void SetBack(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Setting the back of the linear container to \"" << val << "\": ";
con.Back() = val;
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void SetAt(uint& testnum, uint& testerr, lasd::LinearContainer<Data>& con, bool chk, const ulong& ind, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Set of the linear container at index \"" << ind << "\" with value \"" << val << "\": ";
con[ind] = val;
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::out_of_range exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void GetAt(uint& testnum, uint& testerr, lasd::LinearContainer<Data>& con, bool chk, const ulong& ind, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Get of the linear container at index \"" << ind << "\" with value \"" << con[ind] << "\": ";
std::cout << ((tst = ((con[ind] == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::out_of_range exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
// TestableContainer member functions!
template <typename Data>
void Exists(uint& testnum, uint& testerr, const lasd::TestableContainer<Data>& con, bool chk, const Data& val) {
bool tst;
testnum++;
std::cout << " " << testnum << " Data \"" << val << "\" " << ((tst = con.Exists(val)) ? "does" : "does not") << " exist: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
// MappableContainer member functions!
template <typename Data, typename Parameter>
void MapPreOrder(uint& testnum, uint& testerr, lasd::MappableContainer<Data>& con, bool chk, typename lasd::MappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
bool tst = true;
testnum++;
Parameter par = {inipar};
try {
std::cout << " " << testnum << " Executing map in pre order - ";
con.MapPreOrder(fun, &par);
std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data, typename Parameter>
void MapPostOrder(uint& testnum, uint& testerr, lasd::MappableContainer<Data>& con, bool chk, typename lasd::MappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
bool tst = true;
testnum++;
Parameter par = {inipar};
try {
std::cout << " " << testnum << " Executing map in post order - ";
con.MapPostOrder(fun, &par);
std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void MapPrint(const Data& dat, void* _) {
std::cout << dat << " ";
}
template <typename Data>
void MapIncrement(Data& dat, void* _) {
dat++;
}
template <typename Data>
void MapIncrementNPrint(Data& dat, void* _) {
std::cout << dat++ << "->" << dat << "; ";
}
template <typename Data>
void MapDouble(Data& dat, void* _) {
dat *= 2;
}
template <typename Data>
void MapDoubleNPrint(Data& dat, void* _) {
std::cout << dat << "->" << (dat *= 2) << "; ";
}
template <typename Data>
void MapInvert(Data& dat, void* _) {
dat = -dat;
}
template <typename Data>
void MapInvertNPrint(Data& dat, void* _) {
std::cout << dat << "->" << (dat = -dat) << "; ";
}
template <typename Data>
void MapParityInvert(Data& dat, void* _) {
if (dat % 2 != 0) { dat = -dat; }
}
void MapStringAppend(std::string&, void*);
/* ************************************************************************** */
// FoldableContainer member functions!
template <typename Data, typename Parameter, typename Value>
void FoldPreOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer<Data>& con, bool chk, typename lasd::FoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
bool tst;
testnum++;
Parameter par = {inipar};
Value val = inival;
try {
std::cout << " " << testnum << " Executing fold in pre order - ";
con.FoldPreOrder(fun, &par, &val);
std::cout << "obtained value is \"" << val << "\": ";
std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data, typename Parameter, typename Value>
void FoldPostOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer<Data>& con, bool chk, typename lasd::FoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
bool tst;
testnum++;
Parameter par = {inipar};
Value val = inival;
try {
std::cout << " " << testnum << " Executing fold in post order - ";
con.FoldPostOrder(fun, &par, &val);
std::cout << "obtained value is \"" << val << "\": ";
std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void FoldAdd(const Data& dat, const void* _, void* acc) {
*((Data*) acc) += dat;
}
template <typename Data>
void FoldMultiply(const Data& dat, const void* _, void* acc) {
*((Data*) acc) *= dat;
}
void FoldParity(const int&, const void*, void*);
void FoldStringConcatenate(const std::string&, const void*, void*);
/* ************************************************************************** */
// BreadthMappableContainer member functions!
template <typename Data, typename Parameter>
void MapBreadth(uint& testnum, uint& testerr, lasd::BreadthMappableContainer<Data>& con, bool chk, typename lasd::BreadthMappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
bool tst = true;
testnum++;
Parameter par = {inipar};
try {
std::cout << " " << testnum << " Executing map in pre order - ";
con.MapBreadth(fun, &par);
std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
// BreadthFoldableContainer member functions!
template <typename Data, typename Parameter, typename Value>
void FoldBreadth(uint& testnum, uint& testerr, const lasd::BreadthFoldableContainer<Data>& con, bool chk, typename lasd::BreadthFoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
bool tst;
testnum++;
Parameter par = {inipar};
Value val = inival;
try {
std::cout << " " << testnum << " Executing fold in post order - ";
con.FoldBreadth(fun, &par, &val);
std::cout << "obtained value is \"" << val << "\": ";
std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
#endif

3
librerie/exercise2/zlasdtest/exercise1/fulltest.cpp Executable file
View File

@ -0,0 +1,3 @@
void testFullExercise1() {
}

447
librerie/exercise2/zlasdtest/exercise1/simpletest.cpp Executable file
View File

@ -0,0 +1,447 @@
#include <iostream>
/* ************************************************************************** */
#include "../container/container.hpp"
#include "../vector/vector.hpp"
#include "../list/list.hpp"
/* ************************************************************************** */
using namespace std;
/* ************************************************************************** */
void stestVectorInt(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector<int> Test:" << endl;
try {
{
lasd::Vector<int> vec;
Empty(loctestnum, loctesterr, vec, true);
GetFront(loctestnum, loctesterr, vec, false, 0);
GetBack(loctestnum, loctesterr, vec, false, 0);
SetAt(loctestnum, loctesterr, vec, false, 1, 0);
GetAt(loctestnum, loctesterr, vec, false, 2, 0);
Exists(loctestnum, loctesterr, vec, false, 0);
MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 0);
FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 0);
}
{
lasd::Vector<int> vec(3);
Empty(loctestnum, loctesterr, vec, false);
Size(loctestnum, loctesterr, vec, true, 3);
SetAt(loctestnum, loctesterr, vec, true, 0, 4);
SetAt(loctestnum, loctesterr, vec, true, 1, 3);
SetAt(loctestnum, loctesterr, vec, true, 2, 1);
GetFront(loctestnum, loctesterr, vec, true, 4);
GetBack(loctestnum, loctesterr, vec, true, 1);
SetFront(loctestnum, loctesterr, vec, true, 5);
SetBack(loctestnum, loctesterr, vec, true, 4);
Exists(loctestnum, loctesterr, vec, true, 4);
MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 12);
FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<int>, 0, 1, 60);
vec.Resize(2);
FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<int>, 0, 1, 15);
}
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVectorDouble(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector<double> Test:" << endl;
try {
lasd::Vector<double> vec(3);
Empty(loctestnum, loctesterr, vec, false);
Size(loctestnum, loctesterr, vec, true, 3);
SetAt(loctestnum, loctesterr, vec, true, 0, 5.5);
SetAt(loctestnum, loctesterr, vec, true, 1, 3.3);
SetAt(loctestnum, loctesterr, vec, true, 2, 1.1);
GetFront(loctestnum, loctesterr, vec, true, 5.5);
GetBack(loctestnum, loctesterr, vec, true, 1.1);
Exists(loctestnum, loctesterr, vec, true, 3.3);
FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<double>, 0.0, 0.0, 9.9);
FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<double>, 0.0, 1.0, 19.965);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVectorString(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector<string> Test:" << endl;
try {
lasd::Vector<string> vec(2);
Empty(loctestnum, loctesterr, vec, false);
Size(loctestnum, loctesterr, vec, true, 2);
SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
GetFront(loctestnum, loctesterr, vec, true, string("A"));
GetBack(loctestnum, loctesterr, vec, true, string("B"));
Exists(loctestnum, loctesterr, vec, true, string("A"));
MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string(" "));
MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<string>, 0);
FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XA B "));
FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XB A "));
Exists(loctestnum, loctesterr, vec, false, string("A"));
lasd::Vector<string> copvec(vec);
EqualVector(loctestnum, loctesterr, vec, copvec, true);
MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string("!"));
NonEqualVector(loctestnum, loctesterr, vec, copvec, true);
copvec = std::move(vec);
FoldPreOrder(loctestnum, loctesterr, copvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A !B !"));
lasd::Vector<string> movvec(std::move(vec));
FoldPreOrder(loctestnum, loctesterr, movvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A B "));
SetAt(loctestnum, loctesterr, vec, false, 1, string(""));
vec.Resize(1);
SetAt(loctestnum, loctesterr, vec, true, 0, string("X"));
movvec.Clear();
Empty(loctestnum, loctesterr, movvec, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVector(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
stestVectorInt(loctestnum, loctesterr);
stestVectorDouble(loctestnum, loctesterr);
stestVectorString(loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
cout << endl << "Exercise 1 - Vector (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
/* ************************************************************************** */
void stestListInt(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of List<int> Test:" << endl;
try {
lasd::List<int> lst;
Empty(loctestnum, loctesterr, lst, true);
Size(loctestnum, loctesterr, lst, true, 0);
GetFront(loctestnum, loctesterr, lst, false, 0);
GetBack(loctestnum, loctesterr, lst, false, 0);
Exists(loctestnum, loctesterr, lst, false, 0);
MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 0);
FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 0);
RemoveFromFront(loctestnum, loctesterr, lst, false);
FrontNRemove(loctestnum, loctesterr, lst, false, 0);
InsertAtBack(loctestnum, loctesterr, lst, true, 4);
InsertAtFront(loctestnum, loctesterr, lst, true, 5);
InsertAtFront(loctestnum, loctesterr, lst, true, 9);
InsertAtBack(loctestnum, loctesterr, lst, true, 2);
InsertAtFront(loctestnum, loctesterr, lst, true, 1);
GetFront(loctestnum, loctesterr, lst, true, 1);
GetBack(loctestnum, loctesterr, lst, true, 2);
SetFront(loctestnum, loctesterr, lst, true, 2);
SetBack(loctestnum, loctesterr, lst, true, 6);
GetAt(loctestnum, loctesterr, lst, true, 3, 4);
SetAt(loctestnum, loctesterr, lst, true, 3, 3);
Exists(loctestnum, loctesterr, lst, false, 4);
MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 25);
FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<int>, 0, 1, 1620);
RemoveFromFront(loctestnum, loctesterr, lst, true);
FrontNRemove(loctestnum, loctesterr, lst, true, 9);
FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<int>, 0, 1, 90);
lasd::List<int> coplst(lst);
EqualList(loctestnum, loctesterr, lst, coplst, true);
MapPreOrder(loctestnum, loctesterr, lst, true, &MapIncrement<int>, 0);
NonEqualList(loctestnum, loctesterr, lst, coplst, true);
InsertAtFront(loctestnum, loctesterr, lst, true, 0);
InsertAtBack(loctestnum, loctesterr, lst, true, 0);
NonEqualList(loctestnum, loctesterr, lst, coplst, true);
coplst = lst;
EqualList(loctestnum, loctesterr, lst, coplst, true);
RemoveFromFront(loctestnum, loctesterr, coplst, true);
FrontNRemove(loctestnum, loctesterr, coplst, true, 6);
coplst = std::move(lst);
FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 11);
FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldAdd<int>, 0, 0, 17);
lasd::List<int> movlst(std::move(lst));
MapPreOrder(loctestnum, loctesterr, movlst, true, &MapIncrement<int>, 0);
FoldPreOrder(loctestnum, loctesterr, movlst, true, &FoldAdd<int>, 0, 0, 14);
movlst.Clear();
Empty(loctestnum, loctesterr, movlst, true);
Size(loctestnum, loctesterr, movlst, true, 0);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of List<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestListDouble(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of List<double> Test:" << endl;
try {
lasd::List<double> lst;
Empty(loctestnum, loctesterr, lst, true);
Size(loctestnum, loctesterr, lst, true, 0);
InsertAtBack(loctestnum, loctesterr, lst, true, -2.5);
InsertAtBack(loctestnum, loctesterr, lst, true, 2.5);
lst.Clear();
InsertAtBack(loctestnum, loctesterr, lst, true, 0.5);
InsertAtFront(loctestnum, loctesterr, lst, true, 3.3);
InsertAtFront(loctestnum, loctesterr, lst, true, 5.5);
InsertAtBack(loctestnum, loctesterr, lst, true, 1.1);
GetFront(loctestnum, loctesterr, lst, true, 5.5);
GetBack(loctestnum, loctesterr, lst, true, 1.1);
Exists(loctestnum, loctesterr, lst, false, 0.0);
MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<double>, 0);
MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<double>, 0);
FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<double>, 0.0, 0.0, 10.4);
FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<double>, 0.0, 1.0, 9.9825);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of List<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestListString(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of List<string> Test:" << endl;
try {
lasd::List<string> lst;
Empty(loctestnum, loctesterr, lst, true);
Size(loctestnum, loctesterr, lst, true, 0);
InsertAtFront(loctestnum, loctesterr, lst, true, string("A"));
InsertAtBack(loctestnum, loctesterr, lst, true, string("B"));
GetFront(loctestnum, loctesterr, lst, true, string("A"));
GetBack(loctestnum, loctesterr, lst, true, string("B"));
Exists(loctestnum, loctesterr, lst, true, string("B"));
MapPreOrder(loctestnum, loctesterr, lst, true, &MapStringAppend, string(" "));
MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<string>, 0);
FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XA B "));
FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XB A "));
Exists(loctestnum, loctesterr, lst, false, string("B"));
lasd::List<string> coplst(lst);
EqualList(loctestnum, loctesterr, lst, coplst, true);
RemoveFromFront(loctestnum, loctesterr, coplst, true);
NonEqualList(loctestnum, loctesterr, lst, coplst, true);
lst = coplst;
EqualList(loctestnum, loctesterr, lst, coplst, true);
InsertAtBack(loctestnum, loctesterr, lst, true, string("A"));
InsertAtFront(loctestnum, loctesterr, lst, true, string("C"));
NonEqualList(loctestnum, loctesterr, lst, coplst, true);
coplst = std::move(lst);
FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldStringConcatenate, string(""), string("?"), string("?CB A"));
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of List<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestList(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
stestListInt(loctestnum, loctesterr);
stestListDouble(loctestnum, loctesterr);
stestListString(loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
cout << endl << "Exercise 1 - List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
/* ************************************************************************** */
void stestVectorListInt(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector/List<int> Test:" << endl;
try {
lasd::Vector<int> vec(3);
SetAt(loctestnum, loctesterr, vec, true, 0, -1);
SetAt(loctestnum, loctesterr, vec, true, 1, 0);
SetAt(loctestnum, loctesterr, vec, true, 2, 1);
lasd::List<int> lst;
InsertAtFront(loctestnum, loctesterr, lst, true, 1);
InsertAtFront(loctestnum, loctesterr, lst, true, 0);
InsertAtFront(loctestnum, loctesterr, lst, true, -1);
lasd::Vector<int> copvec(lst);
EqualVector(loctestnum, loctesterr, vec, copvec, true);
lasd::Vector<int> copvecx(vec);
EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
lasd::List<int> coplst(vec);
EqualList(loctestnum, loctesterr, lst, coplst, true);
lasd::List<int> coplstx(lst);
EqualList(loctestnum, loctesterr, coplstx, coplst, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector/List<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVectorListDouble(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector/List<double> Test:" << endl;
try {
lasd::Vector<double> vec(3);
SetAt(loctestnum, loctesterr, vec, true, 0, -0.5);
SetAt(loctestnum, loctesterr, vec, true, 1, 0.0);
SetAt(loctestnum, loctesterr, vec, true, 2, 0.5);
lasd::List<double> lst;
InsertAtBack(loctestnum, loctesterr, lst, true, -0.5);
InsertAtBack(loctestnum, loctesterr, lst, true, 0.0);
InsertAtBack(loctestnum, loctesterr, lst, true, 0.5);
lasd::Vector<double> copvec(lst);
EqualVector(loctestnum, loctesterr, vec, copvec, true);
lasd::Vector<double> copvecx(vec);
EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
lasd::List<double> coplst(vec);
EqualList(loctestnum, loctesterr, lst, coplst, true);
lasd::List<double> coplstx(lst);
EqualList(loctestnum, loctesterr, coplstx, coplst, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector/List<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVectorListString(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
cout << endl << "Begin of Vector/List<string> Test:" << endl;
try {
lasd::Vector<string> vec(3);
SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
SetAt(loctestnum, loctesterr, vec, true, 2, string("C"));
lasd::List<string> lst;
InsertAtFront(loctestnum, loctesterr, lst, true, string("B"));
InsertAtBack(loctestnum, loctesterr, lst, true, string("C"));
InsertAtFront(loctestnum, loctesterr, lst, true, string("A"));
lasd::Vector<string> copvec(lst);
EqualVector(loctestnum, loctesterr, vec, copvec, true);
lasd::Vector<string> copvecx(vec);
EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
lasd::List<string> coplst(vec);
EqualList(loctestnum, loctesterr, lst, coplst, true);
lasd::List<string> coplstx(lst);
EqualList(loctestnum, loctesterr, coplstx, coplst, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
cout << "End of Vector/List<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
testnum += loctestnum;
testerr += loctesterr;
}
void stestVectorList(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
stestVectorListInt(loctestnum, loctesterr);
stestVectorListDouble(loctestnum, loctesterr);
stestVectorListString(loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
cout << endl << "Exercise 1 - Vector/List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
/* ************************************************************************** */
void testSimpleExercise1() {
uint testnum = 0, testerr = 0;
stestVector(testnum, testerr);
stestList(testnum, testerr);
stestVectorList(testnum, testerr);
cout << endl << "Exercise 1 (Simple Test) (Errors/Tests: " << testerr << "/" << testnum << ")" << endl;
}

13
librerie/exercise2/zlasdtest/exercise1/test.hpp Executable file
View File

@ -0,0 +1,13 @@
#ifndef EX1TEST_HPP
#define EX1TEST_HPP
/* ************************************************************************** */
void testSimpleExercise1();
void testFullExercise1();
/* ************************************************************************** */
#endif

3
librerie/exercise2/zlasdtest/exercise2/fulltest.cpp Executable file
View File

@ -0,0 +1,3 @@
void testFullExercise2() {
}

359
librerie/exercise2/zlasdtest/exercise2/simpletest.cpp Executable file
View File

@ -0,0 +1,359 @@
#include <iostream>
/* ************************************************************************** */
#include "../container/container.hpp"
#include "../stack/stack.hpp"
#include "../../stack/vec/stackvec.hpp"
#include "../../stack/lst/stacklst.hpp"
#include "../queue/queue.hpp"
#include "../../queue/vec/queuevec.hpp"
#include "../../queue/lst/queuelst.hpp"
/* ************************************************************************** */
using namespace std;
/* ************************************************************************** */
template <typename Stk>
void stestStackInt(Stk& stk, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
Empty(loctestnum, loctesterr, stk, true);
Size(loctestnum, loctesterr, stk, true, 0);
Top(loctestnum, loctesterr, stk, false, 0);
TopNPop(loctestnum, loctesterr, stk, false, 0);
PushC(loctestnum, loctesterr, stk, 4);
PushC(loctestnum, loctesterr, stk, 0);
PushC(loctestnum, loctesterr, stk, 3);
PushC(loctestnum, loctesterr, stk, 1);
PushC(loctestnum, loctesterr, stk, 2);
Empty(loctestnum, loctesterr, stk, false);
Size(loctestnum, loctesterr, stk, true, 5);
TopNPop(loctestnum, loctesterr, stk, true, 2);
Top(loctestnum, loctesterr, stk, true, 1);
Stk copstk(stk);
EqualStack(loctestnum, loctesterr, stk, copstk, true);
PushC(loctestnum, loctesterr, stk, 5);
NonEqualStack(loctestnum, loctesterr, stk, copstk, true);
copstk = stk;
EqualStack(loctestnum, loctesterr, stk, copstk, true);
PushC(loctestnum, loctesterr, copstk, 6);
NonEqualStack(loctestnum, loctesterr, stk, copstk, true);
Top(loctestnum, loctesterr, copstk, true, 6);
copstk = std::move(stk);
TopNPop(loctestnum, loctesterr, copstk, true, 5);
Pop(loctestnum, loctesterr, copstk, true);
Top(loctestnum, loctesterr, copstk, true, 3);
Stk movstk(std::move(stk));
Top(loctestnum, loctesterr, stk, false, 0);
movstk.Clear();
Pop(loctestnum, loctesterr, movstk, false);
Empty(loctestnum, loctesterr, movstk, true);
Size(loctestnum, loctesterr, movstk, true, 0);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Stack<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestStackInt(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::StackVec<int> stkvec;
cout << endl << "Begin of StackVec<int> Test:" << endl;
stestStackInt(stkvec, loctestnum, loctesterr);
lasd::StackLst<int> stklst;
cout << endl << "Begin of StackLst<int> Test:" << endl;
stestStackInt(stklst, loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
}
template <typename Stk>
void stestStackFloat(Stk& stk, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
PushC(loctestnum, loctesterr, stk, 5.9);
PushC(loctestnum, loctesterr, stk, 4.4);
PushC(loctestnum, loctesterr, stk, 9.5);
Empty(loctestnum, loctesterr, stk, false);
Size(loctestnum, loctesterr, stk, true, 3);
TopNPop(loctestnum, loctesterr, stk, true, 9.5);
Top(loctestnum, loctesterr, stk, true, 4.4);
Pop(loctestnum, loctesterr, stk, true);
TopNPop(loctestnum, loctesterr, stk, true, 5.9);
Pop(loctestnum, loctesterr, stk, false);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Stack<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestStackFloat(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::StackVec<double> stkvec;
cout << endl << "Begin of StackVec<double> Test:" << endl;
stestStackFloat(stkvec, loctestnum, loctesterr);
lasd::StackLst<double> stklst;
cout << endl << "Begin of StackLst<double> Test:" << endl;
stestStackFloat(stklst, loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
}
template <typename Stk>
void stestStackString(Stk& stk, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
PushM(loctestnum, loctesterr, stk, string("A"));
PushM(loctestnum, loctesterr, stk, string("B"));
Empty(loctestnum, loctesterr, stk, false);
Size(loctestnum, loctesterr, stk, true, 2);
TopNPop(loctestnum, loctesterr, stk, true, string("B"));
Top(loctestnum, loctesterr, stk, true, string("A"));
Pop(loctestnum, loctesterr, stk, true);
Pop(loctestnum, loctesterr, stk, false);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Stack<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestStackString(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::StackVec<string> stkvec;
cout << endl << "Begin of StackVec<string> Test:" << endl;
stestStackString(stkvec, loctestnum, loctesterr);
lasd::StackLst<string> stklst;
cout << endl << "Begin of StackLst<string> Test:" << endl;
stestStackString(stklst, loctestnum, loctesterr);
cout << endl;
try {
lasd::Vector<string> vec(2);
SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
PushM(loctestnum, loctesterr, stkvec, string("A"));
PushM(loctestnum, loctesterr, stkvec, string("B"));
lasd::StackVec<string> newstkvec(vec);
EqualStack(loctestnum, loctesterr, stkvec, newstkvec, true);
PushM(loctestnum, loctesterr, stklst, string("B"));
PushM(loctestnum, loctesterr, stklst, string("A"));
lasd::StackLst<string> newstklst(vec);
EqualStack(loctestnum, loctesterr, stklst, newstklst, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
}
void stestStack(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
stestStackInt(loctestnum, loctesterr);
stestStackFloat(loctestnum, loctesterr);
stestStackString(loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
cout << endl << "Exercise 2 - Stack (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
/* ************************************************************************** */
template <typename Que>
void stestQueueInt(Que& que, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
Empty(loctestnum, loctesterr, que, true);
Size(loctestnum, loctesterr, que, true, 0);
Head(loctestnum, loctesterr, que, false, 0);
HeadNDequeue(loctestnum, loctesterr, que, false, 0);
EnqueueC(loctestnum, loctesterr, que, 4);
EnqueueC(loctestnum, loctesterr, que, 0);
EnqueueC(loctestnum, loctesterr, que, 3);
EnqueueC(loctestnum, loctesterr, que, 1);
EnqueueC(loctestnum, loctesterr, que, 2);
Empty(loctestnum, loctesterr, que, false);
Size(loctestnum, loctesterr, que, true, 5);
HeadNDequeue(loctestnum, loctesterr, que, true, 4);
Head(loctestnum, loctesterr, que, true, 0);
Que copque(que);
EqualQueue(loctestnum, loctesterr, que, copque, true);
EnqueueC(loctestnum, loctesterr, que, 5);
NonEqualQueue(loctestnum, loctesterr, que, copque, true);
copque = que;
EqualQueue(loctestnum, loctesterr, que, copque, true);
EnqueueC(loctestnum, loctesterr, copque, 6);
NonEqualQueue(loctestnum, loctesterr, que, copque, true);
Head(loctestnum, loctesterr, copque, true, 0);
copque = std::move(que);
HeadNDequeue(loctestnum, loctesterr, copque, true, 0);
Dequeue(loctestnum, loctesterr, copque, true);
Head(loctestnum, loctesterr, copque, true, 1);
Que movque(std::move(que));
Head(loctestnum, loctesterr, que, false, 0);
movque.Clear();
Dequeue(loctestnum, loctesterr, movque, false);
Empty(loctestnum, loctesterr, movque, true);
Size(loctestnum, loctesterr, movque, true, 0);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Queue<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestQueueInt(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::QueueVec<int> quevec;
cout << endl << "Begin of QueueVec<int> Test:" << endl;
stestQueueInt(quevec, loctestnum, loctesterr);
lasd::QueueLst<int> quelst;
cout << endl << "Begin of QueueLst<int> Test:" << endl;
stestQueueInt(quelst, loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
}
template <typename Que>
void stestQueueFloat(Que& que, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
EnqueueC(loctestnum, loctesterr, que, 5.9);
EnqueueC(loctestnum, loctesterr, que, 4.4);
EnqueueC(loctestnum, loctesterr, que, 9.5);
Empty(loctestnum, loctesterr, que, false);
Size(loctestnum, loctesterr, que, true, 3);
HeadNDequeue(loctestnum, loctesterr, que, true, 5.9);
Head(loctestnum, loctesterr, que, true, 4.4);
Dequeue(loctestnum, loctesterr, que, true);
HeadNDequeue(loctestnum, loctesterr, que, true, 9.5);
Dequeue(loctestnum, loctesterr, que, false);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Queue<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestQueueFloat(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::QueueVec<double> quevec;
cout << endl << "Begin of QueueVec<double> Test:" << endl;
stestQueueFloat(quevec, loctestnum, loctesterr);
lasd::QueueLst<double> quelst;
cout << endl << "Begin of QueueLst<double> Test:" << endl;
stestQueueFloat(quelst, loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
}
template <typename Que>
void stestQueueString(Que& que, uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
try {
EnqueueM(loctestnum, loctesterr, que, string("A"));
EnqueueM(loctestnum, loctesterr, que, string("B"));
Empty(loctestnum, loctesterr, que, false);
Size(loctestnum, loctesterr, que, true, 2);
HeadNDequeue(loctestnum, loctesterr, que, true, string("A"));
Head(loctestnum, loctesterr, que, true, string("B"));
Dequeue(loctestnum, loctesterr, que, true);
Dequeue(loctestnum, loctesterr, que, false);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
cout << "End of Queue<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
void stestQueueString(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
lasd::QueueVec<string> quevec;
cout << endl << "Begin of QueueVec<string> Test:" << endl;
stestQueueString(quevec, loctestnum, loctesterr);
lasd::QueueLst<string> quelst;
cout << endl << "Begin of QueueLst<string> Test:" << endl;
stestQueueString(quelst, loctestnum, loctesterr);
cout << endl;
try {
lasd::Vector<string> vec(2);
SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
EnqueueM(loctestnum, loctesterr, quevec, string("A"));
EnqueueM(loctestnum, loctesterr, quevec, string("B"));
lasd::QueueVec<string> newquevec(vec);
EqualStack(loctestnum, loctesterr, quevec, newquevec, true);
EnqueueM(loctestnum, loctesterr, quelst, string("A"));
EnqueueM(loctestnum, loctesterr, quelst, string("B"));
lasd::QueueLst<string> newquelst(vec);
EqualStack(loctestnum, loctesterr, quelst, newquelst, true);
} catch(...) {
loctestnum++; loctesterr++;
cout << endl << "Unmanaged error! " << endl;
}
testnum += loctestnum;
testerr += loctesterr;
}
void stestQueue(uint& testnum, uint& testerr) {
uint loctestnum = 0, loctesterr = 0;
stestQueueInt(loctestnum, loctesterr);
stestQueueFloat(loctestnum, loctesterr);
stestQueueString(loctestnum, loctesterr);
testnum += loctestnum;
testerr += loctesterr;
cout << endl << "Exercise 2 - Queue (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
}
/* ************************************************************************** */
void testSimpleExercise2() {
uint testnum = 0, testerr = 0;
stestStack(testnum, testerr);
stestQueue(testnum, testerr);
cout << endl << "Exercise 2 (Simple Test) (Errors/Tests: " << testerr << "/" << testnum << ")" << endl;
}

13
librerie/exercise2/zlasdtest/exercise2/test.hpp Executable file
View File

@ -0,0 +1,13 @@
#ifndef EX2TEST_HPP
#define EX2TEST_HPP
/* ************************************************************************** */
void testSimpleExercise2();
void testFullExercise2();
/* ************************************************************************** */
#endif

98
librerie/exercise2/zlasdtest/list/list.hpp Executable file
View File

@ -0,0 +1,98 @@
#ifndef LISTTEST_HPP
#define LISTTEST_HPP
#include "../../list/list.hpp"
/* ************************************************************************** */
template <typename Data>
void InsertAtFront(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Insert at the front of the list the value \"" << val << "\": ";
lst.InsertAtFront(val);
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void RemoveFromFront(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Remove from the list of \"" << lst.Front() << "\": ";
lst.RemoveFromFront();
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void FrontNRemove(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " FrontNRemove from the list of \"" << lst.Front() << "\": ";
std::cout << ((tst = ((lst.FrontNRemove() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void InsertAtBack(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " Insert at the back of the list the value \"" << val << "\": ";
lst.InsertAtBack(val);
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void EqualList(uint& testnum, uint& testerr, const lasd::List<Data>& lst1, const lasd::List<Data>& lst2, bool chk) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 == lst2)) ? "" : "not ") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void NonEqualList(uint& testnum, uint& testerr, const lasd::List<Data>& lst1, const lasd::List<Data>& lst2, bool chk) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 != lst2)) ? "not " : "") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
#endif

116
librerie/exercise2/zlasdtest/queue/queue.hpp Executable file
View File

@ -0,0 +1,116 @@
#ifndef QUEUETEST_HPP
#define QUEUETEST_HPP
#include "../../queue/queue.hpp"
/* ************************************************************************** */
template <typename Data>
void EnqueueC(uint& testnum, uint& testerr, lasd::Queue<Data>& que, const Data& val) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Enqueue on the queue of the value \"" << val << "\": ";
que.Enqueue(val);
std::cout << "Correct!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << "Error!" << std::endl;
tst = false;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void EnqueueM(uint& testnum, uint& testerr, lasd::Queue<Data>& que, Data val) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Enqueue on the queue of the value \"" << val << "\": ";
que.Enqueue(std::move(val));
std::cout << "Correct!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << "Error!" << std::endl;
tst = false;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void Head(uint& testnum, uint& testerr, lasd::Queue<Data>& que, bool chk, const Data& val) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " Head of the queue with value \"" << que.Head() << "\": ";
std::cout << ((tst = ((que.Head() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void Dequeue(uint& testnum, uint& testerr, lasd::Queue<Data>& que, bool chk) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Dequeue from the queue: ";
que.Dequeue();
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void HeadNDequeue(uint& testnum, uint& testerr, lasd::Queue<Data>& que, bool chk, const Data& val) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " HeadNDequeue from the queue with value \"" << que.Head() << "\": ";
std::cout << ((tst = ((que.HeadNDequeue() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Que>
void EqualQueue(uint& testnum, uint& testerr, const Que& que1, const Que& que2, bool chk) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " The two queues are " << ((tst = (que1 == que2)) ? "" : "not ") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Que>
void NonEqualQueue(uint& testnum, uint& testerr, const Que& que1, const Que& que2, bool chk) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " The two queues are " << ((tst = (que1 != que2)) ? "not " : "") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
#endif

116
librerie/exercise2/zlasdtest/stack/stack.hpp Executable file
View File

@ -0,0 +1,116 @@
#ifndef STACKTEST_HPP
#define STACKTEST_HPP
#include "../../stack/stack.hpp"
/* ************************************************************************** */
template <typename Data>
void PushC(uint& testnum, uint& testerr, lasd::Stack<Data>& stk, const Data& val) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Push on the stack of the value \"" << val << "\": ";
stk.Push(val);
std::cout << "Correct!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << "Error!" << std::endl;
tst = false;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void PushM(uint& testnum, uint& testerr, lasd::Stack<Data>& stk, Data val) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Push on the stack of the value \"" << val << "\": ";
stk.Push(std::move(val));
std::cout << "Correct!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << "Error!" << std::endl;
tst = false;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void Top(uint& testnum, uint& testerr, lasd::Stack<Data>& stk, bool chk, const Data& val) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " Top of the stack with value \"" << stk.Top() << "\": ";
std::cout << ((tst = ((stk.Top() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void Pop(uint& testnum, uint& testerr, lasd::Stack<Data>& stk, bool chk) {
testnum++;
bool tst = true;
try {
std::cout << " " << testnum << " Pop from the stack: ";
stk.Pop();
std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void TopNPop(uint& testnum, uint& testerr, lasd::Stack<Data>& stk, bool chk, const Data& val) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " TopNPop from the stack with value \"" << stk.Top() << "\": ";
std::cout << ((tst = ((stk.TopNPop() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::length_error exc) {
std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
tst = false;
std::cout << std::endl << "Wrong exception: " << exc.what() << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Stk>
void EqualStack(uint& testnum, uint& testerr, const Stk& stk1, const Stk& stk2, bool chk) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " The two stacks are " << ((tst = (stk1 == stk2)) ? "" : "not ") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Stk>
void NonEqualStack(uint& testnum, uint& testerr, const Stk& stk1, const Stk& stk2, bool chk) {
testnum++;
bool tst;
try {
std::cout << " " << testnum << " The two stacks are " << ((tst = (stk1 != stk2)) ? "not " : "") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
#endif

21
librerie/exercise2/zlasdtest/test.cpp Executable file
View File

@ -0,0 +1,21 @@
#include "./exercise1/test.hpp"
#include "./exercise2/test.hpp"
/* ************************************************************************** */
#include <iostream>
using namespace std;
/* ************************************************************************** */
void lasdtest() {
cout << endl << "~*~#~*~ Welcome to the LASD Test Suite ~*~#~*~ " << endl;
testSimpleExercise1();
testFullExercise1();
testSimpleExercise2();
testFullExercise2();
cout << endl << "Goodbye!" << endl;
}

11
librerie/exercise2/zlasdtest/test.hpp Executable file
View File

@ -0,0 +1,11 @@
#ifndef LASDTEST_HPP
#define LASDTEST_HPP
/* ************************************************************************** */
void lasdtest();
/* ************************************************************************** */
#endif

37
librerie/exercise2/zlasdtest/vector/vector.hpp Executable file
View File

@ -0,0 +1,37 @@
#ifndef VECTORTEST_HPP
#define VECTORTEST_HPP
#include "../../vector/vector.hpp"
/* ************************************************************************** */
template <typename Data>
void EqualVector(uint& testnum, uint& testerr, const lasd::Vector<Data>& vec1, const lasd::Vector<Data>& vec2, bool chk) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 == vec2)) ? "" : "not ") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
template <typename Data>
void NonEqualVector(uint& testnum, uint& testerr, const lasd::Vector<Data>& vec1, const lasd::Vector<Data>& vec2, bool chk) {
bool tst;
testnum++;
try {
std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 != vec2)) ? "not " : "") << "equal: ";
std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
} catch(std::exception exc) {
std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
}
testerr += (1 - (uint) tst);
}
/* ************************************************************************** */
#endif

2
librerie/exercise2/zmytest/test.cpp Executable file
View File

@ -0,0 +1,2 @@
// ...

11
librerie/exercise2/zmytest/test.hpp Executable file
View File

@ -0,0 +1,11 @@
#ifndef MYTEST_HPP
#define MYTEST_HPP
/* ************************************************************************** */
// ...
/* ************************************************************************** */
#endif