Merge branch 'master' of gitlab.com:stax-river/poker-analytics

app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt

@@ -1,21 +1,35 @@
 package net.pokeranalytics.android.filter
 
+import io.realm.RealmList
 import net.pokeranalytics.android.RealmInstrumentedUnitTest
-import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.*
-import net.pokeranalytics.android.model.realm.Session
 import java.util.*
 
 open class BaseFilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
 
     // convenience extension
     fun Session.Companion.testInstance(
-        netResult: Double,
+        netResult: Double = 0.0,
-        isTournament: Boolean,
+        isTournament: Boolean = false,
-        startDate: Date,
+        startDate: Date = Date(),
         endDate: Int = 1,
-        bankroll: Bankroll? = null
+        bankroll: Bankroll? = null,
-    ): Session {
+        game: Game? = null,
+        location : Location? = null,
+        tournamentName: TournamentName? = null,
+        tournamentFeatures: RealmList<TournamentFeature> = RealmList(),
+        numberOfTable: Int = 1,
+        limit: Int? = null,
+        tableSize: Int? = null
+        ): Session {
         val session: Session = Session.newInstance(super.mockRealm, isTournament, bankroll)
+        session.game = game
+        session.location = location
+        session.tournamentFeatures = tournamentFeatures
+        session.tournamentName = tournamentName
+        session.limit = limit
+        session.numberOfTables = numberOfTable
+        session.tableSize = tableSize
         session.result?.netResult = netResult
         session.startDate = startDate
         val cal = Calendar.getInstance() // creates calendar

app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt

@@ -0,0 +1,205 @@
+package net.pokeranalytics.android.filter
+
+import net.pokeranalytics.android.model.filter.FilterManager
+import net.pokeranalytics.android.model.filter.SessionFilterable
+import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.Session
+import org.junit.Assert
+import org.junit.Test
+import java.util.*
+
+class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
+    @Test
+    fun testSingleBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to 0.5,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindNoSmallBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to null,
+            "bb" to 1.0,
+            "code" to null
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testSingleBlindCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 1.0
+        s2.cgSmallBlind = 0.5
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+            "sb" to 1.0,
+            "bb" to 2.0,
+            "code" to "AUD"
+        )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        sessions.map {
+            Assert.assertEquals(s3.id, (it as Session).id)
+        }
+    }
+
+    @Test
+    fun testMultiBlindNoCurrencyFilter() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+
+        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        currency.code = "AUD"
+
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b2.currency = currency
+
+        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s1.cgBigBlind = 1.0
+        s1.cgSmallBlind = 0.5
+
+        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        s2.cgBigBlind = 2.0
+        s2.cgSmallBlind = 1.0
+
+        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        s3.cgBigBlind = 2.0
+        s3.cgSmallBlind = 1.0
+
+        realm.commitTransaction()
+
+
+        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("map" to arrayOf(
+            mapOf(
+                "sb" to 1.0,
+                "bb" to 2.0,
+                "code" to null
+            ),
+            mapOf(
+                "sb" to 0.5,
+                "bb" to 1.0,
+                "code" to null
+            )))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(2, sessions.size)
+        sessions.map {
+            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        }
+    }
+}

app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt

@@ -1,10 +1,10 @@
 package net.pokeranalytics.android.filter
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.realm.RealmList
 import net.pokeranalytics.android.model.filter.FilterManager
 import net.pokeranalytics.android.model.filter.SessionFilterable
-import net.pokeranalytics.android.model.realm.Bankroll
+import net.pokeranalytics.android.model.realm.*
-import net.pokeranalytics.android.model.realm.Session
 import org.junit.Assert
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -111,39 +111,80 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
     }
 
     @Test
