Voomra/trader
Archived
0
Fork 0
Code Activity

implement route searcher

Browse Source
This commit is contained in:
iMoHax
2015-05-21 14:54:55 +03:00
parent bf5f12e405
commit a549dce54a
28 changed files with 693 additions and 1392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
core/src/test/java/ru/trader/analysis/RouteFillerTest.java
View File

@@ -49,8 +49,8 @@ public class RouteFillerTest extends Assert {
v2.addOffer(OFFER_TYPE.BUY, ITEM2, 350, -1);
v2.addOffer(OFFER_TYPE.BUY, ITEM3, 400, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
return route;
}
@@ -91,9 +91,9 @@ public class RouteFillerTest extends Assert {
v3.addOffer(OFFER_TYPE.BUY, ITEM2, 350, -1);
v3.addOffer(OFFER_TYPE.BUY, ITEM3, 400, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
route.add(new RouteEntry(v3, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
route.add(new RouteEntry(v3, false, 0,0));
return route;
}
@@ -140,10 +140,10 @@ public class RouteFillerTest extends Assert {
v3.addOffer(OFFER_TYPE.BUY, ITEM1, 200, -1);
v4.addOffer(OFFER_TYPE.BUY, ITEM3, 450, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
route.add(new RouteEntry(v3, false, 0));
route.add(new RouteEntry(v4, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
route.add(new RouteEntry(v3, false, 0,0));
route.add(new RouteEntry(v4, false, 0,0));
return route;
}
@@ -222,11 +222,11 @@ public class RouteFillerTest extends Assert {
v4.addOffer(OFFER_TYPE.BUY, ITEM3, 370, -1);
v5.addOffer(OFFER_TYPE.BUY, ITEM1, 400, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
route.add(new RouteEntry(v3, false, 0));
route.add(new RouteEntry(v4, false, 0));
route.add(new RouteEntry(v5, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
route.add(new RouteEntry(v3, false, 0,0));
route.add(new RouteEntry(v4, false, 0,0));
route.add(new RouteEntry(v5, false, 0,0));
return route;
}
@@ -285,10 +285,10 @@ public class RouteFillerTest extends Assert {
v3.addOffer(OFFER_TYPE.BUY, ITEM1, 200, -1);
v4.addOffer(OFFER_TYPE.BUY, ITEM3, 450, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
route.add(new RouteEntry(v3, false, 0));
route.add(new RouteEntry(v4, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
route.add(new RouteEntry(v3, false, 0,0));
route.add(new RouteEntry(v4, false, 0,0));
return route;
}
@@ -367,8 +367,8 @@ public class RouteFillerTest extends Assert {
v2.addOffer(OFFER_TYPE.BUY, ITEM2, 225, -1);
Route route = new Route(new RouteEntry(v1, false, 0));
route.add(new RouteEntry(v2, false, 0));
Route route = new Route(new RouteEntry(v1, false, 0,0));
route.add(new RouteEntry(v2, false, 0,0));
return route;
@@ -384,9 +384,9 @@ public class RouteFillerTest extends Assert {
v3.addOffer(OFFER_TYPE.BUY, ITEM1, 200, -1);
v4.addOffer(OFFER_TYPE.BUY, ITEM3, 450, -1);
Route route = new Route(new RouteEntry(v2, false, 0));
route.add(new RouteEntry(v3, false, 0));
route.add(new RouteEntry(v4, false, 0));
Route route = new Route(new RouteEntry(v2, false, 0,0));
route.add(new RouteEntry(v3, false, 0,0));
route.add(new RouteEntry(v4, false, 0,0));
return route;
}

56
core/src/test/java/ru/trader/graph/RouteSearcherTest.java → core/src/test/java/ru/trader/analysis/RouteSearcherTest.java
View File

@@ -1,23 +1,35 @@
package ru.trader.graph;
package ru.trader.analysis;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import ru.trader.core.Market;
import ru.trader.core.Place;
import ru.trader.core.Vendor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.*;
import ru.trader.store.simple.Store;
import java.io.InputStream;
import java.util.List;
import java.util.stream.Collectors;
public class RouteSearcherTest extends Assert {
private static Market market;
public class RouteSearcherTest extends Assert{
private final static Logger LOG = LoggerFactory.getLogger(RouteSearcherTest.class);
private Market world;
private FilteredMarket fWorld;
private Place ithaca;
private Place lhs3262;
@Before
public void setUp() throws Exception {
InputStream is = getClass().getResourceAsStream("/world.xml");
market = Store.loadFromFile(is);
world = Store.loadFromFile(is);
ithaca = world.get("Ithaca");
lhs3262 = world.get("LHS 3262");
MarketFilter filter = new MarketFilter();
fWorld = new FilteredMarket(world, filter);
}
@Test
@@ -25,23 +37,24 @@ public class RouteSearcherTest extends Assert {
// Balance: 6000000, cargo: 440, tank: 40, distance: 13.4, jumps: 6
// Ithaca (Palladium to LHS 3262) -> Morgor -> LHS 3006 -> LHS 3262 (Consumer Technology to Ithaca) -> LHS 3006 -> Morgor -> Ithaca
// Profit: 981200, avg: 490600, distance: 67.5, lands: 2
Vendor ithaca = market.get().stream().filter((v)->v.getName().equals("Ithaca")).findFirst().get().get().iterator().next();
Vendor ithaca_st = ithaca.get().iterator().next();
Ship ship = new Ship();
ship.setCargo(440); ship.setTank(16);
ship.setEngine(5, 'A'); ship.setMass(466);
Profile profile = new Profile(ship);
profile.setBalance(6000000); profile.setJumps(6);
profile.setRoutesCount(10);
Scorer scorer = new Scorer(fWorld, profile);
RouteSearcher searcher = new RouteSearcher(13.4, 40);
RouteGraph graph = new RouteGraph(ithaca, market.getVendors(true), 40, 13.4, true, 6);
graph.setCargo(440);
graph.setBalance(6000000);
LOG.info("Start test routes");
RouteSearcher searcher = new RouteSearcher(scorer);
List<Path<Vendor>> epaths = graph.getPathsTo(ithaca, 10);
PathRoute expect = epaths.stream().map(p -> (PathRoute) p).findFirst().get();
List<PathRoute> apaths = searcher.getPaths(ithaca, ithaca, market.getVendors(true), 6, 6000000, 440, 10);
PathRoute actual = apaths.stream().findFirst().get();
assertTrue("Routes is different",expect.isRoute(actual));
List<Route> apaths = searcher.getRoutes(ithaca_st, ithaca_st, fWorld.getMarkets(true).collect(Collectors.toList()));
Route actual = apaths.stream().findFirst().get();
//assertTrue("Routes is different",expect.isRoute(actual));
}
/*
@Test
public void testRoutes2() throws Exception {
// Balance: 6000000, cargo: 440, tank: 40, distance: 13.6, jumps: 6
@@ -72,6 +85,5 @@ public class RouteSearcherTest extends Assert {
assertEquals("Routes is different",expect.getAvgProfit(), actual.getAvgProfit(), 0.00001);
}
*/
}

12
core/src/test/java/ru/trader/analysis/RouteTest.java
View File

@@ -28,9 +28,9 @@ public class RouteTest extends Assert {
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
Route path = new Route(new RouteEntry(v1, false, 0));
path.add(new RouteEntry(v2, false, 0));
path.add(new RouteEntry(v3, false, 0));
Route path = new Route(new RouteEntry(v1, false, 0,0));
path.add(new RouteEntry(v2, false, 0,0));
path.add(new RouteEntry(v3, false, 0,0));
TestUtil.assertCollectionContainAll(path.getVendors(), v1, v2, v3);
}
@@ -42,9 +42,9 @@ public class RouteTest extends Assert {
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
Route path = new Route(new RouteEntry(v1, false, 0));
path.add(new RouteEntry(v2, false, 0));
path.add(new RouteEntry(v3, false, 0));
Route path = new Route(new RouteEntry(v1, false, 0,0));
path.add(new RouteEntry(v2, false, 0,0));
path.add(new RouteEntry(v3, false, 0,0));
Collection<Vendor> vendors = new ArrayList<>();
Collections.addAll(vendors, v1, v2, v3);
assertTrue(path.contains(vendors));

78
core/src/test/java/ru/trader/analysis/VendorsGraphTest.java Normal file
View File

@@ -0,0 +1,78 @@
package ru.trader.analysis;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.analysis.graph.Crawler;
import ru.trader.analysis.graph.SimpleCollector;
import ru.trader.analysis.graph.Vertex;
import ru.trader.core.*;
import ru.trader.store.simple.Store;
import java.io.InputStream;
import java.util.stream.Collectors;
public class VendorsGraphTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(VendorsGraphTest.class);
private Market world;
private FilteredMarket fWorld;
private Place breksta;
private Place bhadaba;
private Place lhs1541;
private Place itza;
@Before
public void setUp() throws Exception {
InputStream is = getClass().getResourceAsStream("/test3.xml");
world = Store.loadFromFile(is);
breksta = world.get("Breksta");
bhadaba = world.get("Bhadaba");
lhs1541 = world.get("LHS 1541");
itza = world.get("Itza");
MarketFilter filter = new MarketFilter();
fWorld = new FilteredMarket(world, filter);
}
@Test
public void testBuild() throws Exception {
Vendor grantTerminal = breksta.get("Grant Terminal");
Vendor perezMarket = breksta.get("Perez market");
Vendor kandelRing = bhadaba.get("Kandel Ring");
Vendor robertsHub = bhadaba.get("Roberts Hub");
Vendor cabreraDock = lhs1541.get("Cabrera Dock");
Vendor hallerPort = lhs1541.get("Haller Port");
Vendor luikenPort = itza.get("Luiken Port");
Ship ship = new Ship();
ship.setCargo(24); ship.setEngine(2,'A');
Profile profile = new Profile(ship);
LOG.info("Start build test");
profile.setBalance(100000); profile.setJumps(6);
Scorer scorer = new Scorer(fWorld, profile);
LOG.info("Build vendors graph");
VendorsGraph vGraph = new VendorsGraph(scorer);
vGraph.build(cabreraDock, fWorld.getMarkets(true).collect(Collectors.toList()));
SimpleCollector<Vendor> paths = new SimpleCollector<>();
Crawler<Vendor> crawler = vGraph.crawler(paths::add);
crawler.findMin(cabreraDock, 100);
assertEquals(100, paths.get().size());
paths.clear();
Vertex<Vendor> x = vGraph.getRoot();
assertNotNull(x);
}
@After
public void tearDown() throws Exception {
world = null;
fWorld = null;
}
}

41
core/src/test/java/ru/trader/analysis/graph/CrawlerTest.java
View File

@@ -12,9 +12,7 @@ import ru.trader.core.Ship;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class CrawlerTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(CrawlerTest.class);
@@ -89,7 +87,7 @@ public class CrawlerTest extends Assert {
graph.build(x5, entrys);
// x5 <-> x4, x5 <-> x6
SimpleCollector paths = new SimpleCollector();
SimpleCollector<Point> paths = new SimpleCollector<>();
Crawler<Point> crawler = new CCrawler<>(graph, paths::add);
crawler.findMin(x4, 10);
assertPaths(paths.get(), PPath.of(x5, x4));
@@ -118,7 +116,7 @@ public class CrawlerTest extends Assert {
graph.build(x5, entrys);
// x5 <-> x4 <-> x3 <-> x2, x5 <-> x6 <-> x7 <-> x8
// x5 <-> x3, x4 <-> x2, x3 <-> x6, x4 <-> x6
SimpleCollector paths = new SimpleCollector();
SimpleCollector<Point> paths = new SimpleCollector<>();
Crawler<Point> crawler = new CCrawler<>(graph, paths::add);
crawler.findMin(x8, 10);
@@ -140,7 +138,7 @@ public class CrawlerTest extends Assert {
PPath.of(x5, x4, x6, x4), PPath.of(x5, x6, x3, x4),
PPath.of(x5, x3, x5, x4), PPath.of(x5, x4, x2, x4),
PPath.of(x5, x3, x2, x4), PPath.of(x5, x3, x6, x4)
);
);
TestUtil.assertCollectionEquals(paths.getWeights(), 5.0, 15.0, 15.0,
15.0, 15.0, 15.0,
25.0, 25.0,
@@ -182,7 +180,7 @@ public class CrawlerTest extends Assert {
graph.build(x5, entrys);
// x5 <-> x4 <- refill -> x3 <- refill -> x2, x5 <-> x6
// x5 <-> x3 <- refill -> x2, x5 <-> x4 <- refill -> x6
SimpleCollector paths = new SimpleCollector();
SimpleCollector<Point> paths = new SimpleCollector<>();
Crawler<Point> crawler = new CCrawler<>(graph, paths::add);
crawler.findMin(x1, 10);
@@ -225,7 +223,7 @@ public class CrawlerTest extends Assert {
// x5 <-> x6 <-> x4 <-refill -> x2
// x5 <-> x3 <- refill -> x2
// x5 <-> x4 <- refill -> x6
SimpleCollector paths = new SimpleCollector();
SimpleCollector<Point> paths = new SimpleCollector<>();
Crawler<Point> crawler = new CCrawler<>(graph, paths::add);
crawler.findMin(x1, 10);
@@ -268,33 +266,4 @@ public class CrawlerTest extends Assert {
entrys.clear();
}
private class SimpleCollector {
private List<List<Edge<Point>>> paths = new ArrayList<>();
public void add(List<Edge<Point>> path){
paths.add(path);
}
public List<List<Edge<Point>>> get() {
return paths;
}
public List<Edge<Point>> get(int index) {
if (index >= paths.size()) return Collections.emptyList();
return paths.get(index);
}
public void clear(){
paths.clear();
}
public double getWeight(int index){
if (index >= paths.size()) return 0;
return paths.get(index).stream().mapToDouble(Edge::getWeight).sum();
}
public Collection<Double> getWeights(){
return paths.stream().map(p -> p.stream().mapToDouble(Edge::getWeight).sum()).collect(Collectors.toList());
}
}
}

40
core/src/test/java/ru/trader/analysis/graph/SimpleCollector.java Normal file
View File

@@ -0,0 +1,40 @@
package ru.trader.analysis.graph;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
/**
* Created by Mo on 20.05.2015.
*/
public class SimpleCollector<T> {
private List<List<Edge<T>>> paths = new ArrayList<>();
public void add(List<Edge<T>> path){
paths.add(path);
}
public List<List<Edge<T>>> get() {
return paths;
}
public List<Edge<T>> get(int index) {
if (index >= paths.size()) return Collections.emptyList();
return paths.get(index);
}
public void clear(){
paths.clear();
}
public double getWeight(int index){
if (index >= paths.size()) return 0;
return paths.get(index).stream().mapToDouble(Edge::getWeight).sum();
}
public Collection<Double> getWeights(){
return paths.stream().map(p -> p.stream().mapToDouble(Edge::getWeight).sum()).collect(Collectors.toList());
}
}

321
core/src/test/java/ru/trader/graph/GraphTest.java
View File

@@ -1,321 +0,0 @@
package ru.trader.graph;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.TestUtil;
import java.util.ArrayList;
import java.util.Collection;
public class GraphTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(GraphTest.class);
private final static ArrayList<Point> entrys = new ArrayList<>();
private final static Point x1 = new Point("x1",-40);
private final static Point x2 = new Point("x2",-20);
private final static Point x3 = new Point("x3",-10, true);
private final static Point x4 = new Point("x4",-5, true);
private final static Point x5 = new Point("x5",0);
private final static Point x6 = new Point("x6",5);
private final static Point x7 = new Point("x7",20);
private final static Point x8 = new Point("x8",30);
private final static Point x9 = new Point("x9",40);
private final static Point x10 = new Point("x10",50);
@Before
public void setUp() throws Exception {
entrys.add(x1);
entrys.add(x2);
entrys.add(x3);
entrys.add(x4);
entrys.add(x5);
entrys.add(x6);
entrys.add(x7);
entrys.add(x8);
entrys.add(x9);
entrys.add(x10);
}
@Test
public void testBuild0() throws Exception {
LOG.info("Start graph build test0");
Graph<Point> graph = new Graph<>(x5, entrys, 4.9, 10);
// x5
assertFalse(graph.isAccessible(x1));
assertFalse(graph.isAccessible(x2));
assertFalse(graph.isAccessible(x3));
assertFalse(graph.isAccessible(x4));
assertTrue(graph.isAccessible(x5));
assertFalse(graph.isAccessible(x6));
assertFalse(graph.isAccessible(x7));
assertFalse(graph.isAccessible(x8));
assertFalse(graph.isAccessible(x9));
assertFalse(graph.isAccessible(x10));
}
@Test
public void testBuild1() throws Exception {
LOG.info("Start graph build test1");
Graph<Point> graph = new Graph<>(x5, entrys, 5.1, true, 2);
// x5 <-> x4 <-refill-> x3, x5 -> x6
assertFalse(graph.isAccessible(x1));
assertFalse(graph.isAccessible(x2));
assertTrue(graph.isAccessible(x3));
assertTrue(graph.isAccessible(x4));
assertTrue(graph.isAccessible(x5));
assertTrue(graph.isAccessible(x6));
assertFalse(graph.isAccessible(x7));
assertFalse(graph.isAccessible(x8));
assertFalse(graph.isAccessible(x9));
assertFalse(graph.isAccessible(x10));
Vertex<Point> x = graph.getVertex(x5);
// x5 -> x4, x5 -> x6
checkEdges(x, new Point[]{x4, x6}, new Point[]{x1, x2, x3, x7, x8, x9, x10});
// x4 -> x5
x = graph.getVertex(x4);
checkEdges(x, new Point[]{x5, x3}, new Point[]{x1, x2, x6, x7, x8, x9, x10});
// x6 <- x5
x = graph.getVertex(x6);
checkEdges(x, new Point[]{}, new Point[]{x1, x2, x3, x4, x5, x7, x8, x9, x10});
}
private void checkEdges(Vertex<Point> vertex, Point[] trueEdge, Point[] falseEdge){
for (Point point : trueEdge) {
assertTrue(String.format("%s must have edge to %s", vertex, point), vertex.isConnected(point));
}
for (Point point : falseEdge) {
assertFalse(String.format("%s must not have edge to %s", vertex, point), vertex.isConnected(point));
}
}
@Test
public void testBuild2() throws Exception {
LOG.info("Start graph build test2");
Graph<Point> graph = new Graph<>(x5, entrys, 5.1, 3);
// x5 <-> x4 <-> x3, x5 <-> x6
assertFalse(graph.isAccessible(x1));
assertFalse(graph.isAccessible(x2));
assertTrue(graph.isAccessible(x3));
assertTrue(graph.isAccessible(x4));
assertTrue(graph.isAccessible(x5));
assertTrue(graph.isAccessible(x6));
assertFalse(graph.isAccessible(x7));
assertFalse(graph.isAccessible(x8));
assertFalse(graph.isAccessible(x9));
assertFalse(graph.isAccessible(x10));
Vertex<Point> x = graph.getVertex(x5);
// x5 -> x4, x5 -> x6
checkEdges(x, new Point[]{x4, x6}, new Point[]{x1, x2, x3, x7, x8, x9, x10});
// x3 -> x4
x = graph.getVertex(x3);
checkEdges(x, new Point[]{x4}, new Point[]{x1, x2, x5, x6, x7, x8, x9, x10});
// x4 -> x5, x4 -> x3
x = graph.getVertex(x4);
checkEdges(x, new Point[]{x3, x5}, new Point[]{x1, x2, x6, x7, x8, x9, x10});
// x6 -> x5
x = graph.getVertex(x6);
checkEdges(x, new Point[]{x5}, new Point[]{x1, x2, x3, x4, x7, x8, x9, x10});
}
@Test
public void testBuild3() throws Exception {
LOG.info("Start graph build test3");
Graph<Point> graph = new Graph<>(x5, entrys, 5.1, 3);
// x5 <-> x4 <-> x3, x5 <-> x6
assertFalse(graph.isAccessible(x1));
assertFalse(graph.isAccessible(x2));
assertTrue(graph.isAccessible(x3));
assertTrue(graph.isAccessible(x4));
assertTrue(graph.isAccessible(x5));
assertTrue(graph.isAccessible(x6));
assertFalse(graph.isAccessible(x7));
assertFalse(graph.isAccessible(x8));
assertFalse(graph.isAccessible(x9));
assertFalse(graph.isAccessible(x10));
Vertex<Point> x = graph.getVertex(x5);
// x5 -> x4, x5 -> x6
checkEdges(x, new Point[]{x4, x6}, new Point[]{x1, x2, x3, x7, x8, x9, x10});
// x3 -> x4
x = graph.getVertex(x3);
checkEdges(x, new Point[]{x4}, new Point[]{x1, x2, x5, x6, x7, x8, x9, x10});
// x4 -> x5, x4 -> x3
x = graph.getVertex(x4);
checkEdges(x, new Point[]{x3, x5}, new Point[]{x1, x2, x6, x7, x8, x9, x10});
// x6 -> x5
x = graph.getVertex(x6);
checkEdges(x, new Point[]{x5}, new Point[]{x1, x2, x3, x4, x7, x8, x9, x10});
}
@Test
public void testBuild4() throws Exception {
LOG.info("Start graph build test4");
Graph<Point> graph = new Graph<>(x5, entrys, 15.1, 3);
// x5 <-> x4 <-> x3 -> x2, x5 <-> x6 <-> x7 -> x8
// x5 <-> x3, x5 <-> x4 <-> x2, x3 <-> x6, x4 <-> x6
assertFalse(graph.isAccessible(x1));
assertTrue(graph.isAccessible(x2));
assertTrue(graph.isAccessible(x3));
assertTrue(graph.isAccessible(x4));
assertTrue(graph.isAccessible(x5));
assertTrue(graph.isAccessible(x6));
assertTrue(graph.isAccessible(x7));
assertTrue(graph.isAccessible(x8));
assertFalse(graph.isAccessible(x9));
assertFalse(graph.isAccessible(x10));
Vertex<Point> x = graph.getVertex(x5);
// x5 -> x4, x5 -> x3, x5 -> x6
checkEdges(x, new Point[]{x3, x4, x6}, new Point[]{x1, x2, x7, x8, x9, x10});
// x2 -> x3, x2 -> x4
x = graph.getVertex(x2);
checkEdges(x, new Point[]{x3, x4}, new Point[]{x1, x5, x6, x7, x8, x9, x10});
// x3 -> x4, x3 -> x2, x3 -> x5, x3 -> x6
x = graph.getVertex(x3);
checkEdges(x, new Point[]{x2, x4, x5, x6}, new Point[]{x1, x7, x8, x9, x10});
// x4 -> x5, x4 -> x3, x4 -> x2, x4 -> x6
x = graph.getVertex(x4);
checkEdges(x, new Point[]{x2, x3, x5, x6}, new Point[]{x1, x7, x8, x9, x10});
// x6 -> x5, x6 -> x7, x6 -> x3, x6 -> x4
x = graph.getVertex(x6);
checkEdges(x, new Point[]{x5, x7, x3, x4}, new Point[]{x1, x2, x8, x9, x10});
// x7 -> x6, x7 -> x8
x = graph.getVertex(x7);
checkEdges(x, new Point[]{x6, x8}, new Point[]{x1, x2, x3, x4, x5, x9, x10});
// x8 <- x7
x = graph.getVertex(x8);
checkEdges(x, new Point[]{}, new Point[]{x1, x2, x3, x4, x5, x6, x7, x9, x10});
}
@Test
public void testGetPaths() throws Exception {
LOG.info("Start get paths test");
Graph<Point> graph = new Graph<>(x5, entrys, 5.1, 2);
// x5 <-> x4, x5 <-> x6
Collection<Path<Point>> paths = graph.getPathsTo(x4);
TestUtil.assertCollectionEquals(paths, Path.toPath(x5, x4));
paths = graph.getPathsTo(x6);
TestUtil.assertCollectionEquals(paths, Path.toPath(x5, x6));
paths = graph.getPathsTo(x7);
assertEquals(paths.size(), 0);
}
@Test
public void testGetPaths2() throws Exception {
LOG.info("Start get paths test2");
Graph<Point> graph = new Graph<>(x5, entrys, 15.1, 3);
// x5 <-> x4 <-> x3 <-> x2, x5 <-> x6 <-> x7 <-> x8
// x5 <-> x3, x4 <-> x2, x3 <-> x6, x4 <-> x6
Collection<Path<Point>> paths = graph.getPathsTo(x8);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x6, x7, x8));
paths = graph.getPathsTo(x7);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x6, x7), Path.toPath(x5, x4, x6, x7), Path.toPath(x5, x3, x6, x7));
paths = graph.getPathsTo(x7, 1);
assertEquals(1, paths.size());
TestUtil.assertCollectionContainAny(paths, Path.toPath(x5, x6, x7), Path.toPath(x5, x4, x6, x7), Path.toPath(x5, x3, x6, x7));
paths = graph.getPathsTo(x4);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x4), Path.toPath(x5, x6, x4), Path.toPath(x5, x3, x4),
Path.toPath(x5, x3, x5, x4), Path.toPath(x5, x6, x3, x4), Path.toPath(x5, x3, x2, x4), Path.toPath(x5, x3, x6, x4),
Path.toPath(x5, x6, x5, x4));
paths = graph.getPathsTo(x5);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x4, x5), Path.toPath(x5, x4, x6, x5), Path.toPath(x5, x4, x3, x5),
Path.toPath(x5, x6, x5), Path.toPath(x5, x6, x4, x5), Path.toPath(x5, x6, x3, x5), Path.toPath(x5, x3, x5),
Path.toPath(x5, x3, x4, x5), Path.toPath(x5, x3, x6, x5));
Path<Point> fast = graph.getFastPathTo(x8);
assertEquals(fast, Path.toPath(x5, x6, x7, x8));
fast = graph.getFastPathTo(x7);
assertEquals(fast, Path.toPath(x5, x6, x7));
fast = graph.getFastPathTo(x4);
assertEquals(fast, Path.toPath(x5, x4));
}
@Test
public void testGetRefillPaths() throws Exception {
LOG.info("Start get refill paths");
Graph<Point> graph = new Graph<>(x5, entrys, 10.1, 3);
// x5 <-> x4 <- refill -> x3 <- refill -> x2, x5 <-> x6
// x5 <-> x3 <- refill -> x2, x5 <-> x4 <- refill -> x6
Collection<Path<Point>> paths = graph.getPathsTo(x1);
assertTrue(paths.isEmpty());
paths = graph.getPathsTo(x2);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x4, x3, x2), Path.toPath(x5, x3, x2));
paths = graph.getPathsTo(x6);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x6), Path.toPath(x5, x4, x6), Path.toPath(x5, x3, x5, x6),
Path.toPath(x5, x4, x5, x6), Path.toPath(x5, x3, x4, x6));
Path<Point> fast = graph.getFastPathTo(x2);
assertEquals(fast, Path.toPath(x5, x3, x2));
}
@Test
public void testGetRefillPaths2() throws Exception {
LOG.info("Start get refill paths 2 ");
Graph<Point> graph = new Graph<>(x5, entrys, 15.1, true, 4);
// x5 <-> x4 <-> x3 - refill -> x2,
// x5 <-> x6 <-> x4 <-refill -> x2
// x5 <-> x3 <- refill -> x2
// x5 <-> x4 <- refill -> x6
Collection<Path<Point>> paths = graph.getPathsTo(x1);
assertTrue(paths.isEmpty());
paths = graph.getPathsTo(x2);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x3, x4, x2), Path.toPath(x5, x3, x2),
Path.toPath(x5, x4, x3, x2), Path.toPath(x5, x4, x2), Path.toPath(x5, x3, x5, x4, x2),
Path.toPath(x5, x6, x4, x2), Path.toPath(x5, x6, x4, x3, x2), Path.toPath(x5, x4, x3, x4, x2),
Path.toPath(x5, x4, x5, x4, x2), Path.toPath(x5, x6, x5, x4, x2), Path.toPath(x5, x3, x4, x3, x2));
paths = graph.getPathsTo(x6);
TestUtil.assertCollectionContainAll(paths, Path.toPath(x5, x6), Path.toPath(x5, x4, x6),
Path.toPath(x5, x3, x4, x6), Path.toPath(x5, x3, x6), Path.toPath(x5, x4, x3, x6),
Path.toPath(x5, x3, x4, x3, x6), Path.toPath(x5, x3, x4, x5, x6), Path.toPath(x5, x3, x5, x6),
Path.toPath(x5, x3, x5, x4, x6), Path.toPath(x5, x4, x3, x4, x6), Path.toPath(x5, x4, x3, x5, x6),
Path.toPath(x5, x4, x5, x6), Path.toPath(x5, x4, x5, x4, x6));
paths = graph.getPathsTo(x7);
assertTrue(paths.isEmpty());
Path<Point> fast = graph.getFastPathTo(x2);
assertEquals(fast, Path.toPath(x5, x3, x2));
}
@After
public void tearDown() throws Exception {
entrys.clear();
}
}

488
core/src/test/java/ru/trader/graph/PathRouteTest.java
View File

@@ -1,488 +0,0 @@
package ru.trader.graph;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.TestUtil;
import ru.trader.core.*;
import ru.trader.store.simple.SimpleItem;
import ru.trader.store.simple.SimpleOffer;
import ru.trader.store.simple.SimpleVendor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class PathRouteTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(PathRouteTest.class);
private final static Item ITEM1 = new SimpleItem("ITEM1");
private final static Item ITEM2 = new SimpleItem("ITEM2");
private final static Item ITEM3 = new SimpleItem("ITEM3");
private static Vendor v1;
private static Vendor v2;
private static Vendor v3;
private static Vendor v4;
private static Vendor v5;
private PathRoute initTest1(){
LOG.info("Init test 1");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
}
@Test
public void testPathRoute1() throws Exception {
LOG.info("Start path route test 1");
PathRoute path = initTest1();
assertEquals(1000, path.getProfit(), 0.0001);
assertEquals(1, path.getLandsCount());
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v2.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 5);
Order order3 = new Order(v1.getSell(ITEM3), v2.getBuy(ITEM3), 5);
assertEquals(10000, path.getBalance(), 0.0001);
assertEquals(1000, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order1, order2, order3, PathRoute.TRANSIT);
}
private PathRoute initTest2(){
LOG.info("Init test 2");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 300, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 350, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 400, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
}
@Test
public void testPathRoute2() throws Exception {
LOG.info("Start path route test 2");
PathRoute path = initTest2();
assertEquals(1000, path.getProfit(), 0.0001);
assertEquals(1, path.getLandsCount());
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order2 = new Order(v2.getSell(ITEM2), v3.getBuy(ITEM2), 5);
Order order3 = new Order(v1.getSell(ITEM3), v3.getBuy(ITEM3), 5);
assertEquals(10000, path.getBalance(), 0.0001);
assertEquals(1000, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order1, PathRoute.TRANSIT, order3);
path = path.getNext();
orders = path.getOrders();
assertEquals(10000, path.getBalance(), 0.0001);
assertEquals(750, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order2, PathRoute.TRANSIT);
}
private PathRoute initTest3(){
LOG.info("Init test 3");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, -1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, -1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
}
@Test
public void testPathRoute3() throws Exception {
LOG.info("Start path route test 3");
PathRoute path = initTest3();
assertEquals(800, path.getProfit(), 0.0001);
assertEquals(2, path.getLandsCount());
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 5);
Order order3 = new Order(v1.getSell(ITEM3), v4.getBuy(ITEM3), 5);
Order order4 = new Order(v2.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order5 = new Order(v2.getSell(ITEM3), v4.getBuy(ITEM3), 5);
Order order7 = new Order(v3.getSell(ITEM3), v4.getBuy(ITEM3), 5);
assertEquals(10000, path.getBalance(), 0.0001);
assertEquals(800, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order1, order2, order3, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(10125, path.getBalance(), 0.0001);
assertEquals(650, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order5, order4, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(10500, path.getBalance(), 0.0001);
assertEquals(300, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order7, PathRoute.TRANSIT);
}
private PathRoute initTest4(){
LOG.info("Init test 4");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v5 = new SimpleVendor("v5",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 410, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 270, -1));
v4.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 470, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 300, -1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 370, -1));
v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 400, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
res = (PathRoute) res.connectTo(new Vertex<>(v5), false);
res.finish();
res.sort(10000, 5);
return res.getRoot();
}
@Test
public void testPathRoute4() throws Exception {
LOG.info("Start path route test 4");
PathRoute path = initTest4();
assertEquals(1000, path.getProfit(), 0.0001);
assertEquals(3, path.getLandsCount());
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v2.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM1), v5.getBuy(ITEM1), 5);
Order order3 = new Order(v1.getSell(ITEM2), v3.getBuy(ITEM2), 5);
Order order4 = new Order(v1.getSell(ITEM3), v4.getBuy(ITEM3), 5);
Order order5 = new Order(v2.getSell(ITEM2), v3.getBuy(ITEM2), 5);
Order order6 = new Order(v4.getSell(ITEM1), v5.getBuy(ITEM1), 5);
assertEquals(10000, path.getBalance(), 0.0001);
assertEquals(1000, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order3, order1, order4, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(10300, path.getBalance(), 0.0001);
assertEquals(650, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order5, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(10500, path.getBalance(), 0.0001);
assertEquals(500, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(10500, path.getBalance(), 0.0001);
assertEquals(500, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order6, PathRoute.TRANSIT);
}
private PathRoute initTest5(){
LOG.info("Init test 5");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, -1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, -1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
res.finish();
res.sort(500, 5);
return res.getRoot();
}
@Test
public void testPathRoute5() throws Exception {
LOG.info("Start path route test 5");
PathRoute path = initTest5();
assertEquals(620, path.getProfit(), 0.0001);
assertEquals(2, path.getLandsCount());
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 2);
Order order3 = new Order(v1.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order4 = new Order(v2.getSell(ITEM1), v3.getBuy(ITEM1), 3);
Order order5 = new Order(v2.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order7 = new Order(v3.getSell(ITEM3), v4.getBuy(ITEM3), 2);
assertEquals(500, path.getBalance(), 0.0001);
assertEquals(620, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order1, order2, PathRoute.TRANSIT, order3);
path = path.getNext();
orders = path.getOrders();
assertEquals(550, path.getBalance(), 0.0001);
assertEquals(270, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order4, order5, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(1000, path.getBalance(), 0.0001);
assertEquals(120, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order7, PathRoute.TRANSIT);
}
private PathRoute initTest6A(){
LOG.info("Init test 6A");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,1,0);
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, -1));
PathRoute res = new PathRoute(new Vertex<>(v1));
res = (PathRoute) res.connectTo(new Vertex<>(v2), false);
res.finish();
res.sort(500, 5);
return res.getRoot();
}
private PathRoute initTest6B(double balance){
LOG.info("Init test 6B");
v3 = new SimpleVendor("v3",0,1,1);
v4 = new SimpleVendor("v4",1,1,1);
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, -1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, -1));
PathRoute res = new PathRoute(new Vertex<>(v2));
res = (PathRoute) res.connectTo(new Vertex<>(v3), false);
res = (PathRoute) res.connectTo(new Vertex<>(v4), false);
res.finish();
res.sort(balance, 5);
return res.getRoot();
}
@Test
public void testAddPathRoute() throws Exception {
LOG.info("Start add path route test");
PathRoute path = initTest6A();
PathRoute pathB = initTest6B(500);
path.getEnd().add(pathB, false);
path.sort(500, 5);
path = path.getRoot();
assertEquals(620, path.getProfit(), 0.0001);
assertEquals(2, path.getLandsCount());
assertEquals(3, path.getDistance(), 0.0001);
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 2);
Order order3 = new Order(v1.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order4 = new Order(v2.getSell(ITEM1), v3.getBuy(ITEM1), 3);
Order order5 = new Order(v2.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order7 = new Order(v3.getSell(ITEM3), v4.getBuy(ITEM3), 2);
assertEquals(500, path.getBalance(), 0.0001);
assertEquals(620, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order1, order2, PathRoute.TRANSIT, order3);
path = path.getNext();
orders = path.getOrders();
assertEquals(550, path.getBalance(), 0.0001);
assertEquals(270, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order4, order5, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(1000, path.getBalance(), 0.0001);
assertEquals(120, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order7, PathRoute.TRANSIT);
}
@Test
public void testAddPathRouteNoSort() throws Exception {
LOG.info("Start add path route test");
PathRoute path = initTest6A();
PathRoute pathB = initTest6B(550);
path.getEnd().add(pathB, true);
path = path.getRoot();
assertEquals(260, path.getProfit(), 0.0001);
assertEquals(3, path.getLandsCount());
assertEquals(3, path.getDistance(), 0.0001);
path = path.getNext();
Collection<Order> orders = path.getOrders();
Order order1 = new Order(v1.getSell(ITEM1), v3.getBuy(ITEM1), 5);
Order order2 = new Order(v1.getSell(ITEM2), v2.getBuy(ITEM2), 2);
Order order3 = new Order(v1.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order4 = new Order(v2.getSell(ITEM1), v3.getBuy(ITEM1), 3);
Order order5 = new Order(v2.getSell(ITEM3), v4.getBuy(ITEM3), 1);
Order order7 = new Order(v3.getSell(ITEM3), v4.getBuy(ITEM3), 1);
assertEquals(500, path.getBalance(), 0.0001);
assertEquals(260, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order2, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(550, path.getBalance(), 0.0001);
assertEquals(210, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order4, order5, PathRoute.TRANSIT);
path = path.getNext();
orders = path.getOrders();
assertEquals(700, path.getBalance(), 0.0001);
assertEquals(60, path.getProfit(), 0.0001);
TestUtil.assertCollectionEquals(orders, order7, PathRoute.TRANSIT);
}
@Test
public void testEntries() throws Exception {
LOG.info("Start test get entries");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
PathRoute path = new PathRoute(new Vertex<>(v1));
path = (PathRoute) path.connectTo(new Vertex<>(v2), false);
path = (PathRoute) path.connectTo(new Vertex<>(v3), false);
path.finish();
TestUtil.assertCollectionContainAll(path.getEntries(), v1, v2, v3);
}
@Test
public void testContains() throws Exception {
LOG.info("Start test get entries");
v1 = new SimpleVendor("v1",0,0,0);
v2 = new SimpleVendor("v2",0,0,0);
v3 = new SimpleVendor("v3",0,0,0);
v4 = new SimpleVendor("v4",0,0,0);
PathRoute path = new PathRoute(new Vertex<>(v1));
path = (PathRoute) path.connectTo(new Vertex<>(v2), false);
path = (PathRoute) path.connectTo(new Vertex<>(v3), false);
path.finish();
Collection<Vendor> vendors = new ArrayList<>();
Collections.addAll(vendors, v1, v2, v3);
assertTrue(path.contains(vendors));
vendors.clear();
Collections.addAll(vendors, v2);
assertTrue(path.contains(vendors));
vendors.clear();
Collections.addAll(vendors, v4);
assertFalse(path.contains(vendors));
vendors.clear();
Collections.addAll(vendors, v3, v2, v4, v1);
assertFalse(path.contains(vendors));
vendors.clear();
Collections.addAll(vendors, v1, v2, v3, v4);
assertFalse(path.contains(vendors));
}
}

113
core/src/test/java/ru/trader/graph/RouteGraphTest.java
View File

@@ -1,113 +0,0 @@
package ru.trader.graph;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.trader.core.*;
import ru.trader.store.simple.*;
import java.util.ArrayList;
public class RouteGraphTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(RouteGraphTest.class);
private final static Market market = new SimpleMarket();
private final static Item ITEM1 = new SimpleItem("ITEM1");
private final static Item ITEM2 = new SimpleItem("ITEM2");
private final static Item ITEM3 = new SimpleItem("ITEM3");
private final static Item ITEM4 = new SimpleItem("ITEM4");
private final static Item ITEM5 = new SimpleItem("ITEM5");
private static Vendor v1;
private static Vendor v2;
private static Vendor v3;
private static Vendor v4;
private static Vendor v5;
private static Vendor v6;
private static Place p1;
private static Place p2;
private static Place p3;
private static Place p4;
private static Place p5;
static {
p1 = new SimplePlace("v1");
p2 = new SimplePlace("v2");
p3 = new SimplePlace("v3");
p4 = new SimplePlace("v4");
p5 = new SimplePlace("p5",5,5,5);
v1 = new SimpleVendor("v1");
v2 = new SimpleVendor("v2");
v3 = new SimpleVendor("v3");
v4 = new SimpleVendor("v4");
v5 = new SimpleVendor("v5");
v6 = new SimpleVendor("v6");
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 100, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM2, 200, -1));
v1.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 300, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM1, 150, -1));
v2.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 320, -1));
v3.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM3, 390, -1));
v5.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM4, 100, -1));
v6.add(new SimpleOffer(OFFER_TYPE.SELL, ITEM5, 100, -1));
v2.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM2, 225, -1));
v3.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM1, 200, -1));
v4.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM3, 450, -1));
v5.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM5, 500, -1));
v6.add(new SimpleOffer(OFFER_TYPE.BUY, ITEM4, 500, -1));
p1.add(v1);p2.add(v2);p3.add(v3);p4.add(v4);p5.add(v5);p5.add(v6);
market.add(p1);market.add(p2);market.add(p3);market.add(p4);market.add(p5);
}
@Test
public void testRoutes() throws Exception {
RouteGraph graph = new RouteGraph(v1, market.getVendors(true), 1, 1, true, 4);
graph.setBalance(500);
graph.setCargo(5);
//Profit: 150 180 200 230 670 620 950 890 620 950 1015 1180 890 950 930
//Landings: 1 2 3 4 4 2 3 3 2 3 4 4 3 3 4
//Prof: 150 90 66.66 57.5 167.5 310 316.66 296.66 310 316.66 253.75 295 296.66 316.66 232.5
ArrayList<Path<Vendor>> routes = (ArrayList<Path<Vendor>>) graph.getPathsTo(v4, 5);
assertEquals(5, routes.size());
PathRoute path = (PathRoute) routes.get(0).getRoot();
assertEquals(950, path.getProfit(), 0.001);
assertEquals(3, path.getLandsCount());
path = (PathRoute) routes.get(1).getRoot();
assertEquals(950, path.getProfit(), 0.001);
assertEquals(3, path.getLandsCount());
path = (PathRoute) routes.get(2).getRoot();
assertEquals(950, path.getProfit(), 0.001);
assertEquals(3, path.getLandsCount());
path = (PathRoute) routes.get(3).getRoot();
assertEquals(620, path.getProfit(), 0.001);
assertEquals(2, path.getLandsCount());
path = (PathRoute) routes.get(4).getRoot();
assertEquals(620, path.getProfit(), 0.001);
assertEquals(2, path.getLandsCount());
}
@Test
public void testRoutes2() throws Exception {
RouteGraph graph = new RouteGraph(v5, market.getVendors(true), 1, 15, true, 4);
graph.setBalance(500);
graph.setCargo(5);
ArrayList<Path<Vendor>> routes = (ArrayList<Path<Vendor>>) graph.getPathsTo(v1, 5);
assertEquals(5, routes.size());
//v5 -> v6 -> v5 -> v6 -> v1
PathRoute path = (PathRoute) routes.get(0).getRoot();
assertEquals(6000, path.getProfit(), 0.001);
assertEquals(4, path.getLandsCount());
}
}

