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 (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,8 +271,10 @@ class Calculator {
 			val hourlyRate = gSum / gHourlyDuration
 //			var bbHourlyRate = gBBSum / gDuration
 
-			when (options.evolutionValues) {
-				Options.EvolutionValues.STANDARD, Options.EvolutionValues.TIMED -> {
+			val computeDaysPlayed = options.displayedStats.contains(DAYS_PLAYED)
+			val shouldIterateOverSets = (options.evolutionValues != Options.EvolutionValues.NONE || computeDaysPlayed)
+
+			if (computeDaysPlayed) {
 
 				var tHourlyDuration = 0.0
 				var tIndex = 0
@@ -353,10 +355,6 @@ class Calculator {
 
 				}
 			}
-				else -> {
-					// nothing
-				}
-			}
 
 			var average = 0.0
 			if (computables.size > 0) {

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