-    fun testSingleBlindNoCurrencyFilter() {
+    fun testBankrollFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
+        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val b2 = realm.createObject(Bankroll::class.java, "2")
+        b1.live = false
+        b2.live = true
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.BANKROLL
+        filter.valueMap = mapOf("ids" to arrayOf(b1.id))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        Assert.assertEquals(1, sessions.size)
-        currency.code = "AUD"
+        (sessions[0] as Session).bankroll?.run {
+            Assert.assertEquals(b1.id, this.id)
+        }
+    }
 
+    @Test
+    fun testMultipleBankrollFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
         val b1 = realm.createObject(Bankroll::class.java, "1")
         val b2 = realm.createObject(Bankroll::class.java, "2")
-        b2.currency = currency
+        val b3 = realm.createObject(Bankroll::class.java, "3")
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        Session.testInstance(bankroll = b1)
+        Session.testInstance(bankroll = b2)
+        Session.testInstance(bankroll = b3)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.BANKROLL
+        filter.valueMap = mapOf("ids" to arrayOf(b1.id, b2.id))
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val sessions = FilterManager().filter(
-        s1.cgBigBlind = 1.0
+            realm,
-        s1.cgSmallBlind = 0.5
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(b1.id, b2.id)
-        s3.cgBigBlind = 2.0
-        s3.cgSmallBlind = 1.0
 
-        realm.commitTransaction()
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).bankroll?.id))
+        }
+    }
 
+    @Test
+    fun testGameFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val g1 = realm.createObject(Game::class.java, "1")
+        val g2 = realm.createObject(Game::class.java, "2")
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        realm.commitTransaction()
 
-        val filter = SessionFilterable.BLINDS
+        val filter = SessionFilterable.GAME
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+        filter.valueMap = mapOf("ids" to arrayOf(g2.id))
-            "sb" to 0.5,
-            "bb" to 1.0,
-            "code" to null
-        )))
 
         val sessions = FilterManager().filter(
             realm,
@@ -151,46 +192,93 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             arrayListOf(filter)
         )
 
-        Assert.assertEquals(2, sessions.size)
+        Assert.assertEquals(1, sessions.size)
-        sessions.map {
+        (sessions[0] as Session).game?.run {
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+            Assert.assertEquals(g2.id, this.id)
         }
     }
 
     @Test
-    fun testSingleBlindNoSmallBlindNoCurrencyFilter() {
+    fun testMultipleGameFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
+        val g1 = realm.createObject(Game::class.java, "1")
+        val g2 = realm.createObject(Game::class.java, "2")
+        val g3 = realm.createObject(Game::class.java, "3")
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        Session.testInstance(game = g1)
+        Session.testInstance(game = g2)
+        Session.testInstance(game = g3)
+        realm.commitTransaction()
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        val filter = SessionFilterable.GAME
-        currency.code = "AUD"
+        filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id))
 
-        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val sessions = FilterManager().filter(
-        val b2 = realm.createObject(Bankroll::class.java, "2")
+            realm,
-        b2.currency = currency
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s1.cgBigBlind = 1.0
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(g2.id, g3.id)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
+        sessions.forEach {
-        s3.cgBigBlind = 2.0
+            Assert.assertTrue(result.contains((it as Session).game?.id))
-        s3.cgSmallBlind = 1.0
+        }
+    }
 
+    @Test
+    fun testLocationFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val l1 = realm.createObject(Location::class.java, "1")
+        val l2 = realm.createObject(Location::class.java, "2")
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
         realm.commitTransaction()
 
+        val filter = SessionFilterable.LOCATION
+        filter.valueMap = mapOf("ids" to arrayOf(l1.id))
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        (sessions[0] as Session).location?.run {
+            Assert.assertEquals(l1.id, this.id)
+        }
+    }
 
