implement berkeley bd

core/src/main/java/ru/trader/store/berkeley/BDBItemStat.java

@@ -1,31 +1,94 @@
 package ru.trader.store.berkeley;
 
-import ru.trader.core.AbstractItemStat;
+import org.slf4j.Logger;
-import ru.trader.core.Item;
+import org.slf4j.LoggerFactory;
-import ru.trader.core.OFFER_TYPE;
+import ru.trader.core.*;
-import ru.trader.core.Offer;
 
+import java.util.Collections;
 import java.util.NavigableSet;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.DoubleAdder;
 
 
-//TODO: implement
 public class BDBItemStat extends AbstractItemStat {
+    private final static Logger LOG = LoggerFactory.getLogger(BDBItemStat.class);
+
     private final ItemProxy item;
     private final OFFER_TYPE type;
     private final BDBStore store;
+    private NavigableSet<Offer> offers;
+    private volatile double sum;
+    private volatile double avg;
+    private AtomicLong count;
+
 
     public BDBItemStat(ItemProxy item, OFFER_TYPE type, BDBStore store) {
         this.item = item;
         this.type = type;
         this.store = store;
+        offers = new TreeSet<>(store.getOfferAccessor().getAllByItem(item.getId(), type));
+        this.sum = 0;
+        this.avg = Double.NaN;
+        this.count = new AtomicLong(0);
+        init();
+    }
+
+    void init(){
+        sum = 0;
+        count.set(0);
+        offers.forEach(o -> {
+            sum += o.getPrice();
+            count.incrementAndGet();
+        });
+        avg = sum / count.get();
     }
 
     synchronized void put(Offer offer){
+        LOG.trace("Put offer {} to item stat {}", offer, this);
+        assert offer.hasType(type) && offer.hasItem(item);
+        double price = offer.getPrice();
+        sum += price;
+        avg = sum / count.incrementAndGet();
+        if (offers != null){
+            offers.add(offer);
+        }
+        LOG.trace("After this = {}", this);
     }
 
     synchronized void remove(Offer offer){
+        LOG.trace("Remove offer {} from item stat {}", offer, this);
+        assert offer.hasType(type) && offer.hasItem(item);
+        double price = offer.getPrice();
+        sum -= price;
+        if (count.decrementAndGet() > 0){
+            avg = sum / count.get();
+        } else {
+            sum = 0; avg = Double.NaN;
+        }
+        if (offers != null){
+            offers.remove(offer);
+        }
+        LOG.trace("After this = {}", this);
     }
 
+    @Override
+    protected synchronized void updatePrice(AbstractOffer offer, double price) {
+        LOG.trace("Update offer {} from item stat {}", offer, this);
+        assert offer.hasType(type) && offer.hasItem(item);
+        double oldPrice = offer.getPrice();
+        if (offers != null){
+            offers.remove(offer);
+        }
+        super.updatePrice(offer, price);
+        if (offers != null){
+            offers.add(offer);
+        }
+        sum += price - oldPrice;
+        avg = sum / offers.size();
+        LOG.trace("After update this = {}", this);
+    }
 
     @Override
     public OFFER_TYPE getType() {
@@ -39,31 +102,69 @@ public class BDBItemStat extends AbstractItemStat {
 
     @Override
     public Offer getMin() {
-        return null;
+        if (count.get() == 0) return getFake();
+        return offers.first();
     }
 
     @Override
     public double getAvg() {
-        return 0;
+        return avg;
     }
 
     @Override
     public Offer getMax() {
-        return null;
+        if (offers.isEmpty()) return getFake();
+        return offers.last();
     }
 
     @Override
     public Offer getBest() {
-        return null;
+        if (offers.isEmpty()) return getFake();
+        return type.getOrder() > 0 ? offers.first() : offers.last();
     }
 
     @Override
     public NavigableSet<Offer> getOffers() {
-        return null;
+        return Collections.unmodifiableNavigableSet(offers);
     }
 
     @Override
     public boolean isEmpty() {
-        return false;
+        return count.get() == 0;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBItemStat)) return false;
+
+        BDBItemStat itemStat = (BDBItemStat) o;
+        return type == itemStat.type && item.equals(itemStat.item);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = item.hashCode();
+        result = 31 * result + type.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("{");
+        sb.append(getItem());
+        sb.append(", ").append(getType());
+        if (BDBItemStat.LOG.isTraceEnabled()){
+            sb.append(", count=").append(offers.size());
+            sb.append(", sum=").append(sum);
+        }
+        sb.append(", avg=").append(getAvg());
+        sb.append(", best=").append(getBest());
+        sb.append(", min=").append(getMin());
+        sb.append(", max=").append(getMax());
+
+        sb.append("}");
+        return sb.toString();
+    }
+
 }

core/src/main/java/ru/trader/store/berkeley/BDBMarket.java

@@ -1,5 +1,7 @@
 package ru.trader.store.berkeley;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.trader.core.*;
 import ru.trader.store.berkeley.entities.BDBGroup;
 import ru.trader.store.berkeley.entities.BDBItem;
