storaged/tests/storaged_test.cpp - third_party/android/platform/system/core - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <deque>
 #include <fcntl.h>
 #include <random>
 #include <string.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <gtest/gtest.h>

 #include <storaged.h>               // data structures
 #include <storaged_utils.h>         // functions to test

 #define MMC_DISK_STATS_PATH "/sys/block/mmcblk0/stat"
 #define SDA_DISK_STATS_PATH "/sys/block/sda/stat"

 static void pause(uint32_t sec) {
     const char* path = "/cache/test";
     int fd = open(path, O_WRONLY | O_CREAT, 0600);
     ASSERT_LT(-1, fd);
     char buffer[2048];
     memset(buffer, 1, sizeof(buffer));
     int loop_size = 100;
     for (int i = 0; i < loop_size; ++i) {
         ASSERT_EQ(2048, write(fd, buffer, sizeof(buffer)));
     }
     fsync(fd);
     close(fd);

     fd = open(path, O_RDONLY);
     ASSERT_LT(-1, fd);
     for (int i = 0; i < loop_size; ++i) {
         ASSERT_EQ(2048, read(fd, buffer, sizeof(buffer)));
     }
     close(fd);

     sleep(sec);
 }

 // the return values of the tested functions should be the expected ones
 const char* DISK_STATS_PATH;
 TEST(storaged_test, retvals) {
     struct disk_stats stats;
     memset(&stats, 0, sizeof(struct disk_stats));

     if (access(MMC_DISK_STATS_PATH, R_OK) >= 0) {
         DISK_STATS_PATH = MMC_DISK_STATS_PATH;
     } else if (access(SDA_DISK_STATS_PATH, R_OK) >= 0) {
         DISK_STATS_PATH = SDA_DISK_STATS_PATH;
     } else {
         return;
     }

     EXPECT_TRUE(parse_disk_stats(DISK_STATS_PATH, &stats));

     struct disk_stats old_stats;
     memset(&old_stats, 0, sizeof(struct disk_stats));
     old_stats = stats;

     const char wrong_path[] = "/this/is/wrong";
     EXPECT_FALSE(parse_disk_stats(wrong_path, &stats));

     // reading a wrong path should not damage the output structure
     EXPECT_EQ(0, memcmp(&stats, &old_stats, sizeof(disk_stats)));
 }

 TEST(storaged_test, disk_stats) {
     struct disk_stats stats;
     memset(&stats, 0, sizeof(struct disk_stats));

     ASSERT_TRUE(parse_disk_stats(DISK_STATS_PATH, &stats));

     // every entry of stats (except io_in_flight) should all be greater than 0
     for (uint i = 0; i < DISK_STATS_SIZE; ++i) {
         if (i == 8) continue; // skip io_in_flight which can be 0
         EXPECT_LT((uint64_t)0, *((uint64_t*)&stats + i));
     }

     // accumulation of the increments should be the same with the overall increment
     struct disk_stats base, tmp, curr, acc, inc[5];
     memset(&base, 0, sizeof(struct disk_stats));
     memset(&tmp, 0, sizeof(struct disk_stats));
     memset(&acc, 0, sizeof(struct disk_stats));

     for (uint i = 0; i < 5; ++i) {
         ASSERT_TRUE(parse_disk_stats(DISK_STATS_PATH, &curr));
         if (i == 0) {
             base = curr;
             tmp = curr;
             sleep(5);
             continue;
         }
         inc[i] = get_inc_disk_stats(&tmp, &curr);
         add_disk_stats(&inc[i], &acc);
         tmp = curr;
         pause(5);
     }
     struct disk_stats overall_inc;
     memset(&overall_inc, 0, sizeof(disk_stats));
     overall_inc= get_inc_disk_stats(&base, &curr);

     for (uint i = 0; i < DISK_STATS_SIZE; ++i) {
         if (i == 8) continue; // skip io_in_flight which can be 0
         EXPECT_EQ(*((uint64_t*)&overall_inc + i), *((uint64_t*)&acc + i));
     }
 }

 static double mean(std::deque<uint32_t> nums) {
     double sum = 0.0;
     for (uint32_t i : nums) {
     sum += i;
     }
     return sum / nums.size();
 }

 static double standard_deviation(std::deque<uint32_t> nums) {
     double sum = 0.0;
     double avg = mean(nums);
     for (uint32_t i : nums) {
     sum += ((double)i - avg) * ((double)i - avg);
     }
     return sqrt(sum / nums.size());
 }

 TEST(storaged_test, stream_stats) {
     // 100 random numbers
     std::vector<uint32_t> data = {8147,9058,1270,9134,6324,975,2785,5469,9575,9649,1576,9706,9572,4854,8003,1419,4218,9157,7922,9595,6557,357,8491,9340,6787,7577,7431,3922,6555,1712,7060,318,2769,462,971,8235,6948,3171,9502,344,4387,3816,7655,7952,1869,4898,4456,6463,7094,7547,2760,6797,6551,1626,1190,4984,9597,3404,5853,2238,7513,2551,5060,6991,8909,9593,5472,1386,1493,2575,8407,2543,8143,2435,9293,3500,1966,2511,6160,4733,3517,8308,5853,5497,9172,2858,7572,7537,3804,5678,759,540,5308,7792,9340,1299,5688,4694,119,3371};
     std::deque<uint32_t> test_data;
     stream_stats sstats;
     for (uint32_t i : data) {
         test_data.push_back(i);
         sstats.add(i);

         EXPECT_EQ((int)standard_deviation(test_data), (int)sstats.get_std());
         EXPECT_EQ((int)mean(test_data), (int)sstats.get_mean());
     }

     for (uint32_t i : data) {
         test_data.pop_front();
         sstats.evict(i);

         EXPECT_EQ((int)standard_deviation(test_data), (int)sstats.get_std());
         EXPECT_EQ((int)mean(test_data), (int)sstats.get_mean());
     }

     // some real data
     std::vector<uint32_t> another_data = {113875,81620,103145,28327,86855,207414,96526,52567,28553,250311};
     test_data.clear();
     uint32_t window_size = 2;
     uint32_t idx;
     stream_stats sstats1;
     for (idx = 0; idx < window_size; ++idx) {
         test_data.push_back(another_data[idx]);
         sstats1.add(another_data[idx]);
     }
     EXPECT_EQ((int)standard_deviation(test_data), (int)sstats1.get_std());
     EXPECT_EQ((int)mean(test_data), (int)sstats1.get_mean());
     for (;idx < another_data.size(); ++idx) {
         test_data.pop_front();
         sstats1.evict(another_data[idx - window_size]);
         test_data.push_back(another_data[idx]);
         sstats1.add(another_data[idx]);
         EXPECT_EQ((int)standard_deviation(test_data), (int)sstats1.get_std());
         EXPECT_EQ((int)mean(test_data), (int)sstats1.get_mean());
     }
 }

 static struct disk_perf disk_perf_multiply(struct disk_perf perf, double mul) {
     struct disk_perf retval;
     retval.read_perf = (double)perf.read_perf * mul;
     retval.read_ios = (double)perf.read_ios * mul;
     retval.write_perf = (double)perf.write_perf * mul;
     retval.write_ios = (double)perf.write_ios * mul;
     retval.queue = (double)perf.queue * mul;

     return retval;
 }

 static struct disk_stats disk_stats_add(struct disk_stats stats1, struct disk_stats stats2) {
     struct disk_stats retval;
     retval.read_ios = stats1.read_ios + stats2.read_ios;
     retval.read_merges = stats1.read_merges + stats2.read_merges;
     retval.read_sectors = stats1.read_sectors + stats2.read_sectors;
     retval.read_ticks = stats1.read_ticks + stats2.read_ticks;
     retval.write_ios = stats1.write_ios + stats2.write_ios;
     retval.write_merges = stats1.write_merges + stats2.write_merges;
     retval.write_sectors = stats1.write_sectors + stats2.write_sectors;
     retval.write_ticks = stats1.write_ticks + stats2.write_ticks;
     retval.io_in_flight = stats1.io_in_flight + stats2.io_in_flight;
     retval.io_ticks = stats1.io_ticks + stats2.io_ticks;
     retval.io_in_queue = stats1.io_in_queue + stats2.io_in_queue;
     retval.end_time = stats1.end_time + stats2.end_time;

     return retval;
 }

 TEST(storaged_test, disk_stats_monitor) {
     // asserting that there is one file for diskstats
     ASSERT_TRUE(access(MMC_DISK_STATS_PATH, R_OK) >= 0 || access(SDA_DISK_STATS_PATH, R_OK) >= 0);
     // testing if detect() will return the right value
     disk_stats_monitor dsm_detect;
     // feed monitor with constant perf data for io perf baseline
     // using constant perf is reasonable since the functionality of stream_stats
     // has already been tested
     struct disk_perf norm_perf = {
         .read_perf = 10 * 1024,
         .read_ios = 50,
         .write_perf = 5 * 1024,
         .write_ios = 25,
         .queue = 5
     };

     std::random_device rd;
     std::mt19937 gen(rd());
     std::uniform_real_distribution<> rand(0.8, 1.2);

     for (uint i = 0; i < dsm_detect.mWindow; ++i) {
         struct disk_perf perf = disk_perf_multiply(norm_perf, rand(gen));

         dsm_detect.add(&perf);
         dsm_detect.mBuffer.push(perf);
         EXPECT_EQ(dsm_detect.mBuffer.size(), (uint64_t)i + 1);
     }

     dsm_detect.mValid = true;
     dsm_detect.update_mean();
     dsm_detect.update_std();

     for (double i = 0; i < 2 * dsm_detect.mSigma; i += 0.5) {
         struct disk_perf test_perf;
         struct disk_perf test_mean = dsm_detect.mMean;
         struct disk_perf test_std = dsm_detect.mStd;

         test_perf.read_perf = (double)test_mean.read_perf - i * test_std.read_perf;
         test_perf.read_ios = (double)test_mean.read_ios - i * test_std.read_ios;
         test_perf.write_perf = (double)test_mean.write_perf - i * test_std.write_perf;
         test_perf.write_ios = (double)test_mean.write_ios - i * test_std.write_ios;
         test_perf.queue = (double)test_mean.queue + i * test_std.queue;

         EXPECT_EQ((i > dsm_detect.mSigma), dsm_detect.detect(&test_perf));
     }

     // testing if stalled disk_stats can be correctly accumulated in the monitor
     disk_stats_monitor dsm_acc;
     struct disk_stats norm_inc = {
         .read_ios = 200,
         .read_merges = 0,
         .read_sectors = 200,
         .read_ticks = 200,
         .write_ios = 100,
         .write_merges = 0,
         .write_sectors = 100,
         .write_ticks = 100,
         .io_in_flight = 0,
         .io_ticks = 600,
         .io_in_queue = 300,
         .start_time = 0,
         .end_time = 100,
         .counter = 0,
         .io_avg = 0
     };

     struct disk_stats stall_inc = {
         .read_ios = 200,
         .read_merges = 0,
         .read_sectors = 20,
         .read_ticks = 200,
         .write_ios = 100,
         .write_merges = 0,
         .write_sectors = 10,
         .write_ticks = 100,
         .io_in_flight = 0,
         .io_ticks = 600,
         .io_in_queue = 1200,
         .start_time = 0,
         .end_time = 100,
         .counter = 0,
         .io_avg = 0
     };

     struct disk_stats stats_base;
     memset(&stats_base, 0, sizeof(stats_base));

     int loop_size = 100;
     for (int i = 0; i < loop_size; ++i) {
         stats_base = disk_stats_add(stats_base, norm_inc);
         dsm_acc.update(&stats_base);
         EXPECT_EQ(dsm_acc.mValid, (uint32_t)(i + 1) >= dsm_acc.mWindow);
         EXPECT_FALSE(dsm_acc.mStall);
     }

     stats_base = disk_stats_add(stats_base, stall_inc);
     dsm_acc.update(&stats_base);
     EXPECT_TRUE(dsm_acc.mValid);
     EXPECT_TRUE(dsm_acc.mStall);

     for (int i = 0; i < 10; ++i) {
         stats_base = disk_stats_add(stats_base, norm_inc);
         dsm_acc.update(&stats_base);
         EXPECT_TRUE(dsm_acc.mValid);
         EXPECT_FALSE(dsm_acc.mStall);
     }
 }

 static void expect_increasing(struct disk_stats stats1, struct disk_stats stats2) {
     EXPECT_LE(stats1.read_ios, stats2.read_ios);
     EXPECT_LE(stats1.read_merges, stats2.read_merges);
     EXPECT_LE(stats1.read_sectors, stats2.read_sectors);
     EXPECT_LE(stats1.read_ticks, stats2.read_ticks);

     EXPECT_LE(stats1.write_ios, stats2.write_ios);
     EXPECT_LE(stats1.write_merges, stats2.write_merges);
     EXPECT_LE(stats1.write_sectors, stats2.write_sectors);
     EXPECT_LE(stats1.write_ticks, stats2.write_ticks);

     EXPECT_LE(stats1.io_ticks, stats2.io_ticks);
     EXPECT_LE(stats1.io_in_queue, stats2.io_in_queue);
 }

 #define TEST_LOOPS 20
 TEST(storaged_test, disk_stats_publisher) {
     // asserting that there is one file for diskstats
     ASSERT_TRUE(access(MMC_DISK_STATS_PATH, R_OK) >= 0 || access(SDA_DISK_STATS_PATH, R_OK) >= 0);
     disk_stats_publisher dsp;
     struct disk_stats prev;
     memset(&prev, 0, sizeof(prev));

     for (int i = 0; i < TEST_LOOPS; ++i) {
         dsp.update();
         expect_increasing(prev, dsp.mPrevious);
         prev = dsp.mPrevious;
         pause(10);
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <deque>
	#include <fcntl.h>
	#include <random>
	#include <string.h>
	#include <stdio.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <gtest/gtest.h>

	#include <storaged.h> // data structures
	#include <storaged_utils.h> // functions to test

	#define MMC_DISK_STATS_PATH "/sys/block/mmcblk0/stat"
	#define SDA_DISK_STATS_PATH "/sys/block/sda/stat"

	static void pause(uint32_t sec) {
	const char* path = "/cache/test";
	int fd = open(path, O_WRONLY \| O_CREAT, 0600);
	ASSERT_LT(-1, fd);
	char buffer[2048];
	memset(buffer, 1, sizeof(buffer));
	int loop_size = 100;
	for (int i = 0; i < loop_size; ++i) {
	ASSERT_EQ(2048, write(fd, buffer, sizeof(buffer)));
	}
	fsync(fd);
	close(fd);

	fd = open(path, O_RDONLY);
	ASSERT_LT(-1, fd);
	for (int i = 0; i < loop_size; ++i) {
	ASSERT_EQ(2048, read(fd, buffer, sizeof(buffer)));
	}
	close(fd);

	sleep(sec);
	}

	// the return values of the tested functions should be the expected ones
	const char* DISK_STATS_PATH;
	TEST(storaged_test, retvals) {
	struct disk_stats stats;
	memset(&stats, 0, sizeof(struct disk_stats));

	if (access(MMC_DISK_STATS_PATH, R_OK) >= 0) {
	DISK_STATS_PATH = MMC_DISK_STATS_PATH;
	} else if (access(SDA_DISK_STATS_PATH, R_OK) >= 0) {
	DISK_STATS_PATH = SDA_DISK_STATS_PATH;
	} else {
	return;
	}

	EXPECT_TRUE(parse_disk_stats(DISK_STATS_PATH, &stats));

	struct disk_stats old_stats;
	memset(&old_stats, 0, sizeof(struct disk_stats));
	old_stats = stats;

	const char wrong_path[] = "/this/is/wrong";
	EXPECT_FALSE(parse_disk_stats(wrong_path, &stats));

	// reading a wrong path should not damage the output structure
	EXPECT_EQ(0, memcmp(&stats, &old_stats, sizeof(disk_stats)));
	}

	TEST(storaged_test, disk_stats) {
	struct disk_stats stats;
	memset(&stats, 0, sizeof(struct disk_stats));

	ASSERT_TRUE(parse_disk_stats(DISK_STATS_PATH, &stats));

	// every entry of stats (except io_in_flight) should all be greater than 0
	for (uint i = 0; i < DISK_STATS_SIZE; ++i) {
	if (i == 8) continue; // skip io_in_flight which can be 0
	EXPECT_LT((uint64_t)0, ((uint64_t)&stats + i));
	}

	// accumulation of the increments should be the same with the overall increment
	struct disk_stats base, tmp, curr, acc, inc[5];
	memset(&base, 0, sizeof(struct disk_stats));
	memset(&tmp, 0, sizeof(struct disk_stats));
	memset(&acc, 0, sizeof(struct disk_stats));

	for (uint i = 0; i < 5; ++i) {
	ASSERT_TRUE(parse_disk_stats(DISK_STATS_PATH, &curr));
	if (i == 0) {
	base = curr;
	tmp = curr;
	sleep(5);
	continue;
	}
	inc[i] = get_inc_disk_stats(&tmp, &curr);
	add_disk_stats(&inc[i], &acc);
	tmp = curr;
	pause(5);
	}
	struct disk_stats overall_inc;
	memset(&overall_inc, 0, sizeof(disk_stats));
	overall_inc= get_inc_disk_stats(&base, &curr);

	for (uint i = 0; i < DISK_STATS_SIZE; ++i) {
	if (i == 8) continue; // skip io_in_flight which can be 0
	EXPECT_EQ(((uint64_t)&overall_inc + i), ((uint64_t)&acc + i));
	}
	}

	static double mean(std::deque<uint32_t> nums) {
	double sum = 0.0;
	for (uint32_t i : nums) {
	sum += i;
	}
	return sum / nums.size();
	}

	static double standard_deviation(std::deque<uint32_t> nums) {
	double sum = 0.0;
	double avg = mean(nums);
	for (uint32_t i : nums) {
	sum += ((double)i - avg) * ((double)i - avg);
	}
	return sqrt(sum / nums.size());
	}

	TEST(storaged_test, stream_stats) {
	// 100 random numbers
	std::vector<uint32_t> data = {8147,9058,1270,9134,6324,975,2785,5469,9575,9649,1576,9706,9572,4854,8003,1419,4218,9157,7922,9595,6557,357,8491,9340,6787,7577,7431,3922,6555,1712,7060,318,2769,462,971,8235,6948,3171,9502,344,4387,3816,7655,7952,1869,4898,4456,6463,7094,7547,2760,6797,6551,1626,1190,4984,9597,3404,5853,2238,7513,2551,5060,6991,8909,9593,5472,1386,1493,2575,8407,2543,8143,2435,9293,3500,1966,2511,6160,4733,3517,8308,5853,5497,9172,2858,7572,7537,3804,5678,759,540,5308,7792,9340,1299,5688,4694,119,3371};
	std::deque<uint32_t> test_data;
	stream_stats sstats;
	for (uint32_t i : data) {
	test_data.push_back(i);
	sstats.add(i);

	EXPECT_EQ((int)standard_deviation(test_data), (int)sstats.get_std());
	EXPECT_EQ((int)mean(test_data), (int)sstats.get_mean());
	}

	for (uint32_t i : data) {
	test_data.pop_front();
	sstats.evict(i);

	EXPECT_EQ((int)standard_deviation(test_data), (int)sstats.get_std());
	EXPECT_EQ((int)mean(test_data), (int)sstats.get_mean());
	}

	// some real data
	std::vector<uint32_t> another_data = {113875,81620,103145,28327,86855,207414,96526,52567,28553,250311};
	test_data.clear();
	uint32_t window_size = 2;
	uint32_t idx;
	stream_stats sstats1;
	for (idx = 0; idx < window_size; ++idx) {
	test_data.push_back(another_data[idx]);
	sstats1.add(another_data[idx]);
	}
	EXPECT_EQ((int)standard_deviation(test_data), (int)sstats1.get_std());
	EXPECT_EQ((int)mean(test_data), (int)sstats1.get_mean());
	for (;idx < another_data.size(); ++idx) {
	test_data.pop_front();
	sstats1.evict(another_data[idx - window_size]);
	test_data.push_back(another_data[idx]);
	sstats1.add(another_data[idx]);
	EXPECT_EQ((int)standard_deviation(test_data), (int)sstats1.get_std());
	EXPECT_EQ((int)mean(test_data), (int)sstats1.get_mean());
	}
	}

	static struct disk_perf disk_perf_multiply(struct disk_perf perf, double mul) {
	struct disk_perf retval;
	retval.read_perf = (double)perf.read_perf * mul;
	retval.read_ios = (double)perf.read_ios * mul;
	retval.write_perf = (double)perf.write_perf * mul;
	retval.write_ios = (double)perf.write_ios * mul;
	retval.queue = (double)perf.queue * mul;

	return retval;
	}

	static struct disk_stats disk_stats_add(struct disk_stats stats1, struct disk_stats stats2) {
	struct disk_stats retval;
	retval.read_ios = stats1.read_ios + stats2.read_ios;
	retval.read_merges = stats1.read_merges + stats2.read_merges;
	retval.read_sectors = stats1.read_sectors + stats2.read_sectors;
	retval.read_ticks = stats1.read_ticks + stats2.read_ticks;
	retval.write_ios = stats1.write_ios + stats2.write_ios;
	retval.write_merges = stats1.write_merges + stats2.write_merges;
	retval.write_sectors = stats1.write_sectors + stats2.write_sectors;
	retval.write_ticks = stats1.write_ticks + stats2.write_ticks;
	retval.io_in_flight = stats1.io_in_flight + stats2.io_in_flight;
	retval.io_ticks = stats1.io_ticks + stats2.io_ticks;
	retval.io_in_queue = stats1.io_in_queue + stats2.io_in_queue;
	retval.end_time = stats1.end_time + stats2.end_time;

	return retval;
	}

	TEST(storaged_test, disk_stats_monitor) {
	// asserting that there is one file for diskstats
	ASSERT_TRUE(access(MMC_DISK_STATS_PATH, R_OK) >= 0 \|\| access(SDA_DISK_STATS_PATH, R_OK) >= 0);
	// testing if detect() will return the right value
	disk_stats_monitor dsm_detect;
	// feed monitor with constant perf data for io perf baseline
	// using constant perf is reasonable since the functionality of stream_stats
	// has already been tested
	struct disk_perf norm_perf = {
	.read_perf = 10 * 1024,
	.read_ios = 50,
	.write_perf = 5 * 1024,
	.write_ios = 25,
	.queue = 5
	};

	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_real_distribution<> rand(0.8, 1.2);

	for (uint i = 0; i < dsm_detect.mWindow; ++i) {
	struct disk_perf perf = disk_perf_multiply(norm_perf, rand(gen));

	dsm_detect.add(&perf);
	dsm_detect.mBuffer.push(perf);
	EXPECT_EQ(dsm_detect.mBuffer.size(), (uint64_t)i + 1);
	}

	dsm_detect.mValid = true;
	dsm_detect.update_mean();
	dsm_detect.update_std();

	for (double i = 0; i < 2 * dsm_detect.mSigma; i += 0.5) {
	struct disk_perf test_perf;
	struct disk_perf test_mean = dsm_detect.mMean;
	struct disk_perf test_std = dsm_detect.mStd;

	test_perf.read_perf = (double)test_mean.read_perf - i * test_std.read_perf;
	test_perf.read_ios = (double)test_mean.read_ios - i * test_std.read_ios;
	test_perf.write_perf = (double)test_mean.write_perf - i * test_std.write_perf;
	test_perf.write_ios = (double)test_mean.write_ios - i * test_std.write_ios;
	test_perf.queue = (double)test_mean.queue + i * test_std.queue;

	EXPECT_EQ((i > dsm_detect.mSigma), dsm_detect.detect(&test_perf));
	}

	// testing if stalled disk_stats can be correctly accumulated in the monitor
	disk_stats_monitor dsm_acc;
	struct disk_stats norm_inc = {
	.read_ios = 200,
	.read_merges = 0,
	.read_sectors = 200,
	.read_ticks = 200,
	.write_ios = 100,
	.write_merges = 0,
	.write_sectors = 100,
	.write_ticks = 100,
	.io_in_flight = 0,
	.io_ticks = 600,
	.io_in_queue = 300,
	.start_time = 0,
	.end_time = 100,
	.counter = 0,
	.io_avg = 0
	};

	struct disk_stats stall_inc = {
	.read_ios = 200,
	.read_merges = 0,
	.read_sectors = 20,
	.read_ticks = 200,
	.write_ios = 100,
	.write_merges = 0,
	.write_sectors = 10,
	.write_ticks = 100,
	.io_in_flight = 0,
	.io_ticks = 600,
	.io_in_queue = 1200,
	.start_time = 0,
	.end_time = 100,
	.counter = 0,
	.io_avg = 0
	};

	struct disk_stats stats_base;
	memset(&stats_base, 0, sizeof(stats_base));

	int loop_size = 100;
	for (int i = 0; i < loop_size; ++i) {
	stats_base = disk_stats_add(stats_base, norm_inc);
	dsm_acc.update(&stats_base);
	EXPECT_EQ(dsm_acc.mValid, (uint32_t)(i + 1) >= dsm_acc.mWindow);
	EXPECT_FALSE(dsm_acc.mStall);
	}

	stats_base = disk_stats_add(stats_base, stall_inc);
	dsm_acc.update(&stats_base);
	EXPECT_TRUE(dsm_acc.mValid);
	EXPECT_TRUE(dsm_acc.mStall);

	for (int i = 0; i < 10; ++i) {
	stats_base = disk_stats_add(stats_base, norm_inc);
	dsm_acc.update(&stats_base);
	EXPECT_TRUE(dsm_acc.mValid);
	EXPECT_FALSE(dsm_acc.mStall);
	}
	}

	static void expect_increasing(struct disk_stats stats1, struct disk_stats stats2) {
	EXPECT_LE(stats1.read_ios, stats2.read_ios);
	EXPECT_LE(stats1.read_merges, stats2.read_merges);
	EXPECT_LE(stats1.read_sectors, stats2.read_sectors);
	EXPECT_LE(stats1.read_ticks, stats2.read_ticks);

	EXPECT_LE(stats1.write_ios, stats2.write_ios);
	EXPECT_LE(stats1.write_merges, stats2.write_merges);
	EXPECT_LE(stats1.write_sectors, stats2.write_sectors);
	EXPECT_LE(stats1.write_ticks, stats2.write_ticks);

	EXPECT_LE(stats1.io_ticks, stats2.io_ticks);
	EXPECT_LE(stats1.io_in_queue, stats2.io_in_queue);
	}

	#define TEST_LOOPS 20
	TEST(storaged_test, disk_stats_publisher) {
	// asserting that there is one file for diskstats
	ASSERT_TRUE(access(MMC_DISK_STATS_PATH, R_OK) >= 0 \|\| access(SDA_DISK_STATS_PATH, R_OK) >= 0);
	disk_stats_publisher dsp;
	struct disk_stats prev;
	memset(&prev, 0, sizeof(prev));

	for (int i = 0; i < TEST_LOOPS; ++i) {
	dsp.update();
	expect_increasing(prev, dsp.mPrevious);
	prev = dsp.mPrevious;
	pause(10);
	}
	}