-        val filter = SessionFilterable.BLINDS
+    @Test
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
+    fun testMultipleLocationFilter() {
-            "sb" to null,
+        val realm = this.mockRealm
-            "bb" to 1.0,
+        realm.beginTransaction()
-            "code" to null
+        val l1 = realm.createObject(Location::class.java, "1")
-        )))
+        val l2 = realm.createObject(Location::class.java, "2")
+        val l3 = realm.createObject(Location::class.java, "3")
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        Session.testInstance(location = l1)
+        Session.testInstance(location = l2)
+        Session.testInstance(location = l3)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.LOCATION
+        filter.valueMap = mapOf("ids" to arrayOf(l1.id, l3.id))
 
         val sessions = FilterManager().filter(
             realm,
@@ -198,46 +286,96 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
             arrayListOf(filter)
         )
 
-        Assert.assertEquals(2, sessions.size)
+        Assert.assertEquals(6, sessions.size)
-        sessions.map {
+
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        val result = arrayListOf(l2.id, l3.id)
+
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).location?.id))
         }
     }
 
     @Test
-    fun testSingleBlindCurrencyFilter() {
+    fun testTournamentNameFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val t1 = realm.createObject(TournamentName::class.java, "1")
+        val t2 = realm.createObject(TournamentName::class.java, "2")
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.TOURNAMENT_NAME
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id))
 
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+        (sessions[0] as Session).tournamentName?.run {
+            Assert.assertEquals(t1.id, this.id)
+        }
+    }
+
+    @Test
+    fun testMultipleTournamentNameFilter() {
         val realm = this.mockRealm
         realm.beginTransaction()
+        val t1 = realm.createObject(TournamentName::class.java, "1")
+        val t2 = realm.createObject(TournamentName::class.java, "2")
+        val t3 = realm.createObject(TournamentName::class.java, "3")
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        Session.testInstance(tournamentName = t1)
+        Session.testInstance(tournamentName = t2)
+        Session.testInstance(tournamentName = t3)
+        realm.commitTransaction()
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        val filter = SessionFilterable.TOURNAMENT_NAME
-        currency.code = "AUD"
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id))
 
-        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val sessions = FilterManager().filter(
-        val b2 = realm.createObject(Bankroll::class.java, "2")
+            realm,
-        b2.currency = currency
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        Assert.assertEquals(6, sessions.size)
-        s1.cgBigBlind = 1.0
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val result = arrayListOf(t1.id, t2.id)
-        s2.cgBigBlind = 1.0
-        s2.cgSmallBlind = 0.5
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        sessions.forEach {
-        s3.cgBigBlind = 2.0
+            Assert.assertTrue(result.contains((it as Session).tournamentName?.id))
-        s3.cgSmallBlind = 1.0
+        }
+    }
 
+    @Test
+    fun testAllTournamentFeatureFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val t1 = realm.createObject(TournamentFeature::class.java, "1")
+        val t2 = realm.createObject(TournamentFeature::class.java, "2")
+        val t3 = realm.createObject(TournamentFeature::class.java, "3")
+        val t4 = realm.createObject(TournamentFeature::class.java, "4")
+        Session.testInstance(tournamentFeatures = RealmList(t1,t2))
+        Session.testInstance(tournamentFeatures = RealmList(t2,t3))
+        Session.testInstance(tournamentFeatures = RealmList(t3,t4))
+        val s = Session.testInstance(tournamentFeatures = RealmList(t1,t2,t3,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t3))
+        Session.testInstance(tournamentFeatures = RealmList(t2,t4, t3))
+        Session.testInstance(tournamentFeatures = RealmList(t1))
         realm.commitTransaction()
 
-
+        val filter = SessionFilterable.ALL_TOURNAMENT_FEATURES
-        val filter = SessionFilterable.BLINDS
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
-        filter.valueMap = mapOf("map" to arrayOf(mapOf(
-            "sb" to 1.0,
-            "bb" to 2.0,
-            "code" to "AUD"
-        )))
 
         val sessions = FilterManager().filter(
             realm,
@@ -246,51 +384,115 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         )
 
         Assert.assertEquals(1, sessions.size)
