diff --git a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt index f7dac0f4..6057578f 100644 --- a/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt +++ b/app/src/androidTest/java/net/pokeranalytics/android/unitTests/StatsInstrumentedUnitTest.kt @@ -112,6 +112,10 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { s2.startDate = sd2 s2.endDate = ed2 + val l1 = realm.createObject(Location::class.java, UUID.randomUUID().toString()) + s1.location = l1 + s2.location = l1 + realm.commitTransaction() assertEquals(2, computableResults.size) @@ -124,7 +128,8 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val group = ComputableGroup("test", listOf(), stats) val options = Calculator.Options() - options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION) + options.displayedStats = listOf(Stat.STANDARD_DEVIATION_BB_PER_100_HANDS, Stat.STANDARD_DEVIATION, + Stat.LONGEST_STREAKS, Stat.LOCATIONS_PLAYED, Stat.DAYS_PLAYED) val results: ComputedResults = Calculator.compute(realm, group, options) val delta = 0.01 @@ -233,6 +238,42 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { Assert.fail("No std100 stat") } + results.computedStat(Stat.MAXIMUM_NETRESULT)?.let { + assertEquals(300.0, it.value, delta) + } ?: run { + Assert.fail("No MAXIMUM_NETRESULT") + } + + results.computedStat(Stat.MINIMUM_NETRESULT)?.let { + assertEquals(-100.0, it.value, delta) + } ?: run { + Assert.fail("No MINIMUM_NETRESULT") + } + + results.computedStat(Stat.MAXIMUM_DURATION)?.let { + assertEquals(3.0 * 3600 * 1000, it.value, delta) + } ?: run { + Assert.fail("No MAXIMUM_DURATION") + } + + results.computedStat(Stat.DAYS_PLAYED)?.let { + assertEquals(2.0, it.value, delta) + } ?: run { + Assert.fail("No DAYS_PLAYED") + } + + results.computedStat(Stat.LOCATIONS_PLAYED)?.let { + assertEquals(1.0, it.value, delta) + } ?: run { + Assert.fail("No LOCATIONS_PLAYED") + } + + results.computedStat(Stat.LONGEST_STREAKS)?.let { + assertEquals(1.0, it.value, delta) + assertEquals(1.0, it.secondValue!!, delta) + } ?: run { + Assert.fail("No LOCATIONS_PLAYED") + } } @Test @@ -513,7 +554,7 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val sets = realm.where(SessionSet::class.java).findAll() - Assert.assertEquals(2, sets.size) + assertEquals(2, sets.size) } @@ -617,7 +658,7 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val results: ComputedResults = Calculator.compute(realm, group, options) val netResult = results.computedStat(Stat.NETRESULT) - Assert.assertEquals(250.0, netResult?.value) + assertEquals(250.0, netResult?.value) } // @Test @@ -653,7 +694,7 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val results: ComputedResults = Calculator.compute(realm, group, options) val netResult = results.computedStat(Stat.NETRESULT) - Assert.assertEquals(250.0, netResult?.value) + assertEquals(250.0, netResult?.value) println("currency set rate real test starts here") @@ -669,8 +710,44 @@ class StatsInstrumentedUnitTest : RealmInstrumentedUnitTest() { val updatedGroup = ComputableGroup("test", listOf(), stats) val updatedResults: ComputedResults = Calculator.compute(realm, updatedGroup, options) val updatedNetResult = updatedResults.computedStat(Stat.NETRESULT) - Assert.assertEquals(650.0, updatedNetResult?.value) + assertEquals(650.0, updatedNetResult?.value) } + + @Test + fun testDaysPlayed() { + + val realm = this.mockRealm + + realm.executeTransaction { + + val s1 = newSessionInstance(realm) + val s2 = newSessionInstance(realm) + + 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 19:00") + val ed2 = sdf.parse("01/1/2019 20:00") + + s1.startDate = sd1 + s1.endDate = ed1 + + s2.startDate = sd2 + s2.endDate = ed2 + } + + val group = ComputableGroup("", listOf(), listOf()) + val options = Calculator.Options(stats = listOf(Stat.DAYS_PLAYED)) + val report = Calculator.computeGroups(realm, listOf(group), options) + + report.results.firstOrNull()?.computedStat(Stat.DAYS_PLAYED)?.let { + assertEquals(1, it.value.toInt()) + } ?: run { + Assert.fail("Missing DAYS_PLAYED") + } + + } } \ No newline at end of file diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt index efe7d906..59538abc 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt @@ -197,7 +197,7 @@ class Calculator { var tWinningSessionCount = 0 var tBuyinSum = 0.0 var tHands = 0.0 - var winStreak = 0; var loseStreak = 0; var currentStreak = 0 + var longestWinStreak = 0; var longestLoseStreak = 0; var currentStreak = 0 computables.forEach { computable -> index++ @@ -208,20 +208,19 @@ class Calculator { tBuyinSum += computable.ratedBuyin tHands += computable.estimatedHands - if (computable.isPositive == 1) { - if (currentStreak >= 0) { + if (computable.isPositive == 1) { // positive result + if (currentStreak >= 0) { // currently positive streak currentStreak++ - } else { + } else { // currently negative streak + longestLoseStreak = min(longestLoseStreak, currentStreak) currentStreak = 1 - loseStreak = min(loseStreak, currentStreak) } - } - if (computable.isPositive == 0) { - if (currentStreak <= 0) { + } else { // negative result + if (currentStreak <= 0) { // currently negative streak currentStreak-- - } else { + } else { // currently positive streak + longestWinStreak = max(longestWinStreak, currentStreak) currentStreak = -1 - winStreak = max(winStreak, currentStreak) } } @@ -249,12 +248,13 @@ class Calculator { } if (currentStreak >= 0) { - winStreak = max(winStreak, currentStreak) + longestWinStreak = max(longestWinStreak, currentStreak) } else { - loseStreak = min(loseStreak, currentStreak) + longestLoseStreak = min(longestLoseStreak, currentStreak) } - results.addStat(LONGEST_STREAKS, winStreak.toDouble(), loseStreak.toDouble()) + // loseStreak is negative and we want it positive + results.addStat(LONGEST_STREAKS, longestWinStreak.toDouble(), -longestLoseStreak.toDouble()) } @@ -271,90 +271,88 @@ class Calculator { val hourlyRate = gSum / gHourlyDuration // var bbHourlyRate = gBBSum / gDuration - when (options.evolutionValues) { - Options.EvolutionValues.STANDARD, Options.EvolutionValues.TIMED -> { - - var tHourlyDuration = 0.0 - var tIndex = 0 - var tSum = 0.0 - var tTotalHands = 0.0 - var tBBSum = 0.0 - var tHourlyRate = 0.0 - var tHourlyRateBB = 0.0 - val daysSet = mutableSetOf() - - sessionSets.forEach { sessionSet -> - tIndex++ - tHourlyDuration += sessionSet.hourlyDuration - tSum += sessionSet.ratedNet - tTotalHands += sessionSet.estimatedHands - tBBSum += sessionSet.bbNet - - tHourlyRate = gSum / tHourlyDuration - tHourlyRateBB = gBBSum / tHourlyDuration - daysSet.add(sessionSet.startDate.startOfDay()) - - when (options.evolutionValues) { - Options.EvolutionValues.STANDARD -> { - results.addEvolutionValue(tHourlyRate, stat = HOURLY_RATE, data = sessionSet) - results.addEvolutionValue(tIndex.toDouble(), stat = NUMBER_OF_SETS, data = sessionSet) - results.addEvolutionValue( - sessionSet.netDuration.toDouble(), - stat = DURATION, - data = sessionSet - ) - results.addEvolutionValue( - tHourlyDuration / tIndex, - stat = AVERAGE_DURATION, - data = sessionSet - ) - results.addEvolutionValue(tHourlyRateBB, stat = HOURLY_RATE_BB, data = sessionSet) + val computeDaysPlayed = options.displayedStats.contains(DAYS_PLAYED) + val shouldIterateOverSets = (options.evolutionValues != Options.EvolutionValues.NONE || computeDaysPlayed) - Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 -> - results.addEvolutionValue(netBB100, stat = NET_BB_PER_100_HANDS, data = sessionSet) - } + if (computeDaysPlayed) { + var tHourlyDuration = 0.0 + var tIndex = 0 + var tSum = 0.0 + var tTotalHands = 0.0 + var tBBSum = 0.0 + var tHourlyRate = 0.0 + var tHourlyRateBB = 0.0 + val daysSet = mutableSetOf() + + sessionSets.forEach { sessionSet -> + tIndex++ + tHourlyDuration += sessionSet.hourlyDuration + tSum += sessionSet.ratedNet + tTotalHands += sessionSet.estimatedHands + tBBSum += sessionSet.bbNet + + tHourlyRate = gSum / tHourlyDuration + tHourlyRateBB = gBBSum / tHourlyDuration + daysSet.add(sessionSet.startDate.startOfDay()) + + when (options.evolutionValues) { + Options.EvolutionValues.STANDARD -> { + results.addEvolutionValue(tHourlyRate, stat = HOURLY_RATE, data = sessionSet) + results.addEvolutionValue(tIndex.toDouble(), stat = NUMBER_OF_SETS, data = sessionSet) + results.addEvolutionValue( + sessionSet.netDuration.toDouble(), + stat = DURATION, + data = sessionSet + ) + results.addEvolutionValue( + tHourlyDuration / tIndex, + stat = AVERAGE_DURATION, + data = sessionSet + ) + results.addEvolutionValue(tHourlyRateBB, stat = HOURLY_RATE_BB, data = sessionSet) + + Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 -> + results.addEvolutionValue(netBB100, stat = NET_BB_PER_100_HANDS, data = sessionSet) } - Options.EvolutionValues.TIMED -> { - results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet) - results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet) - results.addEvolutionValue( - tIndex.toDouble(), - tHourlyDuration, - NUMBER_OF_SETS, - sessionSet - ) - results.addEvolutionValue( - sessionSet.netDuration.toDouble(), - tHourlyDuration, - DURATION, - sessionSet - ) + + } + Options.EvolutionValues.TIMED -> { + results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet) + results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet) + results.addEvolutionValue( + tIndex.toDouble(), + tHourlyDuration, + NUMBER_OF_SETS, + sessionSet + ) + results.addEvolutionValue( + sessionSet.netDuration.toDouble(), + tHourlyDuration, + DURATION, + sessionSet + ) + results.addEvolutionValue( + tHourlyDuration / tIndex, + tHourlyDuration, + AVERAGE_DURATION, + sessionSet + ) + results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet) + + Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 -> results.addEvolutionValue( - tHourlyDuration / tIndex, + netBB100, tHourlyDuration, - AVERAGE_DURATION, + NET_BB_PER_100_HANDS, sessionSet ) - results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet) - - Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 -> - results.addEvolutionValue( - netBB100, - tHourlyDuration, - NET_BB_PER_100_HANDS, - sessionSet - ) - } } } + } - results.addStat(DAYS_PLAYED, daysSet.size.toDouble()) + results.addStat(DAYS_PLAYED, daysSet.size.toDouble()) - } - } - else -> { - // nothing } } diff --git a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt index 72b7d331..effdd611 100644 --- a/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt +++ b/app/src/main/java/net/pokeranalytics/android/calculus/Report.kt @@ -183,7 +183,7 @@ class ComputedResults(group: ComputableGroup) { } fun addStat(stat: Stat, value: Double, secondValue: Double? = null) { - this._computedStats[stat] = ComputedStat(stat, value, secondValue) + this._computedStats[stat] = ComputedStat(stat, value, secondValue = secondValue) } fun addStats(computedStats: Set) {