Added tests for new stats

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")
+		}
+
+	}
 }

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 (computable.isPositive == 1) { // positive result
-						if (currentStreak >= 0) {
+						if (currentStreak >= 0) { // currently positive streak
 							currentStreak++
-						} else {
+						} else { // currently negative streak
+							longestLoseStreak = min(longestLoseStreak, currentStreak)
 							currentStreak = 1
-							loseStreak = min(loseStreak, currentStreak)
 						}
-					}
+					} else { // negative result
-					if (computable.isPositive == 0) {
+						if (currentStreak <= 0) { // currently negative streak
-						if (currentStreak <= 0) {
 							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) {
+			val computeDaysPlayed = options.displayedStats.contains(DAYS_PLAYED)
-				Options.EvolutionValues.STANDARD, Options.EvolutionValues.TIMED -> {
+			val shouldIterateOverSets = (options.evolutionValues != Options.EvolutionValues.NONE || 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<Date>()
-
-					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 ->
+			if (computeDaysPlayed) {
-									results.addEvolutionValue(netBB100, stat = NET_BB_PER_100_HANDS, data = sessionSet)
-								}
 
+				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<Date>()
+
+				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)
+						Options.EvolutionValues.TIMED -> {
-								results.addEvolutionValue(
+							results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet)
-									tIndex.toDouble(),
+							results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet)
-									tHourlyDuration,
+							results.addEvolutionValue(
-									NUMBER_OF_SETS,
+								tIndex.toDouble(),
-									sessionSet
+								tHourlyDuration,
-								)
+								NUMBER_OF_SETS,
-								results.addEvolutionValue(
+								sessionSet
-									sessionSet.netDuration.toDouble(),
+							)
-									tHourlyDuration,
+							results.addEvolutionValue(
-									DURATION,
+								sessionSet.netDuration.toDouble(),
-									sessionSet
+								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
 				}
 			}
 

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<ComputedStat>) {