-        sessions.map {
+        (sessions[0] as Session)?.run {
-            Assert.assertEquals(s3.id, (it as Session).id)
+            Assert.assertEquals(s.id, this.id)
         }
     }
 
     @Test
-    fun testMultiBlindNoCurrencyFilter() {
+    fun testAnyTournamentFeatureFilter() {
-
         val realm = this.mockRealm
         realm.beginTransaction()
+        val t1 = realm.createObject(TournamentFeature::class.java, "1")
+        val t2 = realm.createObject(TournamentFeature::class.java, "2")
+        val t3 = realm.createObject(TournamentFeature::class.java, "3")
+        val t4 = realm.createObject(TournamentFeature::class.java, "4")
+        Session.testInstance(tournamentFeatures = RealmList(t1,t2))
+        Session.testInstance(tournamentFeatures = RealmList(t2,t3))
+        Session.testInstance(tournamentFeatures = RealmList(t3,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t2,t3,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t3))
+        Session.testInstance(tournamentFeatures = RealmList(t2,t4, t3))
+        Session.testInstance(tournamentFeatures = RealmList(t1))
+        realm.commitTransaction()
 
-        val currency = realm.createObject(net.pokeranalytics.android.model.realm.Currency::class.java, "1")
+        val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
-        currency.code = "AUD"
+        filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
 
-        val b1 = realm.createObject(Bankroll::class.java, "1")
+        val sessions = FilterManager().filter(
-        val b2 = realm.createObject(Bankroll::class.java, "2")
+            realm,
-        b2.currency = currency
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(8, sessions.size)
+    }
+
+    @Test
+    fun testSingleAnyTournamentFeatureFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val t1 = realm.createObject(TournamentFeature::class.java, "1")
+        val t2 = realm.createObject(TournamentFeature::class.java, "2")
+        val t3 = realm.createObject(TournamentFeature::class.java, "3")
+        val t4 = realm.createObject(TournamentFeature::class.java, "4")
+        val s1 = Session.testInstance(tournamentFeatures = RealmList(t1,t2))
+        val s2 = Session.testInstance(tournamentFeatures = RealmList(t2,t3))
+        Session.testInstance(tournamentFeatures = RealmList(t3,t4))
+        val s3 = Session.testInstance(tournamentFeatures = RealmList(t1,t2,t3,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t4))
+        Session.testInstance(tournamentFeatures = RealmList(t1,t3))
+        val s4 = Session.testInstance(tournamentFeatures = RealmList(t2,t4, t3))
+        Session.testInstance(tournamentFeatures = RealmList(t1))
+        realm.commitTransaction()
 
-        val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
-        s1.cgBigBlind = 1.0
+        filter.valueMap = mapOf("ids" to arrayOf(t2.id))
-        s1.cgSmallBlind = 0.5
 
-        val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
+        val sessions = FilterManager().filter(
-        s2.cgBigBlind = 2.0
+            realm,
-        s2.cgSmallBlind = 1.0
+            Session::class.java,
+            arrayListOf(filter)
+        )
 
-        val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
+        val result = arrayListOf(s1.id, s2.id, s3.id, s4.id)
-        s3.cgBigBlind = 2.0
+
-        s3.cgSmallBlind = 1.0
+        Assert.assertEquals(4, sessions.size)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
 
+    @Test
+    fun testTableSizeFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(tableSize = 2)
+        val s2 = Session.testInstance(tableSize = 4)
+        Session.testInstance(tableSize = 9)
+        Session.testInstance(tableSize = 10)
         realm.commitTransaction()
 
+        val filter = SessionFilterable.TABLE_SIZE
+        filter.valueMap = mapOf("values" to arrayOf(2,4))
 
-        val filter = SessionFilterable.BLINDS
+        val sessions = FilterManager().filter(
-        filter.valueMap = mapOf("map" to arrayOf(
+            realm,
-            mapOf(
+            Session::class.java,
-            "sb" to 1.0,
+            arrayListOf(filter)
-            "bb" to 2.0,
+        )
-            "code" to null
+
-            ),
+        Assert.assertEquals(2, sessions.size)
-            mapOf(
+
-            "sb" to 0.5,
+        val result = arrayListOf(s1.id, s2.id)
-            "bb" to 1.0,
+        sessions.forEach {
-            "code" to null
+            Assert.assertTrue(result.contains((it as Session).id))
-            )))
+        }
+    }
+
+    @Test
+    fun testMoreThanNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        Session.testInstance(netResult = 200.0)
+        val s1 = Session.testInstance(netResult = 500.0)
+        Session.testInstance(netResult = 50.0)
+        val s2 = Session.testInstance(netResult = 570.0)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.MORE_THAN_NET_RESULT
+        filter.valueMap = mapOf("net" to 204.0)
 
         val sessions = FilterManager().filter(
             realm,
@@ -299,8 +501,67 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         )
 
         Assert.assertEquals(2, sessions.size)
-        sessions.map {
+
-            Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
+        val result = arrayListOf(s1.id, s2.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun testLessThanNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(netResult = 200.0)
+        val s2 = Session.testInstance(netResult = 500.0)
+        val s3 = Session.testInstance(netResult = 50.0)
+        Session.testInstance(netResult = 570.0)
+        realm.commitTransaction()
+
+        val filter = SessionFilterable.LESS_THAN_NET_RESULT
+        filter.valueMap = mapOf("net" to 540.0)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filter)
+        )
+
+        Assert.assertEquals(3, sessions.size)
+
+        val result = arrayListOf(s1.id, s2.id, s3.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
+        }
+    }
+
+    @Test
+    fun tesNetResultFilter() {
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val s1 = Session.testInstance(netResult = 200.0)
+        val s2 = Session.testInstance(netResult = 500.0)
+        val s3 = Session.testInstance(netResult = 50.0)
+        Session.testInstance(netResult = 570.0)
+        realm.commitTransaction()
+
+        val filterMore = SessionFilterable.MORE_THAN_NET_RESULT
+        filterMore.valueMap = mapOf("net" to 200.0)
+
+        val filterLess = SessionFilterable.LESS_THAN_NET_RESULT
+        filterLess.valueMap = mapOf("net" to 400.0)
+
+        val sessions = FilterManager().filter(
+            realm,
+            Session::class.java,
+            arrayListOf(filterLess, filterMore)
+        )
+
+        Assert.assertEquals(1, sessions.size)
+
+        val result = arrayListOf(s1.id)
+        sessions.forEach {
+            Assert.assertTrue(result.contains((it as Session).id))
         }
     }
 }