87
core/src/test/java/ru/trader/graph/TopListTest.java
View File

@@ -1,87 +0,0 @@
package ru.trader.graph;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
public class TopListTest extends Assert {
private static final Function<Integer, Integer> getGroup = (o1) -> Math.floorDiv(o1, 10);
private static final Comparator<Integer> groupcomp = (o1, o2) -> {
int cmp = Integer.compare(getGroup.apply(o1), getGroup.apply(o2));
if (cmp !=0 ) return cmp;
return o1.compareTo(o2);
};
private void add(List<Integer> list, Integer entry){
TopList.addToGroupTop(list, entry, 10, groupcomp, getGroup, 1);
}
@Test
public void testAddToGroup() throws Exception {
ArrayList<Integer> top = new ArrayList<>(10);
add(top, 5);
add(top, 15);
add(top, 22);
add(top, 34);
add(top, 36);
add(top, 21);
add(top, 7);
add(top, 6);
add(top, 3);
assertEquals(4, top.size());
assertEquals(3, top.get(0).intValue());
assertEquals(15, top.get(1).intValue());
assertEquals(21, top.get(2).intValue());
assertEquals(34, top.get(3).intValue());
}
@Test
public void testAddToGroup2() throws Exception {
ArrayList<Integer> top = new ArrayList<>(10);
add(top, 36);
add(top, 15);
add(top, 22);
add(top, 6);
add(top, 34);
add(top, 5);
add(top, 21);
add(top, 7);
add(top, 3);
assertEquals(4, top.size());
assertEquals(3, top.get(0).intValue());
assertEquals(15, top.get(1).intValue());
assertEquals(21, top.get(2).intValue());
assertEquals(34, top.get(3).intValue());
}
@Test
public void testAddToGroup3() throws Exception {
ArrayList<Integer> top = new ArrayList<>(10);
add(top, 21);
add(top, 34);
add(top, 36);
add(top, 3);
add(top, 15);
add(top, 22);
add(top, 6);
add(top, 34);
add(top, 5);
add(top, 7);
assertEquals(4, top.size());
assertEquals(3, top.get(0).intValue());
assertEquals(15, top.get(1).intValue());
assertEquals(21, top.get(2).intValue());
assertEquals(34, top.get(3).intValue());
}
}

