You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
417 lines
14 KiB
417 lines
14 KiB
package net.pokeranalytics.android
|
|
|
|
import androidx.test.ext.junit.runners.AndroidJUnit4
|
|
import io.realm.RealmResults
|
|
import net.pokeranalytics.android.calculus.Calculator
|
|
import net.pokeranalytics.android.calculus.ComputedResults
|
|
import net.pokeranalytics.android.calculus.SessionGroup
|
|
import net.pokeranalytics.android.calculus.Stat
|
|
import net.pokeranalytics.android.model.realm.Session
|
|
import net.pokeranalytics.android.model.realm.TimeFrame
|
|
import org.junit.Assert
|
|
import org.junit.Assert.assertEquals
|
|
import org.junit.Test
|
|
import org.junit.runner.RunWith
|
|
import java.text.SimpleDateFormat
|
|
import java.util.*
|
|
|
|
/**
|
|
* Instrumented test, which will execute on an Android device.
|
|
*
|
|
* See [testing documentation](http://d.android.com/tools/testing).
|
|
*/
|
|
@RunWith(AndroidJUnit4::class)
|
|
|
|
class ExampleInstrumentedUnitTest : RealmInstrumentedUnitTest() {
|
|
|
|
// convenience extension
|
|
fun Session.Companion.testInstance(netResult: Double, startDate: Date, endDate: Date?): Session {
|
|
val session: Session = Session.newInstance()
|
|
session.result?.netResult = netResult
|
|
session.timeFrame?.setDate(startDate, endDate)
|
|
return session
|
|
}
|
|
|
|
@Test
|
|
fun testSessionStats() {
|
|
|
|
val realm = this.mockRealm
|
|
realm.beginTransaction()
|
|
|
|
val s1 = realm.createObject(Session::class.java, "1")
|
|
val s2 = realm.createObject(Session::class.java, "2")
|
|
|
|
s1.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s2.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
|
|
s1.result = realm.createObject(net.pokeranalytics.android.model.realm.Result::class.java)
|
|
s2.result = realm.createObject(net.pokeranalytics.android.model.realm.Result::class.java)
|
|
|
|
s1.result?.buyin = 100.0 // net result = -100
|
|
s2.result?.buyin = 200.0
|
|
s2.result?.cashout = 500.0 // net result = 300
|
|
|
|
s1.cgBigBlind = 0.5 // bb net result = -200bb
|
|
s2.cgBigBlind = 2.0 // bb net result = 150bb
|
|
|
|
realm.insert(s1)
|
|
realm.insert(s2)
|
|
realm.commitTransaction()
|
|
|
|
val sdf = SimpleDateFormat("dd/M/yyyy hh:mm")
|
|
|
|
val sd1 = sdf.parse("01/1/2019 10:00")
|
|
val ed1 = sdf.parse("01/1/2019 11:00")
|
|
val sd2 = sdf.parse("02/1/2019 08:00")
|
|
val ed2 = sdf.parse("02/1/2019 11:00")
|
|
|
|
realm.beginTransaction()
|
|
|
|
s1.timeFrame?.setDate(sd1, ed1) // duration = 1h, hourly = -100, bb100 = -200bb / 25hands * 100 = -800
|
|
s2.timeFrame?.setDate(sd2, ed2) // duration = 3h, hourly = 100, bb100 = 150 / 75 * 100 = +200
|
|
|
|
realm.copyToRealmOrUpdate(s1)
|
|
realm.copyToRealmOrUpdate(s2)
|
|
|
|
realm.commitTransaction()
|
|
|
|
val sessions = realm.where(Session::class.java).findAll()
|
|
val group = SessionGroup(name = "test", sessions = sessions)
|
|
|
|
val options = Calculator.Options()
|
|
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
|
|
|
|
val results: ComputedResults = Calculator.compute(group, options)
|
|
val delta = 0.01
|
|
|
|
val sum = results.computedStat(Stat.NETRESULT)
|
|
if (sum != null) {
|
|
assertEquals(200.0, sum.value, delta)
|
|
} else {
|
|
Assert.fail("No Net result stat")
|
|
}
|
|
|
|
val average = results.computedStat(Stat.AVERAGE)
|
|
if (average != null) {
|
|
assertEquals(100.0, average.value, delta)
|
|
} else {
|
|
Assert.fail("No AVERAGE stat")
|
|
}
|
|
|
|
val duration = results.computedStat(Stat.DURATION)
|
|
if (duration != null) {
|
|
assertEquals(4.0, duration.value, delta)
|
|
} else {
|
|
Assert.fail("No duration stat")
|
|
}
|
|
|
|
val hourlyRate = results.computedStat(Stat.HOURLY_RATE)
|
|
if (hourlyRate != null) {
|
|
assertEquals(50.0, hourlyRate.value, delta)
|
|
} else {
|
|
Assert.fail("No houry rate stat")
|
|
}
|
|
val handsPlayed = results.computedStat(Stat.HANDS_PLAYED)
|
|
if (handsPlayed != null) {
|
|
assertEquals(100.0, handsPlayed.value, delta)
|
|
} else {
|
|
Assert.fail("No hands played stat")
|
|
}
|
|
val numberOfGames = results.computedStat(Stat.NUMBER_OF_GAMES)
|
|
if (numberOfGames != null) {
|
|
assertEquals(2, numberOfGames.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfGames stat")
|
|
}
|
|
val numberOfSets = results.computedStat(Stat.NUMBER_OF_SETS)
|
|
if (numberOfSets != null) {
|
|
assertEquals(2, numberOfSets.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfSets stat")
|
|
}
|
|
val avgBuyin = results.computedStat(Stat.AVERAGE_BUYIN)
|
|
if (avgBuyin != null) {
|
|
assertEquals(150.0, avgBuyin.value, delta)
|
|
} else {
|
|
Assert.fail("No avgBuyin stat")
|
|
}
|
|
val avgDuration = results.computedStat(Stat.AVERAGE_DURATION)
|
|
if (avgDuration != null) {
|
|
assertEquals(2.0, avgDuration.value, delta)
|
|
} else {
|
|
Assert.fail("No avgDuration stat")
|
|
}
|
|
val roi = results.computedStat(Stat.ROI)
|
|
if (roi != null) {
|
|
assertEquals(200 / 300.0, roi.value, delta)
|
|
} else {
|
|
Assert.fail("No roi stat")
|
|
}
|
|
|
|
val avgBBNet = results.computedStat(Stat.AVERAGE_NET_BB)
|
|
if (avgBBNet != null) {
|
|
assertEquals(-25.0, avgBBNet.value, delta)
|
|
} else {
|
|
Assert.fail("No avgBBNet stat")
|
|
}
|
|
val bbHourlyRate = results.computedStat(Stat.HOURLY_RATE_BB)
|
|
if (bbHourlyRate != null) {
|
|
assertEquals(-12.5, bbHourlyRate.value, delta)
|
|
} else {
|
|
Assert.fail("No bbHourlyRate stat")
|
|
}
|
|
val netbbPer100Hands = results.computedStat(Stat.NET_BB_PER_100_HANDS)
|
|
if (netbbPer100Hands != null) {
|
|
assertEquals(-50.0, netbbPer100Hands.value, delta)
|
|
} else {
|
|
Assert.fail("No netbbPer100Hands stat")
|
|
}
|
|
|
|
val std = results.computedStat(Stat.STANDARD_DEVIATION)
|
|
if (std != null) {
|
|
assertEquals(200.0, std.value, delta)
|
|
} else {
|
|
Assert.fail("No std stat")
|
|
}
|
|
|
|
val stdHourly = results.computedStat(Stat.STANDARD_DEVIATION_HOURLY)
|
|
if (stdHourly != null) {
|
|
assertEquals(111.8, stdHourly.value, delta)
|
|
} else {
|
|
Assert.fail("No stdHourly stat")
|
|
}
|
|
|
|
val std100 = results.computedStat(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS)
|
|
if (std100 != null) {
|
|
assertEquals(559.01, std100.value, delta)
|
|
} else {
|
|
Assert.fail("No std100 stat")
|
|
}
|
|
|
|
}
|
|
|
|
@Test
|
|
fun testOverlappingSessions1() {
|
|
|
|
val realm = this.mockRealm
|
|
realm.beginTransaction()
|
|
|
|
val s1 = realm.createObject(Session::class.java, "1")
|
|
val s2 = realm.createObject(Session::class.java, "2")
|
|
|
|
s1.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s2.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
|
|
s1.result = realm.createObject(net.pokeranalytics.android.model.realm.Result::class.java)
|
|
s2.result = realm.createObject(net.pokeranalytics.android.model.realm.Result::class.java)
|
|
|
|
realm.insert(s1)
|
|
realm.insert(s2)
|
|
realm.commitTransaction()
|
|
|
|
val sdf = SimpleDateFormat("dd/M/yyyy hh:mm")
|
|
|
|
val sd1 = sdf.parse("01/1/2019 09:00")
|
|
val ed1 = sdf.parse("01/1/2019 10:00")
|
|
val sd2 = sdf.parse("01/1/2019 08:00")
|
|
val ed2 = sdf.parse("01/1/2019 11:00")
|
|
|
|
realm.beginTransaction()
|
|
|
|
s1.timeFrame?.setDate(sd1, ed1) // duration = 1h, hourly = -100, bb100 = -200bb / 25hands * 100 = -800
|
|
s2.timeFrame?.setDate(sd2, ed2) // duration = 4h, hourly = 100, bb100 = 150 / 75 * 100 = +200
|
|
|
|
realm.copyToRealmOrUpdate(s1)
|
|
realm.copyToRealmOrUpdate(s2)
|
|
|
|
realm.commitTransaction()
|
|
|
|
val sessions = realm.where(Session::class.java).findAll()
|
|
val group = SessionGroup(name = "test", sessions = sessions)
|
|
|
|
val options = Calculator.Options()
|
|
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
|
|
|
|
val results: ComputedResults = Calculator.compute(group, options)
|
|
val delta = 0.01
|
|
|
|
val duration = results.computedStat(Stat.DURATION)
|
|
if (duration != null) {
|
|
assertEquals(3.0, duration.value, delta)
|
|
} else {
|
|
Assert.fail("No Net result stat")
|
|
}
|
|
|
|
val numberOfSets = results.computedStat(Stat.NUMBER_OF_SETS)
|
|
if (numberOfSets != null) {
|
|
assertEquals(1, numberOfSets.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfSets stat")
|
|
}
|
|
|
|
val numberOfGames = results.computedStat(Stat.NUMBER_OF_GAMES)
|
|
if (numberOfGames != null) {
|
|
assertEquals(2, numberOfGames.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfSets stat")
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun testOverlappingSessions2() {
|
|
|
|
val realm = this.mockRealm
|
|
realm.beginTransaction()
|
|
|
|
val s1 = realm.createObject(Session::class.java, "1")
|
|
val s2 = realm.createObject(Session::class.java, "2")
|
|
val s3 = realm.createObject(Session::class.java, "3")
|
|
|
|
s1.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s2.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s3.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
|
|
realm.insert(s1)
|
|
realm.insert(s2)
|
|
realm.insert(s3)
|
|
realm.commitTransaction()
|
|
|
|
val sdf = SimpleDateFormat("dd/M/yyyy hh:mm")
|
|
|
|
val sd1 = sdf.parse("01/1/2019 05:00")
|
|
val ed1 = sdf.parse("01/1/2019 09:00")
|
|
val sd2 = sdf.parse("01/1/2019 07:00")
|
|
val ed2 = sdf.parse("01/1/2019 11:00")
|
|
val sd3 = sdf.parse("01/1/2019 03:00")
|
|
val ed3 = sdf.parse("01/1/2019 06:00")
|
|
|
|
realm.beginTransaction()
|
|
|
|
s1.timeFrame?.setDate(sd1, ed1) // duration = 4h
|
|
s2.timeFrame?.setDate(sd2, ed2) // duration = 4h
|
|
s3.timeFrame?.setDate(sd3, ed3) // duration = 3h
|
|
|
|
realm.copyToRealmOrUpdate(s1)
|
|
realm.copyToRealmOrUpdate(s2)
|
|
realm.copyToRealmOrUpdate(s3)
|
|
|
|
realm.commitTransaction()
|
|
|
|
val sessions = realm.where(Session::class.java).findAll()
|
|
val group = SessionGroup(name = "test", sessions = sessions)
|
|
|
|
val options = Calculator.Options()
|
|
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
|
|
|
|
val results: ComputedResults = Calculator.compute(group, options)
|
|
val delta = 0.01
|
|
|
|
val duration = results.computedStat(Stat.DURATION)
|
|
if (duration != null) {
|
|
assertEquals(8.0, duration.value, delta)
|
|
} else {
|
|
Assert.fail("No Net result stat")
|
|
}
|
|
|
|
val numberOfSets = results.computedStat(Stat.NUMBER_OF_SETS)
|
|
if (numberOfSets != null) {
|
|
assertEquals(1, numberOfSets.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfSets stat")
|
|
}
|
|
|
|
val numberOfGames = results.computedStat(Stat.NUMBER_OF_GAMES)
|
|
if (numberOfGames != null) {
|
|
assertEquals(3, numberOfGames.value.toInt())
|
|
} else {
|
|
Assert.fail("No numberOfSets stat")
|
|
}
|
|
|
|
}
|
|
|
|
var sessions: RealmResults<Session>? = null
|
|
|
|
// @Test
|
|
fun testOverlappingSessionDeletion() {
|
|
|
|
val realm = this.mockRealm
|
|
this.sessions = realm.where(Session::class.java).findAll() // monitor session deletions
|
|
|
|
this.sessions?.addChangeListener { t, changeSet ->
|
|
|
|
val deletedSessions = realm.where(Session::class.java).`in`("id", changeSet.deletions.toTypedArray()).findAll()
|
|
deletedSessions.forEach { it.cleanup() }
|
|
|
|
}
|
|
|
|
realm.beginTransaction()
|
|
|
|
val s1 = realm.createObject(Session::class.java, "1")
|
|
val s2 = realm.createObject(Session::class.java, "2")
|
|
val s3 = realm.createObject(Session::class.java, "3")
|
|
|
|
s1.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s2.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
s3.timeFrame = realm.createObject(TimeFrame::class.java)
|
|
|
|
realm.insert(s1)
|
|
realm.insert(s2)
|
|
realm.insert(s3)
|
|
realm.commitTransaction()
|
|
|
|
val sdf = SimpleDateFormat("dd/M/yyyy hh:mm")
|
|
|
|
val sd1 = sdf.parse("01/1/2019 05:00")
|
|
val ed1 = sdf.parse("01/1/2019 09:00")
|
|
val sd2 = sdf.parse("01/1/2019 07:00")
|
|
val ed2 = sdf.parse("01/1/2019 11:00")
|
|
val sd3 = sdf.parse("01/1/2019 03:00")
|
|
val ed3 = sdf.parse("01/1/2019 06:00")
|
|
|
|
realm.beginTransaction()
|
|
|
|
s1.timeFrame?.setDate(sd1, ed1) // duration = 4h
|
|
s2.timeFrame?.setDate(sd2, ed2) // duration = 4h
|
|
s3.timeFrame?.setDate(sd3, ed3) // duration = 3h
|
|
|
|
realm.copyToRealmOrUpdate(s1)
|
|
realm.copyToRealmOrUpdate(s2)
|
|
realm.copyToRealmOrUpdate(s3)
|
|
|
|
realm.commitTransaction()
|
|
|
|
val sessions = realm.where(Session::class.java).findAll()
|
|
val group = SessionGroup(name = "test", sessions = sessions)
|
|
|
|
val options = Calculator.Options()
|
|
options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION)
|
|
|
|
val results: ComputedResults = Calculator.compute(group, options)
|
|
val delta = 0.01
|
|
|
|
val duration = results.computedStat(Stat.DURATION)
|
|
if (duration != null) {
|
|
assertEquals(8.0, duration.value, delta)
|
|
} else {
|
|
Assert.fail("No duration stat")
|
|
}
|
|
|
|
// realm.beginTransaction()
|
|
// s1.deleteFromRealm()
|
|
// realm.commitTransaction()
|
|
realm.executeTransaction {
|
|
s1.deleteFromRealm()
|
|
}
|
|
|
|
val group2 = SessionGroup(name = "test", sessions = sessions)
|
|
val results2: ComputedResults = Calculator.compute(group2, options)
|
|
|
|
val duration2 = results2.computedStat(Stat.DURATION)
|
|
if (duration2 != null) {
|
|
assertEquals(7.0, duration2.value, delta)
|
|
} else {
|
|
Assert.fail("No duration2 stat")
|
|
}
|
|
|
|
}
|
|
} |