staxriver
/
poker-analytics
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
feature/top10
Aurelien Hubert 7 years ago
parent 940666adb9 9a9bc21386
commit 3a4249d3c4
4 changed files with 646 additions and 128 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 28
      app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt
  2. 205
      app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
  3. 471
      app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
  4. 70
      app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt

28
app/src/androidTest/java/net/pokeranalytics/android/filter/BaseFilterInstrumentedUnitTest.kt
Unescape View File

@ -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.Session
import net.pokeranalytics.android.model.realm.*
import java.util.*
open class BaseFilterInstrumentedUnitTest : RealmInstrumentedUnitTest() {
// convenience extension
fun Session.Companion.testInstance(
netResult: Double,
isTournament: Boolean,
startDate: Date,
netResult: Double = 0.0,
isTournament: Boolean = false,
startDate: Date = Date(),
endDate: Int = 1,
bankroll: Bankroll? = null
): Session {
bankroll: Bankroll? = null,
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

205
app/src/androidTest/java/net/pokeranalytics/android/filter/BlindFilterInstrumentedTest.kt
Unescape View File

@ -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))
}
}
}

471
app/src/androidTest/java/net/pokeranalytics/android/filter/SessionFilterInstrumentedUnitTest.kt
Unescape View File

@ -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.Session
import net.pokeranalytics.android.model.realm.*
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")
currency.code = "AUD"
Assert.assertEquals(1, sessions.size)
(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)
s1.cgBigBlind = 1.0
s1.cgSmallBlind = 0.5
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
)
val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
s2.cgBigBlind = 1.0
s2.cgSmallBlind = 0.5
Assert.assertEquals(6, sessions.size)
val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
s3.cgBigBlind = 2.0
s3.cgSmallBlind = 1.0
val result = arrayListOf(b1.id, b2.id)
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
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to 0.5,
"bb" to 1.0,
"code" to null
)))
val filter = SessionFilterable.GAME
filter.valueMap = mapOf("ids" to arrayOf(g2.id))
val sessions = FilterManager().filter(
realm,
@ -151,46 +192,93 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
arrayListOf(filter)
)
Assert.assertEquals(2, sessions.size)
sessions.map {
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
Assert.assertEquals(1, sessions.size)
(sessions[0] as Session).game?.run {
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")
currency.code = "AUD"
val filter = SessionFilterable.GAME
filter.valueMap = mapOf("ids" to arrayOf(g2.id, g3.id))
val b1 = realm.createObject(Bankroll::class.java, "1")
val b2 = realm.createObject(Bankroll::class.java, "2")
b2.currency = currency
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
)
val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
s1.cgBigBlind = 1.0
s1.cgSmallBlind = 0.5
Assert.assertEquals(6, sessions.size)
val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
s2.cgBigBlind = 1.0
s2.cgSmallBlind = 0.5
val result = arrayListOf(g2.id, g3.id)
val s3 = Session.testInstance(100.0, false, Date(), 1, b1)
s3.cgBigBlind = 2.0
s3.cgSmallBlind = 1.0
sessions.forEach {
Assert.assertTrue(result.contains((it as Session).game?.id))
}
}
@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
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to null,
"bb" to 1.0,
"code" to null
)))
@Test
fun testMultipleLocationFilter() {
val realm = this.mockRealm
realm.beginTransaction()
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)
sessions.map {
Assert.assertTrue(arrayListOf(s1.id, s2.id).contains((it as Session).id))
Assert.assertEquals(6, sessions.size)
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")
currency.code = "AUD"
val filter = SessionFilterable.TOURNAMENT_NAME
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id))
val b1 = realm.createObject(Bankroll::class.java, "1")
val b2 = realm.createObject(Bankroll::class.java, "2")
b2.currency = currency
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
)
val s1 = Session.testInstance(100.0, false, Date(), 1, b1)
s1.cgBigBlind = 1.0
s1.cgSmallBlind = 0.5
Assert.assertEquals(6, sessions.size)
val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
s2.cgBigBlind = 1.0
s2.cgSmallBlind = 0.5
val result = arrayListOf(t1.id, t2.id)
val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
s3.cgBigBlind = 2.0
s3.cgSmallBlind = 1.0
sessions.forEach {
Assert.assertTrue(result.contains((it as Session).tournamentName?.id))
}
}
@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.BLINDS
filter.valueMap = mapOf("map" to arrayOf(mapOf(
"sb" to 1.0,
"bb" to 2.0,
"code" to "AUD"
)))
val filter = SessionFilterable.ALL_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
val sessions = FilterManager().filter(
realm,
@ -246,51 +384,115 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
)
Assert.assertEquals(1, sessions.size)
sessions.map {
Assert.assertEquals(s3.id, (it as Session).id)
(sessions[0] as Session)?.run {
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")
currency.code = "AUD"
val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t1.id, t2.id, t3.id, t4.id))
val b1 = realm.createObject(Bankroll::class.java, "1")
val b2 = realm.createObject(Bankroll::class.java, "2")
b2.currency = currency
val sessions = FilterManager().filter(
realm,
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)
s1.cgBigBlind = 1.0
s1.cgSmallBlind = 0.5
val filter = SessionFilterable.ANY_TOURNAMENT_FEATURES
filter.valueMap = mapOf("ids" to arrayOf(t2.id))
val s2 = Session.testInstance(100.0, false, Date(), 1, b1)
s2.cgBigBlind = 2.0
s2.cgSmallBlind = 1.0
val sessions = FilterManager().filter(
realm,
Session::class.java,
arrayListOf(filter)
)
val s3 = Session.testInstance(100.0, false, Date(), 1, b2)
s3.cgBigBlind = 2.0
s3.cgSmallBlind = 1.0
val result = arrayListOf(s1.id, s2.id, s3.id, s4.id)
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
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)
val result = arrayListOf(s1.id, s2.id)
sessions.forEach {
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))
}
}
}

70
app/src/main/java/net/pokeranalytics/android/model/filter/SessionFilterable.kt
Unescape View File

@ -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_NAME("tournamentName.id"),
TOURNAMENT_FEATURES("tournamentFeature.id"),
TOURNAMENT_FEATURES("tournamentFeatures.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

Write Preview
Loading…
Cancel
Save