gtfs-actions/generate-shapes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
generate-shapes/src/util/tests/TestMain.cpp
Patrick Brosi 73eb2c16da changes
2018-07-06 16:22:06 +02:00

856 lines
22 KiB
C++
Raw Blame History

// Copyright 2016
// Author: Patrick Brosi
//
#include <string>
#include "lest.h"
#include "util/Nullable.h"
#include "util/String.h"
#include "util/geo/Geo.h"
#include "util/geo/GeoNew.h"
#include "util/graph/DirGraph.h"
#include "util/graph/UndirGraph.h"
#include "util/graph/Dijkstra.h"
#include "util/graph/EDijkstra.h"
#include "util/geo/Grid.h"
#include "util/Misc.h"
using lest::approx;
using namespace util;
using namespace util::geo;
using namespace util::graph;
// define LEST cases
const lest::test specification[] = {
// ___________________________________________________________________________
CASE("atof") {
EXPECT(util::atof("45.534215") == approx(45.534215));
EXPECT(util::atof("5.534") == approx(5.534));
EXPECT(util::atof("534") == approx(534));
EXPECT(util::atof("-534") == approx(-534));
EXPECT(util::atof("-45.534215") == approx(-45.534215));
EXPECT(util::atof("-45.534215", 2) == approx(-45.53));
// TODO: more test cases
},
// ___________________________________________________________________________
CASE("dirgraph") {
DirGraph<int, int> g;
DirNode<int, int>* a = new DirNode<int, int>(0);
DirNode<int, int>* b = new DirNode<int, int>(0);
g.addNd(a);
EXPECT(g.getNds()->size() == (size_t)1);
g.addNd(b);
EXPECT(g.getNds()->size() == (size_t)2);
g.addEdg(a, b);
EXPECT(a->getDeg() == (size_t)1);
EXPECT(b->getDeg() == (size_t)0);
auto c = g.addNd();
g.addEdg(a, c);
g.addEdg(c, b);
EXPECT(a->getDeg() == (size_t)2);
EXPECT(b->getDeg() == (size_t)0);
EXPECT(c->getDeg() == (size_t)1);
g.delEdg(a, c);
EXPECT(a->getDeg() == (size_t)1);
EXPECT(b->getDeg() == (size_t)0);
EXPECT(c->getDeg() == (size_t)1);
g.addEdg(a, a);
EXPECT(a->getDeg() == (size_t)2);
g.delEdg(a, a);
EXPECT(a->getDeg() == (size_t)1);
g.delEdg(a, a);
EXPECT(a->getDeg() == (size_t)1);
// TODO: more test cases
},
// ___________________________________________________________________________
CASE("unddirgraph") {
UndirGraph<int, int> g;
UndirNode<int, int>* a = new UndirNode<int, int>(0);
UndirNode<int, int>* b = new UndirNode<int, int>(0);
g.addNd(a);
EXPECT(g.getNds()->size() == (size_t)1);
g.addNd(b);
EXPECT(g.getNds()->size() == (size_t)2);
g.addEdg(a, b);
EXPECT(a->getDeg() == (size_t)1);
EXPECT(b->getDeg() == (size_t)1);
auto c = g.addNd();
g.addEdg(a, c);
g.addEdg(c, b);
EXPECT(a->getDeg() == (size_t)2);
EXPECT(b->getDeg() == (size_t)2);
EXPECT(c->getDeg() == (size_t)2);
g.delEdg(a, c);
EXPECT(a->getDeg() == (size_t)1);
EXPECT(b->getDeg() == (size_t)2);
EXPECT(c->getDeg() == (size_t)1);
g.delNd(b);
EXPECT(a->getDeg() == (size_t)0);
EXPECT(c->getDeg() == (size_t)0);
g.addEdg(a, a);
EXPECT(a->getDeg() == (size_t)1);
g.delEdg(a, a);
EXPECT(a->getDeg() == (size_t)0);
// TODO: more test cases
},
// ___________________________________________________________________________
CASE("grid") {
Grid<int, Line, double> g(.5, .5, Box<double>(Point<double>(0, 0), Point<double>(3, 3)));
Line<double> l;
l.push_back(Point<double>(0, 0));
l.push_back(Point<double>(1.5, 2));
Line<double> l2;
l.push_back(Point<double>(2.5, 1));
l.push_back(Point<double>(2.5, 2));
g.add(l, 1);
g.add(l2, 2);
std::set<int> ret;
Box<double> req(Point<double>(.5, 1), Point<double>(1, 1.5));
g.get(req, &ret);
EXPECT(ret.size() == (size_t)1);
ret.clear();
g.getNeighbors(1, 0, &ret);
// TODO!
//EXPECT(ret.size() == 1);
ret.clear();
g.getNeighbors(1, 0.55, &ret);
EXPECT(ret.size() == (size_t)2);
// TODO: more test cases
},
// ___________________________________________________________________________
CASE("densify") {
Line<double> a;
a.push_back(Point<double>(1, 1));
a.push_back(Point<double>(10, 1));
auto dense = util::geo::densify(a, 1);
EXPECT(dense.size() == (size_t)10);
for (int i = 0; i < 10; i++) {
EXPECT(dense[i].get<0>() == approx(i + 1.0));
}
dense = util::geo::simplify(dense, 0.1);
EXPECT(dense.size() == (size_t)2);
Line<double> b;
b.push_back(Point<double>(1, 1));
b.push_back(Point<double>(5, 7));
b.push_back(Point<double>(10, 3));
dense = util::geo::densify(b, 1);
dense = util::geo::simplify(dense, 0.1);
EXPECT(dense.size() == (size_t)3);
},
// ___________________________________________________________________________
CASE("summed frechet distance") {
Line<double> a;
a.push_back(Point<double>(1, 1));
a.push_back(Point<double>(2, 1));
a.push_back(Point<double>(3, 1));
a.push_back(Point<double>(3, 2));
a.push_back(Point<double>(4, 2));
a.push_back(Point<double>(4, 1));
a.push_back(Point<double>(5, 1));
a.push_back(Point<double>(6, 1));
Line<double> b;
b.push_back(Point<double>(1, 1));
b.push_back(Point<double>(2, 1));
b.push_back(Point<double>(3, 1));
b.push_back(Point<double>(4, 1));
b.push_back(Point<double>(5, 1));
b.push_back(Point<double>(6, 1));
double fd = util::geo::accFrechetDistC(a, b, 0.1);
EXPECT(fd == approx(2));
},
// ___________________________________________________________________________
CASE("frechet distance") {
Line<double> e;
e.push_back(Point<double>(1, 1));
e.push_back(Point<double>(1, 2));
Line<double> f;
f.push_back(Point<double>(1, 1));
f.push_back(Point<double>(1, 2));
double fd = util::geo::frechetDist(e, f, 0.1);
EXPECT(fd == approx(0));
Line<double> a;
a.push_back(Point<double>(1, 1));
a.push_back(Point<double>(2, 1));
a.push_back(Point<double>(3, 2));
a.push_back(Point<double>(4, 2));
a.push_back(Point<double>(5, 1));
a.push_back(Point<double>(6, 1));
Line<double> b;
b.push_back(Point<double>(1, 1));
b.push_back(Point<double>(2, 1));
b.push_back(Point<double>(3, 1));
b.push_back(Point<double>(4, 1));
b.push_back(Point<double>(5, 1));
b.push_back(Point<double>(6, 1));
auto adense = util::geo::densify(a, 0.1);
auto bdense = util::geo::densify(b, 0.1);
fd = util::geo::frechetDist(a, b, 0.1);
EXPECT(fd == approx(1));
Line<double> c;
c.push_back(Point<double>(1, 1));
c.push_back(Point<double>(2, 1));
Line<double> d;
d.push_back(Point<double>(3, 1));
d.push_back(Point<double>(4, 1));
fd = util::geo::frechetDist(c, d, 0.1);
EXPECT(fd == approx(2));
Line<double> g;
g.push_back(Point<double>(1, 1));
g.push_back(Point<double>(10, 1));
Line<double> h;
h.push_back(Point<double>(1, 1));
h.push_back(Point<double>(3, 2));
h.push_back(Point<double>(3, 1));
h.push_back(Point<double>(10, 1));
fd = util::geo::frechetDist(g, h, 0.1);
EXPECT(fd == approx(1));
},
// ___________________________________________________________________________
CASE("geo box alignment") {
Line<double> a;
a.push_back(Point<double>(1, 1));
a.push_back(Point<double>(1, 2));
Line<double> b;
b.push_back(Point<double>(1, 2));
b.push_back(Point<double>(2, 2));
Line<double> c;
c.push_back(Point<double>(2, 2));
c.push_back(Point<double>(2, 1));
Line<double> d;
d.push_back(Point<double>(2, 1));
d.push_back(Point<double>(1, 1));
Box<double> box(Point<double>(2, 3), Point<double>(5, 4));
MultiLine<double> ml;
ml.push_back(a);
ml.push_back(b);
ml.push_back(c);
ml.push_back(d);
EXPECT(parallelity(box, ml) == approx(1));
ml = rotate(ml, 45);
EXPECT(parallelity(box, ml) == approx(0));
ml = rotate(ml, 45);
EXPECT(parallelity(box, ml) == approx(1));
ml = rotate(ml, 45);
EXPECT(parallelity(box, ml) == approx(0));
ml = rotate(ml, 45);
EXPECT(parallelity(box, ml) == approx(1));
},
// ___________________________________________________________________________
CASE("url decode") {
EXPECT("zürich" == util::urlDecode("z%C3%BCrich"));
EXPECT("!@$%^*()" == util::urlDecode("!%40%24%25%5E*()"));
EXPECT("Løkken" == util::urlDecode("L%C3%B8kken"));
EXPECT("á é" == util::urlDecode("%C3%A1%20%C3%A9"));
EXPECT("á é" == util::urlDecode("%C3%A1+%C3%A9"));
},
// ___________________________________________________________________________
CASE("json escape") {
EXPECT("Hello\\\\Goodbye!" == util::jsonStringEscape("Hello\\Goodbye!"));
EXPECT("\\\"Hello\\\"" == util::jsonStringEscape("\"Hello\""));
},
// ___________________________________________________________________________
CASE("split") {
EXPECT(util::split("hello,again", ',').size() == (size_t)2);
EXPECT(util::split("hello,,again", ',').size() == (size_t)3);
EXPECT(util::split("hello", ',').size() == (size_t)1);
EXPECT(util::split("", ',').size() == (size_t)0);
},
// ___________________________________________________________________________
CASE("editdist") {
EXPECT(util::editDist("hello", "mello") == (size_t)1);
EXPECT(util::editDist("mello", "hello") == (size_t)1);
EXPECT(util::editDist("abcde", "abfde") == (size_t)1);
EXPECT(util::editDist("abcd", "abcde") == (size_t)1);
EXPECT(util::editDist("xabcd", "abcde") == (size_t)2);
EXPECT(util::editDist("abcd", "abcdes") == (size_t)2);
EXPECT(util::editDist("hello", "hello") == (size_t)0);
},
// ___________________________________________________________________________
CASE("toString") {
EXPECT(util::toString(34) == "34");
EXPECT(util::toString("34") == "34");
},
// ___________________________________________________________________________
CASE("replace") {
std::string a("lorem ipsum ipsum lorem");
EXPECT(util::replace(a, "ips", "aa"));
EXPECT(a == "lorem aaum ipsum lorem");
EXPECT(!util::replace(a, "blablabla", ""));
EXPECT(a == "lorem aaum ipsum lorem");
EXPECT(util::replace(a, "m", ""));
EXPECT(a == "lore aaum ipsum lorem");
EXPECT(!util::replace(a, "", ""));
EXPECT(a == "lore aaum ipsum lorem");
std::string b("lorem ipsum ipsum lorem");
EXPECT(util::replaceAll(b, "ips", "aa"));
EXPECT(b == "lorem aaum aaum lorem");
EXPECT(util::replaceAll(b, "m", ""));
EXPECT(b == "lore aau aau lore");
EXPECT(util::replaceAll(b, "a", "aa"));
EXPECT(b == "lore aaaau aaaau lore");
EXPECT(util::replaceAll(b, "e", "e"));
EXPECT(b == "lore aaaau aaaau lore");
EXPECT(util::replaceAll(b, "e", "ee"));
EXPECT(b == "loree aaaau aaaau loree");
EXPECT(!util::replaceAll(b, "", "ee"));
EXPECT(b == "loree aaaau aaaau loree");
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra directed, 1 to all") {
DirGraph<std::string, int> g;
auto a = g.addNd("A");
auto b = g.addNd("B");
auto c = g.addNd("C");
auto d = g.addNd("D");
auto e = g.addNd("E");
auto eAC = g.addEdg(a, c, 1);
auto eAB = g.addEdg(a, b, 5);
auto eDC = g.addEdg(d, c, 1);
auto eDB = g.addEdg(d, b, 3);
auto eED = g.addEdg(e, d, 1);
auto eEB = g.addEdg(e, b, 1);
UNUSED(eAC);
UNUSED(eDC);
UNUSED(eDB);
UNUSED(eED);
UNUSED(eEB);
struct CostFunc : public EDijkstra::CostFunc<std::string, int, int> {
int operator()(const Edge<std::string, int>* from,
const Node<std::string, int>* n,
const Edge<std::string, int>* to) const {
UNUSED(from);
// dont count cost of start edge
if (n) return to->pl();
return 0;
};
int inf() const { return 999; };
};
CostFunc cFunc;
auto cost = EDijkstra::shortestPath(eAB, cFunc);
for (auto u : cost) {
int single = EDijkstra::shortestPath(eAB, u.first, cFunc);
EXPECT(single == u.second);
}
// all to 1
auto eBC = g.addEdg(b, c, 10);
auto costb = EDijkstra::shortestPathRev(eBC, cFunc);
for (auto u : costb) {
int single = EDijkstra::shortestPath(u.first, eBC, cFunc);
EXPECT(single == u.second);
}
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra undirected, edge 1 to 1") {
UndirGraph<std::string, int> g;
auto a = g.addNd("A");
auto b = g.addNd("B");
auto c = g.addNd("C");
auto d = g.addNd("D");
auto e = g.addNd("E");
auto eAC = g.addEdg(a, c, 1);
auto eAB = g.addEdg(a, b, 5);
auto eDC = g.addEdg(d, c, 1);
auto eDB = g.addEdg(d, b, 3);
auto eED = g.addEdg(e, d, 1);
auto eEB = g.addEdg(e, b, 1);
UNUSED(eAC);
UNUSED(eDC);
UNUSED(eDB);
UNUSED(eED);
UNUSED(eEB);
struct CostFunc : public EDijkstra::CostFunc<std::string, int, int> {
int operator()(const Edge<std::string, int>* from,
const Node<std::string, int>* n,
const Edge<std::string, int>* to) const {
UNUSED(from);
// dont count cost of start edge
if (n) return to->pl();
return 0;
};
int inf() const { return 999; };
};
CostFunc cFunc;
EDijkstra::NList<std::string, int> res;
EDijkstra::EList<std::string, int> resE;
int cost = EDijkstra::shortestPath(eAB, d, cFunc, &resE, &res);
EXPECT(cost == 2);
EXPECT(resE.size() == (size_t)3);
EXPECT(res.size() == (size_t)3);
EXPECT((*(res.rbegin()))->pl() == "A");
EXPECT((*(++res.rbegin()))->pl() == "C");
EXPECT((*(++++res.rbegin()))->pl() == "D");
EXPECT((*(resE.rbegin())) == eAB);
EXPECT((*(++resE.rbegin())) == eAC);
EXPECT((*(++++resE.rbegin())) == eDC);
cost = EDijkstra::shortestPath(eAB, b, cFunc, &resE, &res);
EXPECT(cost == 0);
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra undirected, edge 1 to n") {
UndirGraph<std::string, int> g;
auto a = g.addNd("A");
auto b = g.addNd("B");
auto c = g.addNd("C");
auto d = g.addNd("D");
auto e = g.addNd("E");
auto eAC = g.addEdg(a, c, 1);
auto eAB = g.addEdg(a, b, 5);
auto eDC = g.addEdg(d, c, 1);
auto eDB = g.addEdg(d, b, 3);
auto eED = g.addEdg(e, d, 1);
auto eEB = g.addEdg(e, b, 1);
UNUSED(eAC);
UNUSED(eDC);
UNUSED(eDB);
UNUSED(eED);
UNUSED(eEB);
struct CostFunc : public EDijkstra::CostFunc<std::string, int, int> {
int operator()(const Edge<std::string, int>* from, const Node<std::string, int>* n,
const Edge<std::string, int>* to) const {
UNUSED(from);
// dont count cost of start edge
if (n) return to->pl();
return 0;
};
int inf() const { return 999; };
};
CostFunc cFunc;
std::set<Node<std::string, int>*> tos;
tos.insert(d);
tos.insert(b);
tos.insert(b);
EDijkstra::NList<std::string, int> res;
EDijkstra::EList<std::string, int> resE;
int cost = EDijkstra::shortestPath(eAB, tos, cFunc, &resE, &res);
EXPECT(cost == 0);
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra undirected, 1 to n") {
UndirGraph<std::string, int> g;
auto a = g.addNd("A");
auto b = g.addNd("B");
auto c = g.addNd("C");
auto d = g.addNd("D");
auto e = g.addNd("E");
g.addEdg(a, c, 1);
auto eAB = g.addEdg(a, b, 5);
auto eDC = g.addEdg(d, c, 1);
g.addEdg(d, b, 3);
auto eED = g.addEdg(e, d, 1);
g.addEdg(e, b, 1);
struct CostFunc : public EDijkstra::CostFunc<std::string, int, int> {
int operator()(const Edge<std::string, int>* from, const Node<std::string, int>* n,
const Edge<std::string, int>* to) const {
UNUSED(from);
// dont count cost of start edge
if (n) return to->pl();
return 0;
};
int inf() const { return 999; };
};
CostFunc cFunc;
std::set<Edge<std::string, int>*> tos;
tos.insert(eDC);
tos.insert(eED);
std::unordered_map<Edge<std::string, int>*, EDijkstra::EList<std::string, int>*> resE;
resE[eDC] = new EDijkstra::EList<std::string, int>();
resE[eED] = new EDijkstra::EList<std::string, int>();
std::unordered_map<Edge<std::string, int>*, EDijkstra::NList<std::string, int>*> res;
res[eDC] = new EDijkstra::NList<std::string, int>();
res[eED] = new EDijkstra::NList<std::string, int>();
auto hFunc = EDijkstra::ZeroHeurFunc<std::string, int, int>();
std::unordered_map<Edge<std::string, int>*, int> cost = EDijkstra::shortestPath(eAB, tos, cFunc, hFunc, resE, res);
EXPECT(cost[eDC] == 2);
EXPECT(cost[eED] == 2);
EXPECT(resE[eDC]->size() == (size_t)3);
EXPECT(res[eED]->size() == (size_t)3);
EXPECT(resE[eDC]->size() == (size_t)3);
EXPECT(res[eED]->size() == (size_t)3);
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra undirected") {
UndirGraph<std::string, int> g;
auto a = g.addNd("A");
auto b = g.addNd("B");
auto c = g.addNd("C");
auto d = g.addNd("D");
auto e = g.addNd("E");
g.addEdg(a, c, 1);
g.addEdg(a, b, 5);
g.addEdg(d, c, 1);
g.addEdg(d, b, 3);
g.addEdg(e, d, 1);
g.addEdg(e, b, 1);
struct CostFunc : public EDijkstra::CostFunc<std::string, int, int> {
int operator()(const Edge<std::string, int>* fr, const Node<std::string, int>* n,
const Edge<std::string, int>* to) const {
UNUSED(fr);
UNUSED(n);
return to->pl();
};
int inf() const { return 999; };
};
CostFunc cFunc;
EDijkstra::NList<std::string, int> res;
EDijkstra::EList<std::string, int> resE;
int cost = EDijkstra::shortestPath(a, b, cFunc, &resE, &res);
EXPECT(res.size() == (size_t)5);
EXPECT((*(res.rbegin()))->pl() == "A");
EXPECT((*(++res.rbegin()))->pl() == "C");
EXPECT((*(++++res.rbegin()))->pl() == "D");
EXPECT((*(++++++res.rbegin()))->pl() == "E");
EXPECT((*(++++++++res.rbegin()))->pl() == "B");
EXPECT(cost == 4);
EXPECT((*(resE.rbegin()))->getFrom()->pl() == "A");
EXPECT((*(++resE.rbegin()))->getFrom()->pl() == "D");
EXPECT((*(++++resE.rbegin()))->getFrom()->pl() == "E");
EXPECT((*(++++++resE.rbegin()))->getTo()->pl() == "B");
EXPECT(resE.size() == (size_t)4);
cost = EDijkstra::shortestPath(d, b, cFunc, &res);
EXPECT(cost == 2);
cost = EDijkstra::shortestPath(b, d, cFunc, &res);
EXPECT(cost == 2);
cost = EDijkstra::shortestPath(e, b, cFunc, &res);
EXPECT(cost == 1);
cost = EDijkstra::shortestPath(b, e, cFunc, &res);
EXPECT(cost == 1);
cost = EDijkstra::shortestPath(b, a, cFunc, &res);
EXPECT(cost == 4);
cost = EDijkstra::shortestPath(c, a, cFunc, &res);
EXPECT(cost == 1);
cost = EDijkstra::shortestPath(a, c, cFunc, &res);
EXPECT(cost == 1);
cost = EDijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 2);
},
// ___________________________________________________________________________
CASE("Edge-based Dijkstra") {
DirGraph<int, int> g;
DirNode<int, int>* a = new DirNode<int, int>(1);
DirNode<int, int>* b = new DirNode<int, int>(4);
g.addNd(a);
g.addNd(b);
auto c = g.addNd(2);
auto d = g.addNd(3);
auto x = g.addNd();
g.addEdg(a, d, 4);
g.addEdg(a, c, 1);
g.addEdg(c, b, 1);
g.addEdg(b, d, 1);
struct CostFunc : public EDijkstra::CostFunc<int, int, int> {
int operator()(const Edge<int, int>* fr, const Node<int, int>* n,
const Edge<int, int>* to) const {
UNUSED(fr);
UNUSED(n);
return to->pl();
};
int inf() const { return 999; };
};
CostFunc cFunc;
EDijkstra::NList<int, int> res;
int cost = EDijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 3);
g.addEdg(c, d, 3);
cost = EDijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 3);
g.addEdg(a, b, 1);
g.addEdg(x, a, 1);
cost = EDijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 2);
},
// ___________________________________________________________________________
CASE("Dijkstra") {
DirGraph<int, int> g;
DirNode<int, int>* a = new DirNode<int, int>(1);
DirNode<int, int>* b = new DirNode<int, int>(0);
g.addNd(a);
g.addNd(b);
auto c = g.addNd();
auto d = g.addNd(4);
auto x = g.addNd();
g.addEdg(a, d, 4);
g.addEdg(a, c, 1);
g.addEdg(c, b, 1);
g.addEdg(b, d, 1);
struct CostFunc : public Dijkstra::CostFunc<int, int, int> {
int operator()(const Node<int, int>* fr, const Edge<int, int>* e,
const Node<int, int>* to) const {
UNUSED(fr);
UNUSED(to);
return e->pl();
};
int inf() const { return 999; };
};
CostFunc cFunc;
Dijkstra::NList<int, int> res;
int cost = Dijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 3);
EXPECT(res.size() == (size_t)4);
g.addEdg(c, d, 3);
cost = Dijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 3);
g.addEdg(a, b, 1);
g.addEdg(x, a, 1);
cost = Dijkstra::shortestPath(a, d, cFunc, &res);
EXPECT(cost == 2);
const std::set<Node<int, int>*> to{b, c, d, x};
std::unordered_map<Node<int, int>*, Dijkstra::EList<int, int>*> resEdges;
std::unordered_map<Node<int, int>*, Dijkstra::NList<int, int>*> resNodes;
for (auto n : to) {
resEdges[n] = new Dijkstra::EList<int, int>();
resNodes[n] = new Dijkstra::NList<int, int>();
}
auto costs = Dijkstra::shortestPath(a, to, cFunc, resEdges, resNodes);
EXPECT(costs[b] == 1);
EXPECT(costs[c] == 1);
EXPECT(costs[d] == 2);
EXPECT(costs[x] == 999);
},
// ___________________________________________________________________________
CASE("nullable") {
{
util::Nullable<std::string> nullable;
EXPECT(nullable.isNull());
}
{
util::Nullable<std::string> nullable(0);
EXPECT(nullable.isNull());
}
{
std::string str = "aa";
util::Nullable<std::string> nullable(&str);
EXPECT(!nullable.isNull());
EXPECT(nullable == "aa");
EXPECT(!(nullable == "aaa"));
EXPECT(!(nullable != "aa"));
EXPECT(nullable == "aa");
EXPECT(nullable.get() == "aa");
EXPECT(std::string(nullable) == "aa");
}
{
int a = 23;
util::Nullable<int> nullable(a);
util::Nullable<int> nullable2(24);
EXPECT(!nullable.isNull());
EXPECT(nullable == 23);
EXPECT(nullable >= 23);
EXPECT(nullable <= 23);
EXPECT(nullable < 24);
EXPECT(nullable < 24);
EXPECT(!(nullable < 22));
EXPECT(nullable != nullable2);
EXPECT(nullable < nullable2);
EXPECT(nullable2 > nullable);
util::Nullable<int> nullable3(nullable);
EXPECT(nullable == nullable3);
nullable3 = nullable2;
EXPECT(nullable2 == nullable3);
EXPECT(nullable3 == 24);
EXPECT(nullable2 == 24);
EXPECT(nullable2 == nullable2.get());
EXPECT(int(nullable2) == nullable2.get());
EXPECT(!nullable3.isNull());
EXPECT(!nullable2.isNull());
util::Nullable<int> voidnull;
EXPECT(voidnull.isNull());
EXPECT_THROWS(nullable == voidnull);
}
},
// ___________________________________________________________________________
CASE("geometry") {
}
};
// _____________________________________________________________________________
int main(int argc, char** argv) {
return(lest::run(specification, argc, argv));
}
Reference in a new issue View git blame Copy permalink