30
core/src/test/java/ru/trader/graph/VertexTest.java
View File

@@ -1,30 +0,0 @@
package ru.trader.graph;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class VertexTest extends Assert {
private final static Logger LOG = LoggerFactory.getLogger(VertexTest.class);
private final static Point x1 = new Point("x1",1);
private final static Point x2 = new Point("x2",4);
private final static Point x3 = new Point("x3",-2);
private final static Point x4 = new Point("x4",5);
@Test
public void testContains() throws Exception {
LOG.info("Start vertex contains test");
Vertex<Point> vertex = new Vertex<>(x1);
vertex.addEdge(new Edge<>(vertex, new Vertex<>(x2)));
vertex.addEdge(new Edge<>(vertex, x3));
assertFalse("Vertex must contains entry",vertex.isConnected(x1));
assertTrue("Vertex must contains entry",vertex.isConnected(new Vertex<>(x3)));
assertTrue("Vertex must contains entry",vertex.isConnected(x2));
assertFalse("Vertex not must contains entry", vertex.isConnected(new Vertex<>(x4)));
}
}

2
core/src/test/resources/log4j.properties
View File

@@ -4,4 +4,4 @@ log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%p: %d{dd.MM.yyyy HH:mm:ss} (%F:%L) - %m%n
#log4j.logger.ru.trader.analysis.graph.Crawler = TRACE
log4j.logger.ru.trader.analysis.graph = TRACE