app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt

@@ -6,34 +6,35 @@ import net.pokeranalytics.android.exceptions.FilterValueMapException
 import net.pokeranalytics.android.model.filter.interfaces.Filterable
 import net.pokeranalytics.android.model.realm.Session
 
-enum class SessionFilterable: Filterable {
+enum class SessionFilterable(private var fieldName:String? = null): Filterable {
     LIVE,
     CASH,
     ONLINE,
     TOURNAMENT,
-    BANKROLL,
+    BANKROLL("bankroll.id"),
+    GAME("game.id"),
+    TOURNAMENT_NAME("tournamentName.id"),
+    ANY_TOURNAMENT_FEATURES,
+    ALL_TOURNAMENT_FEATURES,
+    LOCATION("location.id"),
+    LIMIT("limit"),
+    TABLE_SIZE("tableSize"),
+    NUMBER_OF_TABLE("numberOfTable"),
+    TOURNAMENT_TYPE("tournamentType"),
     BLINDS,
+    LESS_THAN_NET_RESULT,
+    MORE_THAN_NET_RESULT,
     ;
 
     private enum class Field(var fieldName:String) {
         LIVE("bankroll.live"),
         CASH("type"),
-        BANKROLL("bankroll.id"),
-        START_DATE("startDate"),
-        END_DATE("endDate"),
         CURRENCY("bankroll.currency"),
         CURRENCY_CODE("bankroll.currency.code"),
         BIG_BLIND("cgBigBlind"),
         SMALL_BLIND("cgSmallBlind"),
-        GAME("game.id"),
-        LIMIT("limit"),
-        TABLE_SIZE("tableSize"),
-        LOCATION("location.id"),
-        NUMBER_OF_TABLE("numberOfTable"),
         COMMENT("comment"),
-        TOURNAMENT_TYPE("tournamentType"),
+        TOURNAMENT_FEATURES("tournamentFeatures.id"),
-        TOURNAMENT_NAME("tournamentName.id"),
-        TOURNAMENT_FEATURES("tournamentFeature.id"),
         TOURNAMENT_NUMBER_OF_PLAYER("tournamentNumberOfPlayers"),
         TOURNAMENT_ENTRY_FEE("tournamentEntryFee"),
         RESULT_BUY_IN("result.buyin"),
@@ -48,21 +49,58 @@ enum class SessionFilterable: Filterable {
     override val filterValuesExceptedKeys : Array<String>?
         get() {
             return when (this) {
-                BANKROLL -> arrayOf("ids")
+                BANKROLL, GAME, LOCATION, ANY_TOURNAMENT_FEATURES, ALL_TOURNAMENT_FEATURES -> arrayOf("ids")
+                LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> arrayOf("values")
                 BLINDS -> arrayOf("map")
+                MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> arrayOf("net")
                 else -> null
             }
         }
 
+    var between: Boolean = false
+    var moreThan: Boolean = false
+    var lessThan: Boolean = false
+    var strict: Boolean = false
+
     override fun filter(realmQuery: RealmQuery<out RealmObject>): RealmQuery<out RealmObject> {
         return when (this) {
             LIVE -> realmQuery.equalTo(Field.LIVE.fieldName, true)
             CASH -> realmQuery.equalTo(Field.CASH.fieldName, Session.Type.CASH_GAME.ordinal)
             ONLINE -> LIVE.filter(realmQuery.not())
             TOURNAMENT -> CASH.filter(realmQuery.not())
-            BANKROLL -> {
+            ALL_TOURNAMENT_FEATURES -> {
+                val ids : Array<String> by filterValues
+                ids.forEach {
+                    realmQuery.equalTo(Field.TOURNAMENT_FEATURES.fieldName, it)
+                }
+                realmQuery
+            }
+            ANY_TOURNAMENT_FEATURES -> {
+                val ids : Array<String> by filterValues
+                realmQuery.`in`(Field.TOURNAMENT_FEATURES.fieldName, ids)
+            }
+            BANKROLL, GAME, LOCATION, TOURNAMENT_NAME -> {
                 val ids : Array<String> by filterValues
-                realmQuery.`in`(Field.BANKROLL.fieldName, ids)
+                this.fieldName?.let {
+                    realmQuery.`in`(it, ids)
+                } ?: run {
+                    throw FilterValueMapException("fieldName is missing")
+                }
+            }
+            LIMIT, TOURNAMENT_TYPE, TABLE_SIZE, NUMBER_OF_TABLE -> {
+                val values : Array<Int?>? by filterValues
+                this.fieldName?.let {
+                    realmQuery.`in`(it, values)
+                } ?: run {
+                    throw FilterValueMapException("fieldName is missing")
+                }
+            }
+            MORE_THAN_NET_RESULT, LESS_THAN_NET_RESULT -> {
+                val net : Double by filterValues
+                if (this == LESS_THAN_NET_RESULT) {
+                    realmQuery.not()
+                }
+                realmQuery.greaterThanOrEqualTo(Field.RESULT_NET.fieldName, net)
             }
             BLINDS -> {
                 val map : Array<Map<String,Any?>> by filterValues