@@ -8,12 +10,17 @@ import ru.trader.store.berkeley.entities.BDBPlace;
 import java.util.*;
 
 public class BDBMarket extends AbstractMarket {
+    private final static Logger LOG = LoggerFactory.getLogger(BDBMarket.class);
     private final BDBStore store;
 
     //caching
     private final Map<Item,BDBItemStat> sellItems = new HashMap<>();
     private final Map<Item,BDBItemStat> buyItems = new HashMap<>();
 
+    public BDBMarket(BDBStore store) {
+        this.store = store;
+        store.setMarket(this);
+    }
 
     private Map<Item,BDBItemStat> getItemCache(OFFER_TYPE offerType){
         switch (offerType) {
@@ -30,8 +37,9 @@ public class BDBMarket extends AbstractMarket {
         if (entry == null){
             entry = new BDBItemStat((ItemProxy) item, offer.getType(), store);
             cache.put(item, entry);
+        } else {
+            entry.put(offer);
         }
-        entry.put(offer);
     }
 
     private void remove(Map<Item, BDBItemStat> cache, Offer offer){
@@ -44,10 +52,6 @@ public class BDBMarket extends AbstractMarket {
         }
     }
 
-    public BDBMarket(BDBStore store) {
-        this.store = store;
-    }
-
     @Override
     protected Place createPlace(String name, double x, double y, double z) {
         return new PlaceProxy(new BDBPlace(name, x, y, z), store);
@@ -70,6 +74,9 @@ public class BDBMarket extends AbstractMarket {
 
     @Override
     protected void removePlace(Place place) {
+        for (Vendor vendor : place.get()) {
+            onRemove(vendor);
+        }
         store.getPlaceAccessor().delete(((PlaceProxy) place).getEntity());
     }
 
@@ -91,6 +98,8 @@ public class BDBMarket extends AbstractMarket {
     @Override
     protected void removeItem(Item item) {
         store.getItemAccessor().delete(((ItemProxy) item).getEntity());
+        sellItems.remove(item);
+        buyItems.remove(item);
     }
 
     @Override
@@ -110,8 +119,50 @@ public class BDBMarket extends AbstractMarket {
 
     @Override
     public ItemStat getStat(OFFER_TYPE type, Item item) {
-        //TODO: добавить
+        ItemStat entry = getItemCache(type).get(item);
-        return null;
+        if (entry == null){
+            entry = new BDBItemStat((ItemProxy) item, type, store);
+            getItemCache(type).put(item, (BDBItemStat) entry);
+        }
+        return entry;
+    }
+
+    @Override
+    protected void onAdd(Vendor vendor) {
+        LOG.trace("Cached on add vendor {}", vendor);
+        Collection<Offer> offers = vendor.getAllSellOffers();
+        for (Offer offer : offers) {
+            put(sellItems, offer);
+        }
+        offers = vendor.getAllBuyOffers();
+        for (Offer offer : offers) {
+            put(buyItems, offer);
+        }
+    }
+
+    @Override
+    protected void onRemove(Vendor vendor) {
+        LOG.trace("Remove cache of vendor {}", vendor);
+        Collection<Offer> offers = vendor.getAllSellOffers();
+        for (Offer offer : offers) {
+            remove(sellItems, offer);
+        }
+        offers = vendor.getAllBuyOffers();
+        for (Offer offer : offers) {
+            remove(buyItems, offer);
+        }
+    }
+
+    @Override
+    protected void onAdd(Offer offer) {
+        LOG.trace("Cached on add offer {}", offer);
+        put(getItemCache(offer.getType()), offer);
+    }
+
+    @Override
+    protected void onRemove(Offer offer) {
+        LOG.trace("Remove cache of offer {}", offer);
+        remove(getItemCache(offer.getType()), offer);
     }
 
 }

core/src/main/java/ru/trader/store/berkeley/BDBStore.java

@@ -23,6 +23,7 @@ public class BDBStore {
     private final ItemDA<Item> iDA;
     private final GroupDA<Group> gDA;
     private final PlaceDA<Place> pDA;
+    private BDBMarket market;
 
     public BDBStore(String path){
         EnvironmentConfig envConfig = new EnvironmentConfig();
@@ -39,7 +40,7 @@ public class BDBStore {
             oDA = new OfferDA<>(store, o -> new OfferProxy(o, this));
             iDA = new ItemDA<>(store, i -> new ItemProxy(i, this));
             gDA = new GroupDA<>(store, g -> g);
-            pDA = new PlaceDA<>(store, p -> new PlaceProxy(p, this));
+            pDA = new PlaceDA<>(store, p -> new PlaceProxy(p, null, this));
 
         } catch (DatabaseException e){
             LOG.error("Error on open DB, path {}", path);
@@ -48,6 +49,12 @@ public class BDBStore {
         }
     }
 
+    void setMarket(BDBMarket market) {
+        assert this.market == null;
+        this.market = market;
+        pDA.setConvertFunc(p -> new PlaceProxy(p, market, this));
+    }
+
     public VendorDA<Vendor> getVendorAccessor() {
         return vDA;
     }

core/src/main/java/ru/trader/store/berkeley/ItemProxy.java

@@ -7,11 +7,10 @@ import ru.trader.store.berkeley.entities.BDBItem;
 public class ItemProxy extends AbstractItem {
     private final BDBItem item;
     private final BDBStore store;
-    private final Group group;
+    private Group group;
 
     public ItemProxy(BDBItem item, BDBStore store) {
         this.item = item;
-        this.group = store.getGroupAccessor().get(item.getGroupId());
         this.store = store;
     }
 
@@ -36,7 +35,26 @@ public class ItemProxy extends AbstractItem {
 
     @Override
     public Group getGroup() {
+        if (group == null){
+            group = store.getGroupAccessor().get(item.getGroupId());
+        }
         return group;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof ItemProxy)) return false;
+
+        ItemProxy itemProxy = (ItemProxy) o;
+
+        if (!item.equals(itemProxy.item)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return item.hashCode();
+    }
 }

core/src/main/java/ru/trader/store/berkeley/OfferProxy.java

@@ -5,13 +5,12 @@ import ru.trader.store.berkeley.entities.BDBOffer;
 
 public class OfferProxy extends AbstractOffer {
     private final BDBOffer offer;
-    private final Item item;
+    private Item item;
     private BDBStore store;
     private Vendor vendor;
 
     public OfferProxy(BDBOffer offer, BDBStore store) {
         this.offer = offer;
-        this.item = store.getItemAccessor().get(offer.getItemId());
         this.store = store;
     }
 
@@ -43,6 +42,9 @@ public class OfferProxy extends AbstractOffer {
 
     @Override
     public Item getItem() {
+        if (item == null){
+            item = store.getItemAccessor().get(offer.getItemId());
+        }
         return item;
     }
 
@@ -69,4 +71,20 @@ public class OfferProxy extends AbstractOffer {
         return offer.getCount();
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof OfferProxy)) return false;
+
+        OfferProxy that = (OfferProxy) o;
+
+        if (!offer.equals(that.offer)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return offer.hashCode();
+    }
 }

core/src/main/java/ru/trader/store/berkeley/PlaceProxy.java

@@ -16,6 +16,11 @@ public class PlaceProxy extends AbstractPlace {
         this.store = store;
     }
 
+    public PlaceProxy(BDBPlace place, BDBMarket market, BDBStore store) {
+        this(place, store);
+        setMarket(market);
+    }
+
     protected long getId(){
         return place.getId();
     }
@@ -76,4 +81,20 @@ public class PlaceProxy extends AbstractPlace {
         return store.getVendorAccessor().getAllByPlace(place.getId());
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof PlaceProxy)) return false;
+
+        PlaceProxy that = (PlaceProxy) o;
+
+        if (!place.equals(that.place)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return place.hashCode();
+    }
 }

core/src/main/java/ru/trader/store/berkeley/VendorProxy.java

@@ -114,4 +114,21 @@ public class VendorProxy extends AbstractVendor {
     public boolean has(OFFER_TYPE type, Item item) {
         return store.getOfferAccessor().has(vendor.getId(), type, ((ItemProxy)item).getId());
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof VendorProxy)) return false;
+
+        VendorProxy that = (VendorProxy) o;
+
+        if (!vendor.equals(that.vendor)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return vendor.hashCode();
+    }
 }

core/src/main/java/ru/trader/store/berkeley/dao/OfferDA.java

@@ -6,6 +6,7 @@ import ru.trader.store.berkeley.entities.BDBOffer;
 
 import java.util.Collection;
 import java.util.LinkedList;
+import java.util.TreeSet;
 import java.util.function.Function;
 
 public class OfferDA<T> {
@@ -78,6 +79,20 @@ public class OfferDA<T> {
         return res;
     }
 
+    public Collection<T> getAllByItem(long itemId, OFFER_TYPE type){
+        EntityJoin<Long,BDBOffer> join = new EntityJoin<>(indexById);
+        join.addCondition(indexByItemId, itemId);
+        join.addCondition(indexByType, type);
+        Collection<T> res = new LinkedList<>();
+        try (ForwardCursor<BDBOffer> cursor = join.entities())
+        {
+            for(BDBOffer entity : cursor){
+                res.add(convertFunc.apply(entity));
+            }
+        }
+        return res;
+    }
+
 
     public BDBOffer put(BDBOffer offer){
         return indexById.put(offer);

core/src/main/java/ru/trader/store/berkeley/dao/PlaceDA.java

@@ -13,7 +13,7 @@ import java.util.function.Function;
 public class PlaceDA<T> {
     private final PrimaryIndex<Long, BDBPlace> indexById;
     private final SecondaryIndex<Double, Long, BDBPlace> indexByDistance;
-    private final Function<BDBPlace,T> convertFunc;
+    private Function<BDBPlace,T> convertFunc;
 
     public PlaceDA(EntityStore store, Function<BDBPlace, T> convertFunc) {
         this.convertFunc = convertFunc;
@@ -21,6 +21,10 @@ public class PlaceDA<T> {
         this.indexByDistance = store.getSecondaryIndex(indexById, Double.class, "distance");
     }
 
+    public void setConvertFunc(Function<BDBPlace, T> convertFunc) {
+        this.convertFunc = convertFunc;
+    }
+
     public T get(long id){
         return DAUtils.get(indexById, id, convertFunc);
     }

core/src/main/java/ru/trader/store/berkeley/entities/BDBGroup.java

@@ -31,4 +31,24 @@ public class BDBGroup implements Group {
     public GROUP_TYPE getType() {
         return type;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBGroup)) return false;
+
+        BDBGroup bdbGroup = (BDBGroup) o;
+
+        if (!name.equals(bdbGroup.name)) return false;
+        if (type != bdbGroup.type) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name.hashCode();
+        result = 31 * result + type.hashCode();
+        return result;
+    }
 }

core/src/main/java/ru/trader/store/berkeley/entities/BDBItem.java

@@ -38,4 +38,22 @@ public class BDBItem {
         return groupId;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBItem)) return false;
+
+        BDBItem bdbItem = (BDBItem) o;
+
+        if (id != bdbItem.id) return false;
+        if (!groupId.equals(bdbItem.groupId)) return false;
+        if (!name.equals(bdbItem.name)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (id ^ (id >>> 32));
+    }
 }

core/src/main/java/ru/trader/store/berkeley/entities/BDBOffer.java

@@ -10,21 +10,22 @@ public class BDBOffer {
     private long id;
 
     @SecondaryKey(relate = Relationship.MANY_TO_ONE,
-            relatedEntity = BDBItem.class,
+            relatedEntity = BDBItem.class, onRelatedEntityDelete = DeleteAction.CASCADE)
-            onRelatedEntityDelete = DeleteAction.NULLIFY)
     private long itemId;
 
     @SecondaryKey(relate = Relationship.MANY_TO_ONE,
-            relatedEntity = BDBVendor.class,
+            relatedEntity = BDBVendor.class, onRelatedEntityDelete = DeleteAction.CASCADE)
-            onRelatedEntityDelete = DeleteAction.NULLIFY)
     private long vendorId;
 
-    @SecondaryKey(relate = Relationship.ONE_TO_ONE)
+    @SecondaryKey(relate = Relationship.MANY_TO_ONE)
     private OFFER_TYPE type;
 
     private double price;
     private long count;
 
+    private BDBOffer() {
+    }
+
     public BDBOffer(OFFER_TYPE type, long itemId, double price, long count, long vendorId) {
         this.type = type;
         this.itemId = itemId;
@@ -69,4 +70,24 @@ public class BDBOffer {
         this.vendorId = vendorId;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBOffer)) return false;
+
+        BDBOffer bdbOffer = (BDBOffer) o;
+
+        if (count != bdbOffer.count) return false;
+        if (id != bdbOffer.id) return false;
+        if (itemId != bdbOffer.itemId) return false;
+        if (Double.compare(bdbOffer.price, price) != 0) return false;
+        if (type != bdbOffer.type) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (id ^ (id >>> 32));
+    }
 }

core/src/main/java/ru/trader/store/berkeley/entities/BDBPlace.java

@@ -59,4 +59,25 @@ public class BDBPlace {
         this.distance = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2) + Math.pow(z, 2));
     }
 
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBPlace)) return false;
+
+        BDBPlace bdbPlace = (BDBPlace) o;
+
+        if (id != bdbPlace.id) return false;
+        if (Double.compare(bdbPlace.x, x) != 0) return false;
+        if (Double.compare(bdbPlace.y, y) != 0) return false;
+        if (Double.compare(bdbPlace.z, z) != 0) return false;
+        if (!name.equals(bdbPlace.name)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (id ^ (id >>> 32));
+    }
 }

