PageRenderTime 61ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/Test/Analyst/BasicDecimal.php

https://github.com/codeactual/hashmark
PHP | 1161 lines | 714 code | 164 blank | 283 comment | 14 complexity | af6e336a6971055572b688e8cb79afb7 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. // vim: fenc=utf-8:ft=php:ai:si:ts=4:sw=4:et:
    3. 

  3. 

  4. /**
    5. 

  5.  * Hashmark_TestCase_Analyst_BasicDecimal
    6. 

  6.  *
    7. 

  7.  * @filesource
    8. 

  8.  * @copyright   Copyright (c) 2008-2011 David Smith
    9. 

  9.  * @license     http://www.opensource.org/licenses/mit-license.php MIT License
    10. 

  10.  * @package     Hashmark-Test
    11. 

  11.  * @subpackage  Hashmark_Analyst_BasicDecimal
    12. 

  12.  * @version     $Id$
    13. 

  13. */
    14. 

  14. 

  15. /**
    16. 

  16.  *      -   All test dates are in UTC.
    17. 

  17.  *
    18. 

  18.  * @package     Hashmark-Test
    19. 

  19.  * @subpackage  Hashmark_Analyst_BasicDecimal
    20. 

  20.  */
    21. 

  21. class Hashmark_TestCase_Analyst_BasicDecimal extends Hashmark_TestCase
    22. 

  22. {
    23. 

  23.     /**
    24. 

  24.      * @var Hashmark_Analyst_BasicDecimal   Fixture instance.
    25. 

  25.      */
    26. 

  26.     protected $_analyst;
    27. 

  27. 

  28.     /**
    29. 

  29.      * @var Hashmark_Partition  Fixture instance.
    30. 

  30.      */
    31. 

  31.     protected $_partition;
    32. 

  32. 

  33.     /**
    34. 

  34.      * @var Hashmark_Core   Fixture instance.
    35. 

  35.      */
    36. 

  36.     protected $_core;
    37. 

  37. 

  38.     /**
    39. 

  39.      * @var Array   Tested subset of Hashmark_Analyst_BasicDecimal:$_aggFunctions.
    40. 

  40.      */
    41. 

  41.     protected static $_aggFunctions = array('AVG', 'SUM', 'MAX', 'MIN');
    42. 

  42. 

  43.     /**
    44. 

  44.      * Resources needed for most tests.
    45. 

  45.      *
    46. 

  46.      * @return void
    47. 

  47.      */
    48. 

  48.     protected function setUp()
    49. 

  49.     {
    50. 

  50.         parent::setUp();
    51. 

  51.         
    52. 

  52.         $partition = Hashmark::getModule('Partition', '', $this->_db);
    53. 

  53.         $this->_analyst = Hashmark::getModule('Analyst', 'BasicDecimal', $this->_db, $partition);
    54. 

  54.         $this->_partition = Hashmark::getModule('Partition', '', $this->_db);
    55. 

  55.         $this->_core = Hashmark::getModule('Core', '', $this->_db);
    56. 

  56.     }
    57. 

  57. 

  58.     /**
    59. 

  59.      * Public acess to $_aggFunctions.
    60. 

  60.      *
    61. 

  61.      * @return Array
    62. 

  62.      */
    63. 

  63.     public static function getAggFunctions()
    64. 

  64.     {
    65. 

  65.         return self::$_aggFunctions;
    66. 

  66.     }
    67. 

  67.         
    68. 

  68.     /**
    69. 

  69.      * Quads: sample DATETIME; sample value; placeholder for matching
    70. 

  70.      * provideValuesAt*() format; boolean true if within date range (inclusive).
    71. 

  71.      *
    72. 

  72.      *      -   Uses these range boundaries:
    73. 

  73.      *          2008-11-01 01:45:59
    74. 

  74.      *          2009-04-30 01:45:59
    75. 

  75.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    76. 

  76.      *
    77. 

  77.      * @return Array    Test method argument sets.
    78. 

  78.      */
    79. 

  79.     public static function provideValuesSamples()
    80. 

  80.     {
    81. 

  81.         static $data;
    82. 

  82. 

  83.         if (!$data) {
    84. 

  84.             $data = array();
    85. 

  85.             $data[] = array('2002-07-07 00:00:00', '1000000000000000.0103', null, false);
    86. 

  86.             $data[] = array('2005-05-21 00:00:00', '1000000000000000.9989', null, false);
    87. 

  87.             $data[] = array('2008-10-30 00:00:00', '1000000000000000.3968', null, false);
    88. 

  88.             $data[] = array('2008-11-15 00:00:00', '1000000000000000.1724', null, true);
    89. 

  89.             $data[] = array('2008-11-30 00:00:00', '1000000000000000.6735', null, true);
    90. 

  90.             $data[] = array('2008-12-07 00:00:00', '1000000000000000.1697', null, true);
    91. 

  91.             $data[] = array('2008-12-15 00:00:00', '1000000000000000.3857', null, true);
    92. 

  92.             $data[] = array('2008-12-31 00:00:00', '-1000000000000000.2968', null, true);
    93. 

  93.             $data[] = array('2009-01-01 00:00:00', '1000000000000000.7870', null, true);
    94. 

  94.             $data[] = array('2009-01-15 00:00:00', '1000000000000000.9788', null, true);
    95. 

  95.             $data[] = array('2009-01-31 00:00:00', '1000000000000000.1697', null, true);
    96. 

  96.             $data[] = array('2009-02-01 00:00:00', '1000000000000000.3886', null, true);
    97. 

  97.             $data[] = array('2009-02-14 00:00:00', '-1000000000000000.1970', null, true);
    98. 

  98.             $data[] = array('2009-02-21 00:00:00', '1000000000000000.9788', null, true);
    99. 

  99.             $data[] = array('2009-02-28 00:00:00', '1000000000000000.8564', null, true);
    100. 

  100.             $data[] = array('2009-03-01 00:00:00', '1000000000000000.5109', null, true);
    101. 

  101.             $data[] = array('2009-03-15 00:00:00', '1000000000000000.6109', null, true);
    102. 

  102.             $data[] = array('2009-03-31 00:00:00', '-1000000000000000.1909', null, true);
    103. 

  103.             $data[] = array('2009-04-15 00:00:00', '1000000000000000.5109', null, true);
    104. 

  104.             $data[] = array('2009-04-30 00:00:00', '1000000000000000.5442', null, true);
    105. 

  105.             $data[] = array('2009-05-01 00:00:00', '1000000000000000.5224', null, false);
    106. 

  106.             $data[] = array('2009-07-14 00:00:00', '1000000000000000.2955', null, false);
    107. 

  107.             $data[] = array('2010-12-14 00:00:00', '1000000000000000.2955', null, false);
    108. 

  108.         }
    109. 

  109. 

  110.         return $data;
    111. 

  111.     }
    112. 

  112.     
    113. 

  113.     /**
    114. 

  114.      * Quads: sample DATETIME; sample value; boolean true if most recent value in interval;
    115. 

  115.      * boolean true if within date range (inclusive).
    116. 

  116.      *
    117. 

  117.      *      -   Uses these range boundaries:
    118. 

  118.      *          2009-06-04 01:45:59
    119. 

  119.      *          2009-06-04 06:45:59
    120. 

  120.      *      -   Group aggregates consider all values in an interval, not just
    121. 

  121.      *          those expected in at-interval sets.
    122. 

  122.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    123. 

  123.      *
    124. 

  124.      * @return Array    Test method argument sets.
    125. 

  125.      */
    126. 

  126.     public static function provideValuesAtIntervalHourSamples()
    127. 

  127.     {
    128. 

  128.         static $data;
    129. 

  129. 

  130.         if (!$data) {
    131. 

  131.             $data = array();
    132. 

  132.             $data[] = array('2009-06-04 00:00:00', '1000000000000000.4000', false, false);
    133. 

  133.             $data[] = array('2009-06-04 01:30:00', '1000000000000000.5210', false, false);
    134. 

  134.             $data[] = array('2009-06-04 01:50:00', '1000000000000000.6000', true, true);
    135. 

  135.             $data[] = array('2009-06-04 02:00:00', '-1000000000000000.7900', false, true);
    136. 

  136.             $data[] = array('2009-06-04 02:30:00', '1000000000000000.8500', false, true);
    137. 

  137.             $data[] = array('2009-06-04 02:40:00', '1000000000000000.9030', false, true);
    138. 

  138.             $data[] = array('2009-06-04 02:45:00', '1000000000000000.9030', true, true);
    139. 

  139.             $data[] = array('2009-06-04 03:00:00', '1000000000000000.8030', false, true);
    140. 

  140.             $data[] = array('2009-06-04 03:30:00', '1000000000000000.7030', false, true);
    141. 

  141.             $data[] = array('2009-06-04 03:45:00', '-1000000000000000.6030', true, true);
    142. 

  142.             $data[] = array('2009-06-04 04:00:00', '1000000000000000.5932', false, true);
    143. 

  143.             $data[] = array('2009-06-04 04:30:00', '1000000000000000.4000', false, true);
    144. 

  144.             $data[] = array('2009-06-04 04:45:00', '1000000000000000.3000', true, true);
    145. 

  145.             $data[] = array('2009-06-04 05:00:00', '1000000000000000.2030', false, true);
    146. 

  146.             $data[] = array('2009-06-04 05:30:00', '1000000000000000.1210', false, true);
    147. 

  147.             $data[] = array('2009-06-04 05:35:00', '1000000000000000.1210', false, true);
    148. 

  148.             $data[] = array('2009-06-04 05:45:00', '1000000000000000.2000', true, true);
    149. 

  149.             $data[] = array('2009-06-04 06:00:00', '1000000000000000.3900', false, true);
    150. 

  150.             $data[] = array('2009-06-04 06:30:00', '-1000000000000000.4000', false, true);
    151. 

  151.             $data[] = array('2009-06-04 06:45:00', '1000000000000000.5030', true, true);
    152. 

  152.             $data[] = array('2009-06-04 07:00:00', '1000000000000000.6900', false, false);
    153. 

  153.         }
    154. 

  154. 

  155.         return $data;
    156. 

  156.     }
    157. 

  157.     
    158. 

  158.     /**
    159. 

  159.      * Quads: sample DATETIME; sample value; boolean true if most recent value in interval;
    160. 

  160.      * boolean true if within date range (inclusive).
    161. 

  161.      *
    162. 

  162.      *      -   Uses these range boundaries:
    163. 

  163.      *          2009-06-04 01:45:59
    164. 

  164.      *          2009-06-11 01:45:59
    165. 

  165.      *      -   Group aggregates consider all values in an interval, not just
    166. 

  166.      *          those expected in at-interval sets.
    167. 

  167.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    168. 

  168.      *
    169. 

  169.      * @return Array    Test method argument sets.
    170. 

  170.      */
    171. 

  171.     public static function provideValuesAtIntervalDaySamples()
    172. 

  172.     {
    173. 

  173.         static $data;
    174. 

  174. 

  175.         if (!$data) {
    176. 

  176.             $data = array();
    177. 

  177.             $data[] = array('2009-06-03 00:00:00', '1000000000000000.3432', false, false);
    178. 

  178.             $data[] = array('2009-06-04 00:00:00', '1000000000000000.4000', false, false);
    179. 

  179.             $data[] = array('2009-06-04 11:00:00', '1000000000000000.5210', false, true);
    180. 

  180.             $data[] = array('2009-06-04 22:00:00', '1000000000000000.1946', true, true);
    181. 

  181.             $data[] = array('2009-06-05 00:00:00', '1000000000000000.7904', false, true);
    182. 

  182.             $data[] = array('2009-06-05 11:00:00', '1000000000000000.8553', false, true);
    183. 

  183.             $data[] = array('2009-06-05 22:00:00', '1000000000000000.9365', true, true);
    184. 

  184.             $data[] = array('2009-06-06 00:00:00', '1000000000000000.5377', false, true);
    185. 

  185.             $data[] = array('2009-06-06 11:00:00', '1000000000000000.4089', false, true);
    186. 

  186.             $data[] = array('2009-06-06 22:00:00', '1000000000000000.3397', true, true);
    187. 

  187.             $data[] = array('2009-06-07 00:00:00', '1000000000000000.9184', false, true);
    188. 

  188.             $data[] = array('2009-06-07 05:00:00', '1000000000000000.2000', false, true);
    189. 

  189.             $data[] = array('2009-06-07 11:00:00', '1000000000000000.3224', false, true);
    190. 

  190.             $data[] = array('2009-06-07 22:00:00', '1000000000000000.2000', true, true);
    191. 

  191.             $data[] = array('2009-06-08 00:00:00', '-1000000000000000.0549', false, true);
    192. 

  192.             $data[] = array('2009-06-08 11:00:00', '1000000000000000.5947', false, true);
    193. 

  193.             $data[] = array('2009-06-08 22:00:00', '1000000000000000.9635', true, true);
    194. 

  194.             $data[] = array('2009-06-09 00:00:00', '1000000000000000.3720', false, true);
    195. 

  195.             $data[] = array('2009-06-09 11:00:00', '1000000000000000.2027', false, true);
    196. 

  196.             $data[] = array('2009-06-09 22:00:00', '1000000000000000.1946', true, true);
    197. 

  197.             $data[] = array('2009-06-10 00:00:00', '1000000000000000.9821', false, true);
    198. 

  198.             $data[] = array('2009-06-10 11:00:00', '1000000000000000.3701', false, true);
    199. 

  199.             $data[] = array('2009-06-10 22:00:00', '-1000000000000000.4504', true, true);
    200. 

  200.             $data[] = array('2009-06-11 00:00:00', '1000000000000000.5030', false, true);
    201. 

  201.             $data[] = array('2009-06-11 00:30:00', '1000000000000000.6810', false, true);
    202. 

  202.             $data[] = array('2009-06-11 01:00:00', '1000000000000000.6810', true, true);
    203. 

  203.             $data[] = array('2009-06-12 03:00:00', '1000000000000000.8604', false, false);
    204. 

  204.         }
    205. 

  205. 

  206.         return $data;
    207. 

  207.     }
    208. 

  208.     
    209. 

  209.     /**
    210. 

  210.      * Quads: sample DATETIME; sample value; boolean true if most recent value in interval;
    211. 

  211.      * boolean true if within date range (inclusive).
    212. 

  212.      *
    213. 

  213.      *      -   Uses these range boundaries:
    214. 

  214.      *          2009-05-31 01:45:59
    215. 

  215.      *          2009-07-12 01:45:59
    216. 

  216.      *      -   Group aggregates consider all values in an interval, not just
    217. 

  217.      *          those expected in at-interval sets.
    218. 

  218.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    219. 

  219.      *
    220. 

  220.      * @return Array    Test method argument sets.
    221. 

  221.      */
    222. 

  222.     public static function provideValuesAtIntervalWeekSamples()
    223. 

  223.     {
    224. 

  224.         static $data;
    225. 

  225. 

  226.         if (!$data) {
    227. 

  227.             $data = array();
    228. 

  228.             $data[] = array('2008-05-30 03:45:00', '1000000000000000.1332', false, false);
    229. 

  229.             $data[] = array('2009-06-03 03:14:21', '-1000000000000000.8809', false, true);
    230. 

  230.             $data[] = array('2009-06-06 03:36:59', '1000000000000000.9634', false, true);
    231. 

  231.             $data[] = array('2009-06-06 03:37:59', '1000000000000000.8231', false, true);
    232. 

  232.             $data[] = array('2009-06-07 03:37:59', '1000000000000000.7530', true, true);
    233. 

  233.             $data[] = array('2009-06-10 03:44:59', '1000000000000000.6330', false, true);
    234. 

  234.             $data[] = array('2009-06-11 03:44:59', '1000000000000000.6330', false, true);
    235. 

  235.             $data[] = array('2009-06-13 03:45:01', '1000000000000000.5831', false, true);
    236. 

  236.             $data[] = array('2009-06-13 21:01:01', '1000000000000000.4604', false, true);
    237. 

  237.             $data[] = array('2009-06-14 03:01:01', '-1000000000000000.0618', true, true);
    238. 

  238.             $data[] = array('2009-06-17 04:01:01', '1000000000000000.1103', false, true);
    239. 

  239.             $data[] = array('2009-06-20 01:01:01', '1000000000000000.6207', false, true);
    240. 

  240.             $data[] = array('2009-06-20 04:00:00', '1000000000000000.3006', false, true);
    241. 

  241.             $data[] = array('2009-06-21 10:30:07', '1000000000000000.2206', true, true);
    242. 

  242.             $data[] = array('2009-06-24 10:42:07', '1000000000000000.3028', false, true);
    243. 

  243.             $data[] = array('2009-06-25 09:45:10', '1000000000000000.7600', false, true);
    244. 

  244.             $data[] = array('2009-06-27 02:01:01', '1000000000000000.4705', false, true);
    245. 

  245.             $data[] = array('2009-06-27 09:45:10', '1000000000000000.7600', false, true);
    246. 

  246.             $data[] = array('2009-06-28 01:45:20', '1000000000000000.5101', true, true);
    247. 

  247.             $data[] = array('2009-07-01 20:14:32', '-1000000000000000.0310', false, true);
    248. 

  248.             $data[] = array('2009-07-05 00:00:00', '1000000000000000.7300', false, true);
    249. 

  249.             $data[] = array('2009-07-05 01:30:00', '1000000000000000.4513', true, true);
    250. 

  250.             $data[] = array('2009-07-08 01:30:00', '1000000000000000.5516', false, true);
    251. 

  251.             $data[] = array('2009-07-11 01:25:00', '1000000000000000.5516', false, true);
    252. 

  252.             $data[] = array('2009-07-12 01:30:00', '1000000000000000.4412', true, true);
    253. 

  253.             $data[] = array('2009-08-16 01:30:00', '1000000000000000.3118', false, false);
    254. 

  254.             $data[] = array('2010-07-05 00:00:00', '1000000000000000.1009', false, false);
    255. 

  255.         }
    256. 

  256. 

  257.         return $data;
    258. 

  258.     }
    259. 

  259.     
    260. 

  260.     /**
    261. 

  261.      * Quads: sample DATETIME; sample value; boolean true if most recent value in interval;
    262. 

  262.      * boolean true if within date range (inclusive).
    263. 

  263.      *
    264. 

  264.      *      -   Uses these range boundaries:
    265. 

  265.      *          2009-01-01 01:45:59
    266. 

  266.      *          2009-06-30 01:45:59
    267. 

  267.      *      -   Group aggregates consider all values in an interval, not just
    268. 

  268.      *          those expected in at-interval sets.
    269. 

  269.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    270. 

  270.      *
    271. 

  271.      * @return Array    Test method argument sets.
    272. 

  272.      */
    273. 

  273.     public static function provideValuesAtIntervalMonthSamples()
    274. 

  274.     {
    275. 

  275.         static $data;
    276. 

  276. 

  277.         if (!$data) {
    278. 

  278.             $data = array();
    279. 

  279.             $data[] = array('2008-12-31 23:45:01', '1000000000000000.5932', false, false);
    280. 

  280.             $data[] = array('2009-01-01 03:37:59', '1000000000000000.7030', false, true);
    281. 

  281.             $data[] = array('2009-01-15 03:44:59', '1000000000000000.6030', false, true);
    282. 

  282.             $data[] = array('2009-01-31 03:45:00', '-1000000000000000.1932', false, true);
    283. 

  283.             $data[] = array('2009-01-31 09:45:00', '-1000000000000000.1932', true, true);
    284. 

  284.             $data[] = array('2009-02-01 00:00:00', '1000000000000000.2000', false, true);
    285. 

  285.             $data[] = array('2009-02-07 03:36:59', '1000000000000000.9030', false, true);
    286. 

  286.             $data[] = array('2009-02-15 03:14:21', '1000000000000000.8500', false, true);
    287. 

  287.             $data[] = array('2009-02-28 03:36:59', '1000000000000000.9030', false, true);
    288. 

  288.             $data[] = array('2009-02-28 03:37:59', '1000000000000000.8030', true, true);
    289. 

  289.             $data[] = array('2009-03-01 03:37:59', '1000000000000000.7030', false, true);
    290. 

  290.             $data[] = array('2009-03-15 03:44:59', '1000000000000000.6030', false, true);
    291. 

  291.             $data[] = array('2009-03-31 03:45:01', '1000000000000000.5932', false, true);
    292. 

  292.             $data[] = array('2009-03-31 21:01:01', '-1000000000000000.6210', true, true);
    293. 

  293.             $data[] = array('2009-04-01 03:01:01', '1000000000000000.9213', false, true);
    294. 

  294.             $data[] = array('2009-04-15 04:01:01', '1000000000000000.8500', false, true);
    295. 

  295.             $data[] = array('2009-04-30 01:01:01', '1000000000000000.4000', false, true);
    296. 

  296.             $data[] = array('2009-04-30 04:00:00', '1000000000000000.3020', true, true);
    297. 

  297.             $data[] = array('2009-05-01 10:30:07', '1000000000000000.2400', false, true);
    298. 

  298.             $data[] = array('2009-05-15 10:42:07', '-1000000000000000.3400', false, true);
    299. 

  299.             $data[] = array('2009-05-31 02:01:01', '1000000000000000.4000', false, true);
    300. 

  300.             $data[] = array('2009-05-31 09:45:10', '1000000000000000.4400', true, true);
    301. 

  301.             $data[] = array('2009-06-01 01:45:20', '1000000000000000.5400', false, true);
    302. 

  302.             $data[] = array('2009-06-07 01:30:00', '1000000000000000.9213', false, true);
    303. 

  303.             $data[] = array('2009-06-15 20:14:32', '-1000000000000000.6210', false, true);
    304. 

  304.             $data[] = array('2009-06-30 00:00:00', '1000000000000000.7000', false, true);
    305. 

  305.             $data[] = array('2009-06-30 01:30:00', '1000000000000000.9213', true, true);
    306. 

  306.             $data[] = array('2009-06-30 11:42:00', '1000000000000000.9213', false, false);
    307. 

  307.             $data[] = array('2009-07-01 00:00:00', '1000000000000000.9000', false, false);
    308. 

  308.         }
    309. 

  309. 

  310.         return $data;
    311. 

  311.     }
    312. 

  312.     
    313. 

  313.     /**
    314. 

  314.      * Quads: sample DATETIME; sample value; boolean true if most recent value in interval;
    315. 

  315.      * boolean true if within date range (inclusive).
    316. 

  316.      *
    317. 

  317.      *      -   Uses these range boundaries:
    318. 

  318.      *          2009-01-01 01:45:59
    319. 

  319.      *          2012-12-31 01:45:59
    320. 

  320.      *      -   Group aggregates consider all values in an interval, not just
    321. 

  321.      *          those expected in at-interval sets.
    322. 

  322.      *      -   Distinct and full group AVG/SUM/COUNT for interval groups should differ at least once.
    323. 

  323.      *
    324. 

  324.      * @return Array    Test method argument sets.
    325. 

  325.      */
    326. 

  326.     public static function provideValuesAtIntervalYearSamples()
    327. 

  327.     {
    328. 

  328.         static $data;
    329. 

  329. 

  330.         if (!$data) {
    331. 

  331.             $data = array();
    332. 

  332.             $data[] = array('2008-12-31 23:45:01', '1000000000000000.5932', false, false);
    333. 

  333.             $data[] = array('2009-01-01 04:01:01', '1000000000000000.8500', false, true);
    334. 

  334.             $data[] = array('2009-06-01 01:01:01', '1000000000000000.4907', false, true);
    335. 

  335.             $data[] = array('2009-12-31 04:00:00', '1000000000000000.3020', false, true);
    336. 

  336.             $data[] = array('2009-12-31 05:00:00', '1000000000000000.6355', true, true);
    337. 

  337.             $data[] = array('2010-01-01 10:30:07', '1000000000000000.2400', false, true);
    338. 

  338.             $data[] = array('2010-06-01 10:42:07', '1000000000000000.3451', false, true);
    339. 

  339.             $data[] = array('2010-09-01 10:30:07', '1000000000000000.2400', false, true);
    340. 

  340.             $data[] = array('2010-12-31 02:01:01', '1000000000000000.7182', false, true);
    341. 

  341.             $data[] = array('2010-12-31 03:01:01', '-1000000000000000.3712', true, true);
    342. 

  342.             $data[] = array('2011-01-01 09:45:10', '1000000000000000.4407', false, true);
    343. 

  343.             $data[] = array('2011-06-01 01:45:20', '1000000000000000.5404', false, true);
    344. 

  344.             $data[] = array('2011-12-31 20:14:32', '1000000000000000.6210', false, true);
    345. 

  345.             $data[] = array('2011-12-31 21:14:32', '-1000000000000000.9123', true, true);
    346. 

  346.             $data[] = array('2012-01-01 00:00:00', '1000000000000000.7001', false, true);
    347. 

  347.             $data[] = array('2012-06-01 01:30:00', '1000000000000000.9213', false, true);
    348. 

  348.             $data[] = array('2012-12-31 00:42:00', '-1000000000000000.8577', false, true);
    349. 

  349.             $data[] = array('2012-12-31 01:27:00', '1000000000000000.9213', true, true);
    350. 

  350.             $data[] = array('2013-01-01 00:00:00', '1000000000000000.1992', false, false);
    351. 

  351.         }
    352. 

  352. 

  353.         return $data;
    354. 

  354.     }
    355. 

  355. 

  356.     /**
    357. 

  357.      * Returns samples, and associated fields like data range,
    358. 

  358.      * from provide*() methods like provideValuesAtIntervalHourSamples().
    359. 

  359.      *
    360. 

  360.      *      -   Does not use @dataProvider format.
    361. 

  361.      *
    362. 

  362.      * @param string    $name  Provider method name. 
    363. 

  363.      * @return Array    If $name is empty, all sample data; otherwise
    364. 

  364.      *                  only the named section.
    365. 

  365.      */
    366. 

  366.     public static function provideFullSamplesData($name = '')
    367. 

  367.     {
    368. 

  368.         static $data;
    369. 

  369. 

  370.         if (!$data) {
    371. 

  371.             $data = array();
    372. 

  372.             $data['provideValuesSamples'] = array('samples' => self::provideValuesSamples(),
    373. 

  373.                                                   'rangeStart' => '2008-11-01 01:45:59',
    374. 

  374.                                                   'rangeEnd' => '2009-04-30 01:45:59');
    375. 

  375.             $data['provideValuesAtIntervalHourSamples'] = array('interval' => 'h',
    376. 

  376.                                                                 'samples' => self::provideValuesAtIntervalHourSamples(),
    377. 

  377.                                                                 'rangeStart' => '2009-06-04 01:45:59',
    378. 

  378.                                                                 'rangeEnd' => '2009-06-04 06:45:59');
    379. 

  379.             $data['provideValuesAtIntervalDaySamples'] = array('interval' => 'd',
    380. 

  380.                                                                'samples' => self::provideValuesAtIntervalDaySamples(),
    381. 

  381.                                                                'rangeStart' => '2009-06-04 01:45:59',
    382. 

  382.                                                                'rangeEnd' => '2009-06-11 01:45:59');
    383. 

  383.             $data['provideValuesAtIntervalWeekSamples'] = array('interval' => 'w',
    384. 

  384.                                                                 'samples' => self::provideValuesAtIntervalWeekSamples(),
    385. 

  385.                                                                 'rangeStart' => '2009-05-31 01:45:59',
    386. 

  386.                                                                 'rangeEnd' => '2009-07-12 01:45:59');
    387. 

  387.             $data['provideValuesAtIntervalMonthSamples'] = array('interval' => 'm',
    388. 

  388.                                                                  'samples' => self::provideValuesAtIntervalMonthSamples(),
    389. 

  389.                                                                  'rangeStart' => '2009-01-01 01:45:59',
    390. 

  390.                                                                  'rangeEnd' => '2009-06-30 01:45:59');
    391. 

  391.             $data['provideValuesAtIntervalYearSamples'] = array('interval' => 'y',
    392. 

  392.                                                                 'samples' => self::provideValuesAtIntervalYearSamples(),
    393. 

  393.                                                                 'rangeStart' => '2009-01-01 01:45:59',
    394. 

  394.                                                                 'rangeEnd' => '2012-12-31 01:45:59');
    395. 

  395.         }
    396. 

  396. 

  397.         if (!$name) {
    398. 

  398.             return $data;
    399. 

  399.         }
    400. 

  400. 

  401.         if (isset($data[$name])) {
    402. 

  402.             return $data[$name];
    403. 

  403.         }
    404. 

  404. 

  405.         return false;
    406. 

  406.     }
    407. 

  407.     
    408. 

  408.     /**
    409. 

  409.      * Return expected aggregate/change/moving/etc. values based on samples
    410. 

  410.      * from provideValuesSamples(), provideValuesSamplesAtInterval*, etc.
    411. 

  411.      *
    412. 

  412.      *      -   Does not use @dataProvider format.
    413. 

  413.      *
    414. 

  414.      * @param string    $name   Name of section in provider.php data.
    415. 

  415.      * @return Array    If $name is empty, all provider.php data; otherwise
    416. 

  416.      *                  only the named section.
    417. 

  417.      * @see Test/BasicDecimal/Tool/ scripts for recalculating expected values.
    418. 

  418.      */
    419. 

  419.     public static function provideExpectedValues($name = '')
    420. 

  420.     {
    421. 

  421.         static $expProviders;
    422. 

  422. 

  423.         if (!$expProviders) {
    424. 

  424.             require_once HASHMARK_ROOT_DIR . '/Test/Analyst/BasicDecimal/Data/provider.php';
    425. 

  425.         }
    426. 

  426. 

  427.         if (!$name) {
    428. 

  428.             return $expProviders;
    429. 

  429.         }
    430. 

  430. 

  431.         if (isset($expProviders[$name])) {
    432. 

  432.             return $expProviders[$name];
    433. 

  433.         }
    434. 

  434. 

  435.         return false;
    436. 

  436.     }
    437. 

  437. 

  438.     /**
    439. 

  439.      * @test
    440. 

  440.      * @group BasicDecimal
    441. 

  441.      * @group hasGeneratedProviderData
    442. 

  442.      */
    443. 

  443.     public function hasGeneratedProviderData()
    444. 

  444.     {
    445. 

  445.         $this->assertTrue(is_readable(HASHMARK_ROOT_DIR . '/Test/Analyst/BasicDecimal/Data/provider.php'),
    446. 

  446.                           'Generate data: php -f Test/Analyst/BasicDecimal/Tool/writeProviderData.php');
    447. 

  447.     }
    448. 

  448.     
    449. 

  449.     /**
    450. 

  450.      * @test
    451. 

  451.      * @group Analyst
    452. 

  452.      * @group BasicDecimal
    453. 

  453.      * @group throwsOnMissingSql
    454. 

  454.      * @group query
    455. 

  455.      */
    456. 

  456.     public function throwsOnMissingSql()
    457. 

  457.     {
    458. 

  458.         $thrown = false;
    459. 

  459.         $values = array();
    460. 

  460. 

  461.         foreach (array('', array(), 1) as $sql) {
    462. 

  462.             try {
    463. 

  463.                 $this->_analyst->multiQuery($sql, $values);
    464. 

  464.             } catch (Exception $e) {
    465. 

  465.                 $thrown = true;
    466. 

  466.             }
    467. 

  467. 

  468.             $this->assertTrue($thrown);
    469. 

  469.         }
    470. 

  470.     }
    471. 

  471.     
    472. 

  472.     /**
    473. 

  473.      * @test
    474. 

  474.      * @group BasicDecimal
    475. 

  475.      * @group findsValues
    476. 

  476.      * @group values
    477. 

  477.      * @group decimal
    478. 

  478.      * @group createScalar
    479. 

  479.      * @group createSample
    480. 

  480.      */
    481. 

  481.     public function findsValues()
    482. 

  482.     {
    483. 

  483.         $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    484. 

  484.         $scalarId = $this->_core->createScalar($scalarFields);
    485. 

  485. 

  486.         $sampleProvider = self::provideFullSamplesData('provideValuesSamples');
    487. 

  487.         $this->assertFalse(empty($sampleProvider));
    488. 

  488.         
    489. 

  489.         $expValues = array();
    490. 

  490. 

  491.         foreach ($sampleProvider['samples'] as $sample) {
    492. 

  492.             list($end, $value, , $isInRange) = $sample;
    493. 

  493. 

  494.             if ($isInRange) {
    495. 

  495.                 $expValues[$end] = $value;
    496. 

  496.             }
    497. 

  497. 

  498.             $this->_partition->createSample($scalarId, $value, $end);
    499. 

  499.         }
    500. 

  500. 

  501.         $actValues = $this->_analyst->values($scalarId, 50, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd']);
    502. 

  502. 

  503.         $this->assertEquals(count($expValues), count($actValues));
    504. 

  504. 

  505.         foreach ($actValues as $actual) {
    506. 

  506.             $this->assertDecimalEquals($expValues[$actual['x']], $actual['y']);
    507. 

  507.         }
    508. 

  508.     }
    509. 

  509.     
    510. 

  510.     /**
    511. 

  511.      * @test
    512. 

  512.      * @group BasicDecimal
    513. 

  513.      * @group findsValuesAtInterval
    514. 

  514.      * @group valuesAtInterval
    515. 

  515.      * @group decimal
    516. 

  516.      * @group createScalar
    517. 

  517.      * @group createSample
    518. 

  518.      */
    519. 

  519.     public function findsValuesAtInterval()
    520. 

  520.     {
    521. 

  521.         $intervalProviders = array(self::provideFullSamplesData('provideValuesAtIntervalHourSamples'),
    522. 

  522.                                    self::provideFullSamplesData('provideValuesAtIntervalDaySamples'),
    523. 

  523.                                    self::provideFullSamplesData('provideValuesAtIntervalWeekSamples'),
    524. 

  524.                                    self::provideFullSamplesData('provideValuesAtIntervalMonthSamples'),
    525. 

  525.                                    self::provideFullSamplesData('provideValuesAtIntervalHourSamples'));
    526. 

  526.         
    527. 

  527.         foreach ($intervalProviders as $sampleProvider) {
    528. 

  528.             $this->assertFalse(empty($sampleProvider));
    529. 

  529. 

  530.             $sampleSets = array($sampleProvider['samples'], array_reverse($sampleProvider['samples']));
    531. 

  531. 

  532.             foreach ($sampleSets as $samples) {
    533. 

  533.                 $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    534. 

  534.                 $scalarId = $this->_core->createScalar($scalarFields);
    535. 

  535. 

  536.                 $expValues = array();
    537. 

  537. 

  538.                 foreach ($samples as $sample) {
    539. 

  539.                     list($end, $value, $isMostRecentInInterval) = $sample;
    540. 

  540. 

  541.                     if ($isMostRecentInInterval) {
    542. 

  542.                         $expValues[$end] = $value;
    543. 

  543.                     }
    544. 

  544. 

  545.                     $this->_partition->createSample($scalarId, $value, $end);
    546. 

  546.                 }
    547. 

  547. 

  548.                 $actValues = $this->_analyst->valuesAtInterval($scalarId, 50, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval']);
    549. 

  549.                     
    550. 

  550.                 $errorMsg = "int={$sampleProvider['interval']}";
    551. 

  551. 

  552.                 $this->assertEquals(count($expValues), count($actValues), $errorMsg);
    553. 

  553. 

  554.                 foreach ($actValues as $actual) {
    555. 

  555.                     $this->assertDecimalEquals($expValues[$actual['x']], $actual['y'], $errorMsg . " x={$actual['x']}");
    556. 

  556.                 }
    557. 

  557.             }
    558. 

  558.         }
    559. 

  559.     }
    560. 

  560.     
    561. 

  561.     /**
    562. 

  562.      * @test
    563. 

  563.      * @group BasicDecimal
    564. 

  564.      * @group findsValuesAgg
    565. 

  565.      * @group valuesAgg
    566. 

  566.      * @group decimal
    567. 

  567.      * @group createScalar
    568. 

  568.      * @group createSample
    569. 

  569.      */
    570. 

  570.     public function findsValuesAgg()
    571. 

  571.     {
    572. 

  572.         $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    573. 

  573.         $scalarId = $this->_core->createScalar($scalarFields);
    574. 

  574. 

  575.         $sampleProvider = self::provideFullSamplesData('provideValuesSamples');
    576. 

  576.         $this->assertFalse(empty($sampleProvider));
    577. 

  577. 

  578.         $expValues = self::provideExpectedValues('provideValuesAgg');
    579. 

  579.         $this->assertFalse(empty($expValues));
    580. 

  580. 

  581.         foreach ($sampleProvider['samples'] as $sample) {
    582. 

  582.             list($end, $value) = $sample;
    583. 

  583.             $this->_partition->createSample($scalarId, $value, $end);
    584. 

  584.         }
    585. 

  585. 

  586.         foreach (self::$_aggFunctions as $aggFunc) {
    587. 

  587.             $errorMsg = "val=ALL f={$aggFunc}";
    588. 

  588.             $actual = $this->_analyst->valuesAgg($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $aggFunc, false);
    589. 

  589.             $this->assertDecimalEquals($expValues['ALL'][$aggFunc], $actual, $errorMsg);
    590. 

  590.             
    591. 

  591.             $errorMsg = "val=DIS f={$aggFunc}";
    592. 

  592.             $actual = $this->_analyst->valuesAgg($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $aggFunc, true);
    593. 

  593.             $this->assertDecimalEquals($expValues['DIS'][$aggFunc], $actual, $errorMsg);
    594. 

  594.         }
    595. 

  595.     }
    596. 

  596.     
    597. 

  597.     /**
    598. 

  598.      * @test
    599. 

  599.      * @group BasicDecimal
    600. 

  600.      * @group findsValuesAggAtInterval
    601. 

  601.      * @group valuesAggAtInterval
    602. 

  602.      * @group decimal
    603. 

  603.      * @group createScalar
    604. 

  604.      * @group createSample
    605. 

  605.      */
    606. 

  606.     public function findsValuesAggAtInterval()
    607. 

  607.     {
    608. 

  608.         $allSampleProviders = self::provideFullSamplesData();
    609. 

  609.         $this->assertFalse(empty($allSampleProviders));
    610. 

  610. 

  611.         $expProvider = self::provideExpectedValues('provideValuesAggAtInterval');
    612. 

  612.         $this->assertFalse(empty($expProvider));
    613. 

  613. 

  614.         foreach ($expProvider as $sampleProviderName => $expValues) {
    615. 

  615.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    616. 

  616.             $this->assertFalse(empty($sampleProvider));
    617. 

  617. 

  618.             $expCount = count($expValues['ALL']['AVG']);
    619. 

  619.             $expDistinctCount = count($expValues['DIS']['AVG']);
    620. 

  620.             
    621. 

  621.             $sampleSets = array($sampleProvider['samples'], array_reverse($sampleProvider['samples']));
    622. 

  622.                 
    623. 

  623.             foreach ($sampleSets as $samples) {
    624. 

  624.                 $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    625. 

  625.                 $scalarId = $this->_core->createScalar($scalarFields);
    626. 

  626. 

  627.                 foreach ($samples as $sample) {
    628. 

  628.                     list($end, $value) = $sample;
    629. 

  629.                     $this->_partition->createSample($scalarId, $value, $end);
    630. 

  630.                 }
    631. 

  631. 

  632.                 foreach (self::$_aggFunctions as $aggFunc) {
    633. 

  633.                     $errorMsg = "data={$sampleProviderName} val=ALL f={$aggFunc} int={$sampleProvider['interval']}";
    634. 

  634.                     $actValues = $this->_analyst->valuesAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFunc, false);
    635. 

  635.                     $this->assertEquals($expCount, count($actValues), $errorMsg);
    636. 

  636.                     foreach ($actValues as $actual) {
    637. 

  637.                         $this->assertDecimalEquals($expValues['ALL'][$aggFunc][$actual['x']], $actual['y'], $errorMsg . " x={$actual['x']}");
    638. 

  638.                     }
    639. 

  639. 

  640.                     $errorMsg = "data={$sampleProviderName} val=DIS f={$aggFunc} int={$sampleProvider['interval']}";
    641. 

  641.                     $actValues = $this->_analyst->valuesAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFunc, true);
    642. 

  642.                     $this->assertEquals($expDistinctCount, count($actValues), $errorMsg);
    643. 

  643.                     foreach ($actValues as $actual) {
    644. 

  644.                         $this->assertDecimalEquals($expValues['DIS'][$aggFunc][$actual['x']], $actual['y'], $errorMsg . " x={$actual['x']}");
    645. 

  645.                     }
    646. 

  646.                 }
    647. 

  647.             }
    648. 

  648.         }
    649. 

  649.     }
    650. 

  650.     
    651. 

  651.     /**
    652. 

  652.      * @test
    653. 

  653.      * @group BasicDecimal
    654. 

  654.      * @group findsValuesNestedAggsAtInterval
    655. 

  655.      * @group valuesNestedAggAtInterval
    656. 

  656.      * @group decimal
    657. 

  657.      * @group createScalar
    658. 

  658.      * @group createSample
    659. 

  659.      */
    660. 

  660.     public function findsValuesNestedAggsAtInterval()
    661. 

  661.     {
    662. 

  662.         $allSampleProviders = self::provideFullSamplesData();
    663. 

  663.         $this->assertFalse(empty($allSampleProviders));
    664. 

  664. 

  665.         $expProvider = self::provideExpectedValues('provideValuesNestedAggAtInterval');
    666. 

  666.         $this->assertFalse(empty($expProvider));
    667. 

  667. 

  668.         foreach ($expProvider as $sampleProviderName => $expValues) {
    669. 

  669.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    670. 

  670.             $this->assertFalse(empty($sampleProvider));
    671. 

  671. 

  672.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    673. 

  673.             $scalarId = $this->_core->createScalar($scalarFields);
    674. 

  674. 

  675.             foreach ($sampleProvider['samples'] as $sample) {
    676. 

  676.                 list($end, $value) = $sample;
    677. 

  677.                 $this->_partition->createSample($scalarId, $value, $end);
    678. 

  678.             }
    679. 

  679. 

  680.             foreach (self::$_aggFunctions as $aggFuncOuter) {
    681. 

  681.                 foreach (self::$_aggFunctions as $aggFuncInner) {
    682. 

  682.                     $errorMsg = "data={$sampleProviderName} val=ALL func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    683. 

  683.                     $actualAgg = $this->_analyst->valuesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, false, $aggFuncInner, false);
    684. 

  684.                     $this->assertDecimalEquals($expValues['ALL'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    685. 

  685. 

  686.                     $errorMsg = "data={$sampleProviderName} val=DIS_INNER func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    687. 

  687.                     $actualAgg = $this->_analyst->valuesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, false, $aggFuncInner, true);
    688. 

  688.                     $this->assertDecimalEquals($expValues['DIS_INNER'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    689. 

  689. 

  690.                     $errorMsg = "data={$sampleProviderName} val=DIS_OUTER func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    691. 

  691.                     $actualAgg = $this->_analyst->valuesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, true, $aggFuncInner, false);
    692. 

  692.                     $this->assertDecimalEquals($expValues['DIS_OUTER'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    693. 

  693.                     
    694. 

  694.                     $errorMsg = "data={$sampleProviderName} val=DIS_BOTH func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    695. 

  695.                     $actualAgg = $this->_analyst->valuesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, true, $aggFuncInner, true);
    696. 

  696.                     $this->assertDecimalEquals($expValues['DIS_BOTH'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    697. 

  697.                 }
    698. 

  698.             }
    699. 

  699.         }
    700. 

  700.     }
    701. 

  701.     
    702. 

  702.     /**
    703. 

  703.      * @test
    704. 

  704.      * @group BasicDecimal
    705. 

  705.      * @group findsValuesAggAtRecurrence
    706. 

  706.      * @group valuesAggAtRecurrence
    707. 

  707.      * @group decimal
    708. 

  708.      * @group createScalar
    709. 

  709.      * @group createSample
    710. 

  710.      */
    711. 

  711.     public function findsValuesAggAtRecurrence()
    712. 

  712.     {
    713. 

  713.         $allSampleProviders = self::provideFullSamplesData();
    714. 

  714.         $this->assertFalse(empty($allSampleProviders));
    715. 

  715. 

  716.         $expProvider = self::provideExpectedValues('provideValuesAggAtRecurrence');
    717. 

  717.         $this->assertFalse(empty($expProvider));
    718. 

  718. 

  719.         foreach ($expProvider as $sampleProviderName => $expValues) {
    720. 

  720.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    721. 

  721.             $this->assertFalse(empty($sampleProvider));
    722. 

  722. 

  723.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    724. 

  724.             $scalarId = $this->_core->createScalar($scalarFields);
    725. 

  725. 

  726.             foreach ($sampleProvider['samples'] as $sample) {
    727. 

  727.                 list($end, $value) = $sample;
    728. 

  728.                 $this->_partition->createSample($scalarId, $value, $end);
    729. 

  729.             }
    730. 

  730. 

  731.             foreach (Hashmark_Analyst_BasicDecimal::getRecurFunctions() as $recurFunc) {
    732. 

  732.                 foreach (self::$_aggFunctions as $aggFunc) {
    733. 

  733.                     $errorMsg = "data={$sampleProviderName} val=ALL recur={$recurFunc} agg={$aggFunc}";
    734. 

  734.                     $actValues = $this->_analyst->valuesAggAtRecurrence($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $recurFunc, $aggFunc, false);
    735. 

  735.                     foreach ($actValues as $actual) {
    736. 

  736.                         $this->assertDecimalEquals($expValues['ALL'][$recurFunc][$actual['x']][$aggFunc], $actual['y'], $errorMsg . " x={$actual['x']}");
    737. 

  737.                     }
    738. 

  738. 

  739.                     $errorMsg = "data={$sampleProviderName} val=DIS recur={$recurFunc} agg={$aggFunc}";
    740. 

  740.                     $actValues = $this->_analyst->valuesAggAtRecurrence($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $recurFunc, $aggFunc, true);
    741. 

  741.                     foreach ($actValues as $actual) {
    742. 

  742.                         $this->assertDecimalEquals($expValues['DIS'][$recurFunc][$actual['x']][$aggFunc], $actual['y'], $errorMsg . " x={$actual['x']}");
    743. 

  743.                     }
    744. 

  744.                 }
    745. 

  745.             }
    746. 

  746.         }
    747. 

  747.     }
    748. 

  748.     
    749. 

  749.     /**
    750. 

  750.      * @test
    751. 

  751.      * @group BasicDecimal
    752. 

  752.      * @group findsChanges
    753. 

  753.      * @group changes
    754. 

  754.      * @group decimal
    755. 

  755.      * @group createScalar
    756. 

  756.      * @group createSample
    757. 

  757.      */
    758. 

  758.     public function findsChanges()
    759. 

  759.     {
    760. 

  760.         $allSampleProviders = self::provideFullSamplesData();
    761. 

  761.         $this->assertFalse(empty($allSampleProviders));
    762. 

  762. 

  763.         $expProvider = self::provideExpectedValues('provideChanges');
    764. 

  764.         $this->assertFalse(empty($expProvider));
    765. 

  765. 

  766.         foreach ($expProvider as $sampleProviderName => $expValues) {
    767. 

  767.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    768. 

  768.             $this->assertFalse(empty($sampleProvider));
    769. 

  769. 

  770.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    771. 

  771.             $scalarId = $this->_core->createScalar($scalarFields);
    772. 

  772. 

  773.             foreach ($sampleProvider['samples'] as $sample) {
    774. 

  774.                 list($end, $value) = $sample;
    775. 

  775.                 $this->_partition->createSample($scalarId, $value, $end);
    776. 

  776.             }
    777. 

  777. 

  778.             $errorMsg = "data={$sampleProviderName}";
    779. 

  779. 

  780.             $actValues = $this->_analyst->changes($scalarId, 50, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd']);
    781. 

  781. 

  782.             $this->assertEquals(count($expValues), count($actValues), $errorMsg);
    783. 

  783. 

  784.             foreach ($actValues as $actual) {
    785. 

  785.                 $this->assertDecimalEquals($expValues[$actual['x']], $actual['y2'], $errorMsg . " x={$actual['x']}");
    786. 

  786.             }
    787. 

  787.         }
    788. 

  788.     }
    789. 

  789.     
    790. 

  790.     /**
    791. 

  791.      * @test
    792. 

  792.      * @group BasicDecimal
    793. 

  793.      * @group findsChangesAtInterval
    794. 

  794.      * @group changesAtInterval
    795. 

  795.      * @group decimal
    796. 

  796.      * @group createScalar
    797. 

  797.      * @group createSample
    798. 

  798.      */
    799. 

  799.     public function findsChangesAtInterval()
    800. 

  800.     {
    801. 

  801.         $allSampleProviders = self::provideFullSamplesData();
    802. 

  802.         $this->assertFalse(empty($allSampleProviders));
    803. 

  803. 

  804.         $expProvider = self::provideExpectedValues('provideChangesAtInterval');
    805. 

  805.         $this->assertFalse(empty($expProvider));
    806. 

  806. 

  807.         foreach ($expProvider as $sampleProviderName => $expValues) {
    808. 

  808.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    809. 

  809.             $this->assertFalse(empty($sampleProvider));
    810. 

  810. 

  811.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    812. 

  812.             $scalarId = $this->_core->createScalar($scalarFields);
    813. 

  813. 

  814.             foreach ($sampleProvider['samples'] as $sample) {
    815. 

  815.                 list($end, $value) = $sample;
    816. 

  816.                 $this->_partition->createSample($scalarId, $value, $end);
    817. 

  817.             }
    818. 

  818. 

  819.             $actValues = $this->_analyst->changesAtInterval($scalarId, 50, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval']);
    820. 

  820. 

  821.             $errorMsg = "data={$sampleProviderName} int={$sampleProvider['interval']}";
    822. 

  822. 

  823.             $this->assertEquals(count($expValues), count($actValues), $errorMsg);
    824. 

  824. 

  825.             foreach ($actValues as $actual) {
    826. 

  826.                 $this->assertDecimalEquals($expValues[$actual['x']], $actual['y2'], $errorMsg . " x={$actual['x']}");
    827. 

  827.             }
    828. 

  828.         }
    829. 

  829.     }
    830. 

  830.     
    831. 

  831.     /**
    832. 

  832.      * @test
    833. 

  833.      * @group BasicDecimal
    834. 

  834.      * @group findsChangesAgg
    835. 

  835.      * @group changesAgg
    836. 

  836.      * @group decimal
    837. 

  837.      * @group createScalar
    838. 

  838.      * @group createSample
    839. 

  839.      */
    840. 

  840.     public function findsChangesAgg()
    841. 

  841.     {
    842. 

  842.         $allSampleProviders = self::provideFullSamplesData();
    843. 

  843.         $this->assertFalse(empty($allSampleProviders));
    844. 

  844. 

  845.         $expProvider = self::provideExpectedValues('provideChangesAgg');
    846. 

  846.         $this->assertFalse(empty($expProvider));
    847. 

  847. 

  848.         foreach ($expProvider as $sampleProviderName => $expValues) {
    849. 

  849.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    850. 

  850.             $this->assertFalse(empty($sampleProvider));
    851. 

  851. 

  852.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    853. 

  853.             $scalarId = $this->_core->createScalar($scalarFields);
    854. 

  854. 

  855.             foreach ($sampleProvider['samples'] as $sample) {
    856. 

  856.                 list($end, $value) = $sample;
    857. 

  857.                 $this->_partition->createSample($scalarId, $value, $end);
    858. 

  858.             }
    859. 

  859. 

  860.             foreach (self::$_aggFunctions as $aggFunc) {
    861. 

  861.                 $errorMsg = "val=ALL f={$aggFunc}";
    862. 

  862.                 $actual = $this->_analyst->changesAgg($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $aggFunc, false);
    863. 

  863.                 $this->assertDecimalEquals($expValues['ALL'][$aggFunc], $actual, $errorMsg);
    864. 

  864. 

  865.                 $errorMsg = "val=DIS f={$aggFunc}";
    866. 

  866.                 $actual = $this->_analyst->changesAgg($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $aggFunc, true);
    867. 

  867.                 $this->assertDecimalEquals($expValues['DIS'][$aggFunc], $actual, $errorMsg);
    868. 

  868.             }
    869. 

  869.         }
    870. 

  870.     }
    871. 

  871.     
    872. 

  872.     /**
    873. 

  873.      * @test
    874. 

  874.      * @group BasicDecimal
    875. 

  875.      * @group findsChangesAggAtInterval
    876. 

  876.      * @group changesAggAtInterval
    877. 

  877.      * @group decimal
    878. 

  878.      * @group createScalar
    879. 

  879.      * @group createSample
    880. 

  880.      */
    881. 

  881.     public function findsChangesAggAtInterval()
    882. 

  882.     {
    883. 

  883.         $allSampleProviders = self::provideFullSamplesData();
    884. 

  884.         $this->assertFalse(empty($allSampleProviders));
    885. 

  885. 

  886.         $expProvider = self::provideExpectedValues('provideChangesAggAtInterval');
    887. 

  887.         $this->assertFalse(empty($expProvider));
    888. 

  888. 

  889.         foreach ($expProvider as $sampleProviderName => $expValues) {
    890. 

  890.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    891. 

  891.             $this->assertFalse(empty($sampleProvider));
    892. 

  892. 

  893.             $aggCount = count($expValues['ALL']['AVG']);
    894. 

  894.             $aggDistinctCount = count($expValues['DIS']['AVG']);
    895. 

  895. 

  896.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    897. 

  897.             $scalarId = $this->_core->createScalar($scalarFields);
    898. 

  898. 

  899.             foreach ($sampleProvider['samples'] as $sample) {
    900. 

  900.                 list($end, $value) = $sample;
    901. 

  901.                 $this->_partition->createSample($scalarId, $value, $end);
    902. 

  902.             }
    903. 

  903. 

  904.             foreach (self::$_aggFunctions as $aggFunc) {
    905. 

  905.                 $errorMsg = "data={$sampleProviderName} val=ALL f={$aggFunc} int={$sampleProvider['interval']}";
    906. 

  906.                 $actValues = $this->_analyst->changesAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFunc, false);
    907. 

  907.                 $this->assertEquals($aggCount, count($actValues), $errorMsg);
    908. 

  908.                 foreach ($actValues as $actual) {
    909. 

  909.                     $this->assertDecimalEquals($expValues['ALL'][$aggFunc][$actual['x']], $actual['y'], $errorMsg . " x={$actual['x']}");
    910. 

  910.                 }
    911. 

  911. 

  912.                 $errorMsg = "data={$sampleProviderName} val=DIS f={$aggFunc} int={$sampleProvider['interval']}";
    913. 

  913.                 $actValues = $this->_analyst->changesAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFunc, true);
    914. 

  914.                 $this->assertEquals($aggDistinctCount, count($actValues), $errorMsg);
    915. 

  915.                 foreach ($actValues as $actual) {
    916. 

  916.                     $this->assertDecimalEquals($expValues['DIS'][$aggFunc][$actual['x']], $actual['y'], $errorMsg . " x={$actual['x']}");
    917. 

  917.                 }
    918. 

  918.             }
    919. 

  919.         }
    920. 

  920.     }
    921. 

  921.     
    922. 

  922.     /**
    923. 

  923.      * @test
    924. 

  924.      * @group BasicDecimal
    925. 

  925.      * @group findsChangesNestedAggsAtInterval
    926. 

  926.      * @group changesNestedAggAtInterval
    927. 

  927.      * @group decimal
    928. 

  928.      * @group createScalar
    929. 

  929.      * @group createSample
    930. 

  930.      */
    931. 

  931.     public function findsChangesNestedAggsAtInterval()
    932. 

  932.     {
    933. 

  933.         $allSampleProviders = self::provideFullSamplesData();
    934. 

  934.         $this->assertFalse(empty($allSampleProviders));
    935. 

  935. 

  936.         $expProvider = self::provideExpectedValues('provideChangesNestedAggAtInterval');
    937. 

  937.         $this->assertFalse(empty($expProvider));
    938. 

  938. 

  939.         foreach ($expProvider as $sampleProviderName => $expValues) {
    940. 

  940.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    941. 

  941.             $this->assertFalse(empty($sampleProvider));
    942. 

  942. 

  943.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    944. 

  944.             $scalarId = $this->_core->createScalar($scalarFields);
    945. 

  945. 

  946.             foreach ($sampleProvider['samples'] as $sample) {
    947. 

  947.                 list($end, $value) = $sample;
    948. 

  948.                 $this->_partition->createSample($scalarId, $value, $end);
    949. 

  949.             }
    950. 

  950. 

  951.             foreach (self::$_aggFunctions as $aggFuncOuter) {
    952. 

  952.                 foreach (self::$_aggFunctions as $aggFuncInner) {
    953. 

  953.                     $errorMsg = "data={$sampleProviderName} val=ALL func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    954. 

  954.                     $actualAgg = $this->_analyst->changesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, false, $aggFuncInner, false);
    955. 

  955.                     $this->assertDecimalEquals($expValues['ALL'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    956. 

  956. 

  957.                     $errorMsg = "data={$sampleProviderName} val=DIS_INNER func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    958. 

  958.                     $actualAgg = $this->_analyst->changesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, false, $aggFuncInner, true);
    959. 

  959.                     $this->assertDecimalEquals($expValues['DIS_INNER'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    960. 

  960. 

  961.                     $errorMsg = "data={$sampleProviderName} val=DIS_OUTER func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    962. 

  962.                     $actualAgg = $this->_analyst->changesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, true, $aggFuncInner, false);
    963. 

  963.                     $this->assertDecimalEquals($expValues['DIS_OUTER'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    964. 

  964.                     
    965. 

  965.                     $errorMsg = "data={$sampleProviderName} val=DIS_BOTH func={$aggFuncOuter}({$aggFuncInner}) int={$sampleProvider['interval']}";
    966. 

  966.                     $actualAgg = $this->_analyst->changesNestedAggAtInterval($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $sampleProvider['interval'], $aggFuncOuter, true, $aggFuncInner, true);
    967. 

  967.                     $this->assertDecimalEquals($expValues['DIS_BOTH'][$aggFuncOuter][$aggFuncInner], $actualAgg, $errorMsg);
    968. 

  968.                 }
    969. 

  969.             }
    970. 

  970.         }
    971. 

  971.     }
    972. 

  972.     
    973. 

  973.     /**
    974. 

  974.      * @test
    975. 

  975.      * @group BasicDecimal
    976. 

  976.      * @group findsChangesAggAtRecurrence
    977. 

  977.      * @group changesAggAtRecurrence
    978. 

  978.      * @group decimal
    979. 

  979.      * @group createScalar
    980. 

  980.      * @group createSample
    981. 

  981.      */
    982. 

  982.     public function findsChangesAggAtRecurrence()
    983. 

  983.     {
    984. 

  984.         $allSampleProviders = self::provideFullSamplesData();
    985. 

  985.         $this->assertFalse(empty($allSampleProviders));
    986. 

  986. 

  987.         $expProvider = self::provideExpectedValues('provideChangesAggAtRecurrence');
    988. 

  988.         $this->assertFalse(empty($expProvider));
    989. 

  989. 

  990.         foreach ($expProvider as $sampleProviderName => $expValues) {
    991. 

  991.             $sampleProvider = $allSampleProviders[$sampleProviderName];
    992. 

  992.             $this->assertFalse(empty($sampleProvider));
    993. 

  993. 

  994.             $scalarFields = array('name' => self::randomString(), 'type' => 'decimal');
    995. 

  995.             $scalarId = $this->_core->createScalar($scalarFields);
    996. 

  996. 

  997.             foreach ($sampleProvider['samples'] as $sample) {
    998. 

  998.                 list($end, $value) = $sample;
    999. 

  999.                 $this->_partition->createSample($scalarId, $value, $end);
    1000. 

  1000.             }
    1001. 

  1001. 

  1002.             foreach (Hashmark_Analyst_BasicDecimal::getRecurFunctions() as $recurFunc) {
    1003. 

  1003.                 foreach (self::$_aggFunctions as $aggFunc) {
    1004. 

  1004.                     $errorMsg = "data={$sampleProviderName} val=ALL recur={$recurFunc} agg={$aggFunc}";
    1005. 

  1005.                     $actValues = $this->_analyst->changesAggAtRecurrence($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $recurFunc, $aggFunc, false);
    1006. 

  1006.                     foreach ($actValues as $actual) {
    1007. 

  1007.                         $this->assertDecimalEquals($expValues['ALL'][$recurFunc][$actual['x']][$aggFunc], $actual['y'], $errorMsg . " x={$actual['x']}");
    1008. 

  1008.                     }
    1009. 

  1009. 

  1010.                     $errorMsg = "data={$sampleProviderName} val=DIS recur={$recurFunc} agg={$aggFunc}";
    1011. 

  1011.                     $actValues = $this->_analyst->changesAggAtRecurrence($scalarId, $sampleProvider['rangeStart'], $sampleProvider['rangeEnd'], $recurFunc, $aggFunc, true);
    1012. 

  1012.                     foreach ($actValues as $actual) {
    1013. 

  1013.                         $this->assertDecimalEquals($expValues['DIS'][$recurFunc][$actual['x']][$aggFunc], $actual['y'], $errorMsg . " x={$actual['x']}");
    1014. 

  1014.                     }
    1015. 

  1015.                 }
    1016. 

  1016.             }
    1017. 

  1017.         }
    1018. 

  1018.     }
    1019. 

  1019.    
    1020. 

  1020.     /**
    1021. 

  1021.      * @test
    1022. 

  1022.      * @group BasicDecimal
    1023. 

  1023.      * @group findsFrequencies
    1024. 

  1024.      * @group frequency
    1025. 

  1025.      * @group decimal
    1026. 

  1026.      * @group createScalar
    1027. 

  1027.      * @group c…
    1028.

Large files files are truncated, but you can click here to view the full file