core/src/main/java/ru/trader/store/berkeley/entities/BDBVendor.java

@@ -4,7 +4,7 @@ import com.sleepycat.persist.model.*;
 import ru.trader.core.SERVICE_TYPE;
 
 import java.util.Collection;
-import java.util.EnumSet;
+import java.util.HashSet;
 
 @Entity(version = 1)
 public class BDBVendor {
@@ -13,14 +13,13 @@ public class BDBVendor {
     private long id;
 
     @SecondaryKey(relate = Relationship.MANY_TO_ONE,
-            relatedEntity = BDBPlace.class,
+                  relatedEntity = BDBPlace.class, onRelatedEntityDelete = DeleteAction.CASCADE)
-            onRelatedEntityDelete = DeleteAction.NULLIFY)
     private long placeId;
     private String name;
     private double distance;
 
-    @SecondaryKey(relate=Relationship.ONE_TO_MANY)
+    @SecondaryKey(relate=Relationship.MANY_TO_MANY)
-    EnumSet<SERVICE_TYPE> services = EnumSet.noneOf(SERVICE_TYPE.class);
+    Collection<SERVICE_TYPE> services = new HashSet<>();
 
     private BDBVendor() {
     }
@@ -73,4 +72,25 @@ public class BDBVendor {
     public Collection<SERVICE_TYPE> getServices() {
         return services;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof BDBVendor)) return false;
+
+        BDBVendor bdbVendor = (BDBVendor) o;
+
+        if (Double.compare(bdbVendor.distance, distance) != 0) return false;
+        if (id != bdbVendor.id) return false;
+        if (placeId != bdbVendor.placeId) return false;
+        if (!name.equals(bdbVendor.name)) return false;
+        if (!services.equals(bdbVendor.services)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (id ^ (id >>> 32));
+    }
 }

core/src/test/java/ru/trader/store/berkeley/MarketTest.java

@@ -0,0 +1,550 @@
+package ru.trader.store.berkeley;
+
+
+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.core.*;
+import ru.trader.store.simple.SimpleMarket;
+
+import java.io.File;
+import java.util.Collection;
+
+
+public class MarketTest  extends Assert {
+    private final static Logger LOG = LoggerFactory.getLogger(MarketTest.class);
+    private BDBStore store;
+    private Market market;
+
+    @Before
+    public void setUp() throws Exception {
+        File f = new File("test-bd");
+        if (!f.exists()){
+            f.mkdir();
+        }
+        store = new BDBStore("test-bd");
+        market = new BDBMarket(store);
+
+    }
+
+    @Test
+    public void testGroup(){
+        LOG.info("Start test group");
+        Group group1 = market.addGroup("Group 1", GROUP_TYPE.MARKET);
+        Group group2 = market.addGroup("Group 2", GROUP_TYPE.OUTFIT);
+        Group group3 = market.addGroup("Group 3", GROUP_TYPE.MARKET);
+        int c = 3;
+        for (Group group : market.getGroups()) {
+            if ("Group 1".equals(group.getName())){
+                assertEquals(group1, group);
+                assertEquals(GROUP_TYPE.MARKET, group.getType());
+                c--;
+            } else
+            if ("Group 2".equals(group.getName())){
+                assertEquals(group2, group);
+                assertEquals(GROUP_TYPE.OUTFIT, group.getType());
+                c--;
+            } else
+            if ("Group 3".equals(group.getName())){
+                assertEquals(group3, group);
+                assertEquals(GROUP_TYPE.MARKET, group.getType());
+                c--;
+            } else c = -1;
+        }
+        assertEquals("Wrong group count", 0, c);
+
+        market.remove(group1);
+        market.remove(group2);
+        market.remove(group3);
+
+        assertEquals(0, market.getGroups().size());
+    }
+
+
+    @Test
+    public void testItem(){
+        LOG.info("Start test item");
+        Group group1 = market.addGroup("Group 1", GROUP_TYPE.MARKET);
+        Group group2 = market.addGroup("Group 2", GROUP_TYPE.OUTFIT);
+
+        Item item1 = market.addItem("Item 1", group1);
+        Item item2 = market.addItem("Item 2", group2);
+        Item item3 = market.addItem("Item 3", group1);
+        int c = 3;
+        for (Item item : market.getItems()) {
+            if ("Item 1".equals(item.getName())){
+                assertEquals(item1, item);
+                assertEquals(group1, item.getGroup());
+                c--;
+            } else
+            if ("Item 2".equals(item.getName())){
+                assertEquals(item2, item);
+                assertEquals(group2, item.getGroup());
+                c--;
+            } else
+            if ("Item 3".equals(item.getName())){
+                assertEquals(item3, item);
+                assertEquals(group1, item.getGroup());
+                c--;
+            } else c = -1;
+
+        }
+        assertEquals("Wrong item count", 0, c);
+
+
+        market.remove(group1);
+        market.remove(group2);
+
+        assertEquals(0, market.getGroups().size());
+
+        market.remove(item1);
+        market.remove(item2);
+        market.remove(item3);
+
+        assertEquals(0, market.getItems().size());
+
+
+    }
+
+
+    @Test
+    public void testPlace(){
+        LOG.info("Start test place");
+        Place place1 = market.addPlace("Place 1", 1, 2, 3);
+        Place place2 = market.addPlace("Place 2", 3, 1, 2);
+
+        int c = 2;
+        for (Place place : market.get()) {
+            if ("Place 1".equals(place.getName())){
+                assertEquals(place1, place);
+                assertEquals(1, place.getX(), 0.01);
+                assertEquals(2, place.getY(), 0.01);
+                assertEquals(3, place.getZ(), 0.01);
+                c--;
+            } else
+            if ("Place 2".equals(place.getName())){
+                assertEquals(place2, place);
+                assertEquals(3, place.getX(), 0.01);
+                assertEquals(1, place.getY(), 0.01);
+                assertEquals(2, place.getZ(), 0.01);
+                c--;
+            } else c = -1;
+
+        }
+        assertEquals("Wrong item count", 0, c);
+
+        market.remove(place1);
+        market.remove(place2);
+
+        assertEquals(0, market.get().size());
+
+    }
+
+
+    @Test
+    public void testVendor(){
+        LOG.info("Start test vendor");
+        Place place1 = market.addPlace("Place 1", 1, 2, 3);
+        Place place2 = market.addPlace("Place 2", 3, 1, 2);
+        Vendor vendor1 = place1.addVendor("Vendor 1");
+        vendor1.setDistance(100);
+        vendor1.add(SERVICE_TYPE.MARKET);
+        vendor1.add(SERVICE_TYPE.OUTFIT);
+
+        Vendor vendor2 = place1.addVendor("Vendor 2");
+        vendor2.setDistance(40);
+
+
+        Vendor vendor3 = place2.addVendor("Vendor 3");
+        vendor3.add(SERVICE_TYPE.OUTFIT);
+        vendor3.add(SERVICE_TYPE.LARGE_LANDPAD);
+        vendor3.add(SERVICE_TYPE.MEDIUM_LANDPAD);
+        vendor3.remove(SERVICE_TYPE.LARGE_LANDPAD);
+
+        int c = 3;
+        for (Vendor vendor : market.getVendors()) {
+            if ("Transit".equals(vendor.toString())) continue;
+            if ("Vendor 1".equals(vendor.getName())){
+                assertEquals(vendor1, vendor);
+                assertEquals(place1, vendor.getPlace());
+                assertEquals(100, vendor.getDistance(), 0.001);
+                assertTrue(vendor.has(SERVICE_TYPE.MARKET));
+                assertTrue(vendor.has(SERVICE_TYPE.OUTFIT));
+                assertFalse(vendor.has(SERVICE_TYPE.LARGE_LANDPAD));
+                assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                assertFalse(vendor.has(SERVICE_TYPE.MEDIUM_LANDPAD));
+                c--;
+            } else
+            if ("Vendor 2".equals(vendor.getName())){
+                assertEquals(vendor2, vendor);
+                assertEquals(place1, vendor.getPlace());
+                assertEquals(40, vendor.getDistance(), 0.001);
+                assertFalse(vendor.has(SERVICE_TYPE.MARKET));
+                assertFalse(vendor.has(SERVICE_TYPE.OUTFIT));
+                assertFalse(vendor.has(SERVICE_TYPE.LARGE_LANDPAD));
+                assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                assertFalse(vendor.has(SERVICE_TYPE.MEDIUM_LANDPAD));
+                c--;
+            } else
+            if ("Vendor 3".equals(vendor.getName())){
+                assertEquals(vendor3, vendor);
+                assertEquals(place2, vendor.getPlace());
+                assertEquals(0, vendor.getDistance(), 0.001);
+                assertFalse(vendor.has(SERVICE_TYPE.MARKET));
+                assertTrue(vendor.has(SERVICE_TYPE.OUTFIT));
+                assertFalse(vendor.has(SERVICE_TYPE.LARGE_LANDPAD));
+                assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                assertTrue(vendor.has(SERVICE_TYPE.MEDIUM_LANDPAD));
+                c--;
+            } else c = -1;
+
+        }
+        assertEquals("Wrong vendors count", 0, c);
+
+        place1.remove(vendor1);
+        place1.remove(vendor2);
+        place2.remove(vendor3);
+
+        assertEquals(2, market.getVendors().size());
+
+        market.remove(place1);
+        market.remove(place2);
+
+        assertEquals(0, market.getVendors().size());
+    }
+
+    @Test
+    public void testOffer(){
+        LOG.info("Start test offer");
+        Group group1 = market.addGroup("Group 1", GROUP_TYPE.MARKET);
+        Group group2 = market.addGroup("Group 2", GROUP_TYPE.OUTFIT);
+        Item item1 = market.addItem("Item 1", group1);
+        Item item2 = market.addItem("Item 2", group2);
+        Item item3 = market.addItem("Item 3", group1);
+        Place place1 = market.addPlace("Place 1", 1, 2, 3);
+        Vendor vendor1 = place1.addVendor("Vendor 1");
+
+        Offer offer1 = vendor1.addOffer(OFFER_TYPE.SELL, item1, 254, 10);
+        Offer offer2 = vendor1.addOffer(OFFER_TYPE.BUY, item1, 300, 15);
+        Offer offer3 = vendor1.addOffer(OFFER_TYPE.BUY, item3, 100, 100);
+        Offer offer4 = vendor1.addOffer(OFFER_TYPE.SELL, item2, 10, -1);
+
+        int c = 2;
+        for (Offer offer : vendor1.getAllSellOffers()) {
+            if (item1.equals(offer.getItem())){
+                assertEquals(offer1, offer);
+                assertEquals(OFFER_TYPE.SELL, offer.getType());
+                assertEquals(254, offer.getPrice(), 0.01);
+                assertEquals(10, offer.getCount());
+                c--;
+            } else
+            if (item2.equals(offer.getItem())){
+                assertEquals(offer4, offer);
+                assertEquals(OFFER_TYPE.SELL, offer.getType());
+                assertEquals(10, offer.getPrice(), 0.01);
+                assertEquals(-1, offer.getCount());
+                c--;
+            } else c = -1;
+        }
+        assertEquals("Wrong buy offers count", 0, c);
+
+
+        c = 2;
+        for (Offer offer : vendor1.getAllBuyOffers()) {
+            if (item1.equals(offer.getItem())){
+                assertEquals(offer2, offer);
+                assertEquals(OFFER_TYPE.BUY, offer.getType());
+                assertEquals(300, offer.getPrice(), 0.01);
+                assertEquals(15, offer.getCount());
+                c--;
+            } else
+            if (item3.equals(offer.getItem())){
+                assertEquals(offer3, offer);
+                assertEquals(OFFER_TYPE.BUY, offer.getType());
+                assertEquals(100, offer.getPrice(), 0.01);
+                assertEquals(100, offer.getCount());
+                c--;
+            } else c = -1;
+        }
+        assertEquals("Wrong buy offers count", 0, c);
+
+        vendor1.remove(offer1);
+        vendor1.remove(offer2);
+        vendor1.remove(offer3);
+        vendor1.remove(offer4);
+        assertEquals(0, vendor1.getAllBuyOffers().size());
+        assertEquals(0, vendor1.getAllSellOffers().size());
+
+        place1.remove(vendor1);
+        market.remove(place1);
+        market.remove(item1);
+        market.remove(item2);
+        market.remove(item3);
+        market.remove(group1);
+        market.remove(group2);
+    }
+
+
+    @Test
+    public void testItemStat(){
+        LOG.info("Start item stat test");
+        Group group1 = market.addGroup("Group 1", GROUP_TYPE.MARKET);
+        Item item1 = market.addItem("Item 1", group1);
+        Item item2 = market.addItem("Item 2", group1);
+        Place place1 = market.addPlace("Place 1", 1, 2, 3);
+        Vendor vendor1 = place1.addVendor("Vendor 1");
+        Vendor vendor2 = place1.addVendor("Vendor 2");
+        Vendor vendor3 = place1.addVendor("Vendor 3");
+        Vendor vendor4 = place1.addVendor("Vendor 4");
+
+        Offer offer1 = vendor1.addOffer(OFFER_TYPE.SELL, item1, 10, 1);
+        Offer offer2 = vendor2.addOffer(OFFER_TYPE.SELL, item1, 20, 1);
+        Offer offer3 = vendor3.addOffer(OFFER_TYPE.SELL, item1, 30, 1);
+        Offer offer4 = vendor4.addOffer(OFFER_TYPE.SELL, item1, 40, 1);
+
+        Offer offer5 = vendor1.addOffer(OFFER_TYPE.BUY, item1, 100, 1);
+        Offer offer6 = vendor2.addOffer(OFFER_TYPE.BUY, item1, 200, 1);
+        Offer offer7 = vendor3.addOffer(OFFER_TYPE.BUY, item1, 300, 1);
+        Offer offer8 = vendor4.addOffer(OFFER_TYPE.BUY, item1, 400, 1);
+
+        Offer offer9 = vendor1.addOffer(OFFER_TYPE.BUY, item2, 1, 30);
+        Offer offer10 = vendor2.addOffer(OFFER_TYPE.BUY, item2, 500, 10);
+
+
+        ItemStat sellStat = market.getStat(OFFER_TYPE.SELL, item1);
+        assertEquals((10+20+30+40)/4, sellStat.getAvg(), 0);
+        assertEquals(offer1, sellStat.getBest());
+        assertEquals(offer1, sellStat.getMin());
+        assertEquals(offer4, sellStat.getMax());
+        assertEquals(4, sellStat.getOffers().size());
+
+        ItemStat buyStat = market.getStat(OFFER_TYPE.BUY, item1);
+        assertEquals((100+200+300+400)/4, buyStat.getAvg(), 0);
+        assertEquals(offer8, buyStat.getBest());
+        assertEquals(offer5, buyStat.getMin());
+        assertEquals(offer8, buyStat.getMax());
+        assertEquals(4, buyStat.getOffers().size());
+
+        vendor1.remove(offer1);
+        vendor4.remove(offer4);
+        assertEquals((20+30)/2, sellStat.getAvg(), 0);
+        assertEquals(offer2, sellStat.getBest());
+        assertEquals(offer2, sellStat.getMin());
+        assertEquals(offer3, sellStat.getMax());
+        assertEquals(2, sellStat.getOffers().size());
+
+        market.remove(place1);
+
+        assertEquals(0, market.getSell(item1).size());
+        assertEquals(0, market.getBuy(item1).size());
+        assertEquals(0, vendor1.getAllBuyOffers().size());
+        assertEquals(0, vendor1.getAllSellOffers().size());
+        assertEquals(0, market.getVendors().size());
+        assertEquals(0, market.get().size());
+        assertEquals(0, sellStat.getOffers().size());
+        assertEquals(0, buyStat.getOffers().size());
+
+        market.remove(item1);
+        market.remove(item2);
+        market.remove(group1);
+        assertTrue(market.getStatBuy(item1).isEmpty());
+        assertTrue(market.getStatBuy(item2).isEmpty());
+    }
+
+
+    private void assertGroup(Group group1, Group group2){
+        assertEquals(group1.getName(), group2.getName());
+        assertEquals(group1.getType(), group2.getType());
+    }
+
+    private void assertItem(Item item1, Item item2){
+        assertEquals(item1.getName(), item2.getName());
+        assertGroup(item1.getGroup(), item2.getGroup());
+    }
+
+    private void assertPlace(Place place1, Place place2){
+        assertEquals(place1.getName(), place2.getName());
+        assertEquals(place1.getX(), place2.getX(), 0.00001);
+        assertEquals(place1.getY(), place2.getY(), 0.00001);
+        assertEquals(place1.getZ(), place2.getZ(), 0.00001);
+    }
+
+    private void assertVendor(Vendor vendor1, Vendor vendor2){
+        assertEquals(vendor1.getName(), vendor2.getName());
+        assertEquals(vendor1.getDistance(), vendor2.getDistance(), 0.00001);
+    }
+
+    private void assertOffer(Offer offer1, Offer offer2){
+        assertEquals(offer1.getType(), offer2.getType());
+        assertItem(offer1.getItem(), offer2.getItem());
+        assertEquals(offer1.getPrice(), offer2.getPrice(), 0.000001);
+        assertEquals(offer1.getCount(), offer2.getCount());
+    }
+
+    @Test
+    public void testImport(){
+        LOG.info("Start import test");
+
+        Market world = new SimpleMarket();
+        Group group1 = world.addGroup("Group 1", GROUP_TYPE.MARKET);
+        Group group2 = world.addGroup("Group 2", GROUP_TYPE.MARKET);
+        Group group3 = world.addGroup("Group 3", GROUP_TYPE.OUTFIT);
+        Item item1 = world.addItem("Item 1", group1);
+        Item item2 = world.addItem("Item 2", group1);
+        Item item3 = world.addItem("Item 3", group2);
+        Item item4 = world.addItem("Item 4", group2);
+        Item item5 = world.addItem("Item 5", group3);
+        Place place1 = world.addPlace("Place 1", 0, 1, 3);
+        Place place2 = world.addPlace("Place 2",4,0,5);
+        Place place3 = world.addPlace("Place 3",0,0,0);
+        Vendor vendor1 = place1.addVendor("Vendor 1");
+        Vendor vendor2 = place1.addVendor("Vendor 2");
+        Vendor vendor3 = place2.addVendor("Vendor 3");
+        vendor1.setDistance(10);
+        vendor1.add(SERVICE_TYPE.MARKET);
+        vendor1.add(SERVICE_TYPE.OUTFIT);
+        Offer offer1 = vendor1.addOffer(OFFER_TYPE.SELL, item1, 10,43);
+        Offer offer2 = vendor1.addOffer(OFFER_TYPE.BUY, item1, 12,1);
+        Offer offer3 = vendor1.addOffer(OFFER_TYPE.SELL, item2, 1012,1000);
+        Offer offer4 = vendor1.addOffer(OFFER_TYPE.SELL, item3, 110,0);
+        Offer offer5 = vendor1.addOffer(OFFER_TYPE.SELL, item4, 1112,12);
+        Offer offer6 = vendor1.addOffer(OFFER_TYPE.BUY, item5, 11,10);
+        vendor2.setDistance(100.4);
+        vendor3.setDistance(200000.4);
+        vendor3.add(SERVICE_TYPE.OUTFIT);
+
+        LOG.info("add market");
+        market.add(world);
+
+        LOG.info("check groups");
+        Collection<Group> groups = world.getGroups();
+        int i=0;
+        for (Group group : groups) {
+            if (group1.getName().equals(group.getName())) {assertGroup(group, group1);i++;}
+            if (group2.getName().equals(group.getName())) {assertGroup(group, group2);i++;}
+            if (group3.getName().equals(group.getName())) {assertGroup(group, group3);i++;}
+        }
+        assertEquals(3, i);
+
+        LOG.info("check items");
+        Collection<Item> items = world.getItems();
+        i=0;
+        for (Item item : items) {
+            if (item1.getName().equals(item.getName())) {assertItem(item, item1);i++;}
+            if (item2.getName().equals(item.getName())) {assertItem(item, item2);i++;}
+            if (item3.getName().equals(item.getName())) {assertItem(item, item3);i++;}
+            if (item4.getName().equals(item.getName())) {assertItem(item, item4);i++;}
+            if (item5.getName().equals(item.getName())) {assertItem(item, item5);i++;}
+        }
+        assertEquals(5, i);
+
+        LOG.info("check places");
+        Collection<Place> places = world.get();
+        i=0;
+        for (Place place : places) {
+            if (place1.getName().equals(place.getName())) {
+                assertPlace(place, place1);
+                i++;
+                Collection<Vendor> vendors = place.get();
+                int j=0;
+                for (Vendor vendor : vendors) {
+                    if (vendor1.getName().equals(vendor.getName())) {
+                        LOG.info("check vendor 1");
+                        assertVendor(vendor, vendor1);j++;
+                        Collection<Offer> offers = vendor.getAllSellOffers();
+                        int o = 0;
+                        for (Offer offer : offers) {
+                            if (offer1.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer1);o++;}
+                            if (offer3.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer3);o++;}
+                            if (offer4.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer4);o++;}
+                            if (offer5.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer5);o++;}
+                        }
+                        assertEquals(4, o);
+                        offers = vendor.getAllBuyOffers();
+                        o = 0;
+                        for (Offer offer : offers) {
+                            if (offer2.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer2);o++;}
+                            if (offer6.getItem().getName().equals(offer.getItem().getName())) {assertOffer(offer, offer6);o++;}
+                        }
+                        assertEquals(2, o);
+                        assertTrue(vendor.has(SERVICE_TYPE.MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.REPAIR));
+                        assertFalse(vendor.has(SERVICE_TYPE.MUNITION));
+                        assertTrue(vendor.has(SERVICE_TYPE.OUTFIT));
+                        assertFalse(vendor.has(SERVICE_TYPE.SHIPYARD));
+                    }
+                    if (vendor2.getName().equals(vendor.getName())) {
+                        LOG.info("check vendor 2");
+                        assertVendor(vendor, vendor2);j++;
+                        assertTrue(vendor.getAllBuyOffers().isEmpty());
+                        assertTrue(vendor.getAllSellOffers().isEmpty());
+                        assertFalse(vendor.has(SERVICE_TYPE.MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.REPAIR));
+                        assertFalse(vendor.has(SERVICE_TYPE.MUNITION));
+                        assertFalse(vendor.has(SERVICE_TYPE.OUTFIT));
+                        assertFalse(vendor.has(SERVICE_TYPE.SHIPYARD));
+                    }
+                }
+                assertEquals(2, j);
+                assertTrue(place.canRefill());
+            }
+            if (place2.getName().equals(place.getName())) {
+                assertPlace(place, place2);
+                i++;
+                Collection<Vendor> vendors = place.get();
+                int j=0;
+                for (Vendor vendor : vendors) {
+                    if (vendor3.getName().equals(vendor.getName())) {
+                        LOG.info("check vendor 3");
+                        assertVendor(vendor, vendor3);j++;
+                        assertTrue(vendor.getAllBuyOffers().isEmpty());
+                        assertTrue(vendor.getAllSellOffers().isEmpty());
+                        assertFalse(vendor.has(SERVICE_TYPE.MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.BLACK_MARKET));
+                        assertFalse(vendor.has(SERVICE_TYPE.REPAIR));
+                        assertFalse(vendor.has(SERVICE_TYPE.MUNITION));
+                        assertTrue(vendor.has(SERVICE_TYPE.OUTFIT));
+                        assertFalse(vendor.has(SERVICE_TYPE.SHIPYARD));
+                    }
+                }
+                assertEquals(1, j);
+                assertTrue(place.canRefill());
+            }
+            if (place3.getName().equals(place.getName())) {
+                assertPlace(place, place3);
+                i++;
+                assertTrue(place.get().isEmpty());
+                assertFalse(place.canRefill());
+            }
+
+        }
+        assertEquals(3, i);
+        market.clear();
+    }
+
+
+    @After
+    public void tearDown() throws Exception {
+        store.close();
+        deleteFolder(new File("test-bd"));
+    }
+
+    public static void deleteFolder(File folder) {
+        File[] files = folder.listFiles();
+        if(files!=null) { //some JVMs return null for empty dirs
+            for(File f: files) {
+                if(f.isDirectory()) {
+                    deleteFolder(f);
+                } else {
+                    f.delete();
+                }
+            }
+        }
+        folder.delete();
+    }
+}