<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source to the Rust file `libtest/lib.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>lib.rs.html -- source</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><link rel="shortcut icon" href="https://doc.rust-lang.org/favicon.ico"></head><body class="rustdoc source"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">☰</div><a href='../../test/index.html'><img src='https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='logo' width='100'></a></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><input class="search-input" name="search" autocomplete="off" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><pre class="line-numbers"><span id="1"> 1</span>
<span id="2"> 2</span>
<span id="3"> 3</span>
<span id="4"> 4</span>
<span id="5"> 5</span>
<span id="6"> 6</span>
<span id="7"> 7</span>
<span id="8"> 8</span>
<span id="9"> 9</span>
<span id="10"> 10</span>
<span id="11"> 11</span>
<span id="12"> 12</span>
<span id="13"> 13</span>
<span id="14"> 14</span>
<span id="15"> 15</span>
<span id="16"> 16</span>
<span id="17"> 17</span>
<span id="18"> 18</span>
<span id="19"> 19</span>
<span id="20"> 20</span>
<span id="21"> 21</span>
<span id="22"> 22</span>
<span id="23"> 23</span>
<span id="24"> 24</span>
<span id="25"> 25</span>
<span id="26"> 26</span>
<span id="27"> 27</span>
<span id="28"> 28</span>
<span id="29"> 29</span>
<span id="30"> 30</span>
<span id="31"> 31</span>
<span id="32"> 32</span>
<span id="33"> 33</span>
<span id="34"> 34</span>
<span id="35"> 35</span>
<span id="36"> 36</span>
<span id="37"> 37</span>
<span id="38"> 38</span>
<span id="39"> 39</span>
<span id="40"> 40</span>
<span id="41"> 41</span>
<span id="42"> 42</span>
<span id="43"> 43</span>
<span id="44"> 44</span>
<span id="45"> 45</span>
<span id="46"> 46</span>
<span id="47"> 47</span>
<span id="48"> 48</span>
<span id="49"> 49</span>
<span id="50"> 50</span>
<span id="51"> 51</span>
<span id="52"> 52</span>
<span id="53"> 53</span>
<span id="54"> 54</span>
<span id="55"> 55</span>
<span id="56"> 56</span>
<span id="57"> 57</span>
<span id="58"> 58</span>
<span id="59"> 59</span>
<span id="60"> 60</span>
<span id="61"> 61</span>
<span id="62"> 62</span>
<span id="63"> 63</span>
<span id="64"> 64</span>
<span id="65"> 65</span>
<span id="66"> 66</span>
<span id="67"> 67</span>
<span id="68"> 68</span>
<span id="69"> 69</span>
<span id="70"> 70</span>
<span id="71"> 71</span>
<span id="72"> 72</span>
<span id="73"> 73</span>
<span id="74"> 74</span>
<span id="75"> 75</span>
<span id="76"> 76</span>
<span id="77"> 77</span>
<span id="78"> 78</span>
<span id="79"> 79</span>
<span id="80"> 80</span>
<span id="81"> 81</span>
<span id="82"> 82</span>
<span id="83"> 83</span>
<span id="84"> 84</span>
<span id="85"> 85</span>
<span id="86"> 86</span>
<span id="87"> 87</span>
<span id="88"> 88</span>
<span id="89"> 89</span>
<span id="90"> 90</span>
<span id="91"> 91</span>
<span id="92"> 92</span>
<span id="93"> 93</span>
<span id="94"> 94</span>
<span id="95"> 95</span>
<span id="96"> 96</span>
<span id="97"> 97</span>
<span id="98"> 98</span>
<span id="99"> 99</span>
<span id="100"> 100</span>
<span id="101"> 101</span>
<span id="102"> 102</span>
<span id="103"> 103</span>
<span id="104"> 104</span>
<span id="105"> 105</span>
<span id="106"> 106</span>
<span id="107"> 107</span>
<span id="108"> 108</span>
<span id="109"> 109</span>
<span id="110"> 110</span>
<span id="111"> 111</span>
<span id="112"> 112</span>
<span id="113"> 113</span>
<span id="114"> 114</span>
<span id="115"> 115</span>
<span id="116"> 116</span>
<span id="117"> 117</span>
<span id="118"> 118</span>
<span id="119"> 119</span>
<span id="120"> 120</span>
<span id="121"> 121</span>
<span id="122"> 122</span>
<span id="123"> 123</span>
<span id="124"> 124</span>
<span id="125"> 125</span>
<span id="126"> 126</span>
<span id="127"> 127</span>
<span id="128"> 128</span>
<span id="129"> 129</span>
<span id="130"> 130</span>
<span id="131"> 131</span>
<span id="132"> 132</span>
<span id="133"> 133</span>
<span id="134"> 134</span>
<span id="135"> 135</span>
<span id="136"> 136</span>
<span id="137"> 137</span>
<span id="138"> 138</span>
<span id="139"> 139</span>
<span id="140"> 140</span>
<span id="141"> 141</span>
<span id="142"> 142</span>
<span id="143"> 143</span>
<span id="144"> 144</span>
<span id="145"> 145</span>
<span id="146"> 146</span>
<span id="147"> 147</span>
<span id="148"> 148</span>
<span id="149"> 149</span>
<span id="150"> 150</span>
<span id="151"> 151</span>
<span id="152"> 152</span>
<span id="153"> 153</span>
<span id="154"> 154</span>
<span id="155"> 155</span>
<span id="156"> 156</span>
<span id="157"> 157</span>
<span id="158"> 158</span>
<span id="159"> 159</span>
<span id="160"> 160</span>
<span id="161"> 161</span>
<span id="162"> 162</span>
<span id="163"> 163</span>
<span id="164"> 164</span>
<span id="165"> 165</span>
<span id="166"> 166</span>
<span id="167"> 167</span>
<span id="168"> 168</span>
<span id="169"> 169</span>
<span id="170"> 170</span>
<span id="171"> 171</span>
<span id="172"> 172</span>
<span id="173"> 173</span>
<span id="174"> 174</span>
<span id="175"> 175</span>
<span id="176"> 176</span>
<span id="177"> 177</span>
<span id="178"> 178</span>
<span id="179"> 179</span>
<span id="180"> 180</span>
<span id="181"> 181</span>
<span id="182"> 182</span>
<span id="183"> 183</span>
<span id="184"> 184</span>
<span id="185"> 185</span>
<span id="186"> 186</span>
<span id="187"> 187</span>
<span id="188"> 188</span>
<span id="189"> 189</span>
<span id="190"> 190</span>
<span id="191"> 191</span>
<span id="192"> 192</span>
<span id="193"> 193</span>
<span id="194"> 194</span>
<span id="195"> 195</span>
<span id="196"> 196</span>
<span id="197"> 197</span>
<span id="198"> 198</span>
<span id="199"> 199</span>
<span id="200"> 200</span>
<span id="201"> 201</span>
<span id="202"> 202</span>
<span id="203"> 203</span>
<span id="204"> 204</span>
<span id="205"> 205</span>
<span id="206"> 206</span>
<span id="207"> 207</span>
<span id="208"> 208</span>
<span id="209"> 209</span>
<span id="210"> 210</span>
<span id="211"> 211</span>
<span id="212"> 212</span>
<span id="213"> 213</span>
<span id="214"> 214</span>
<span id="215"> 215</span>
<span id="216"> 216</span>
<span id="217"> 217</span>
<span id="218"> 218</span>
<span id="219"> 219</span>
<span id="220"> 220</span>
<span id="221"> 221</span>
<span id="222"> 222</span>
<span id="223"> 223</span>
<span id="224"> 224</span>
<span id="225"> 225</span>
<span id="226"> 226</span>
<span id="227"> 227</span>
<span id="228"> 228</span>
<span id="229"> 229</span>
<span id="230"> 230</span>
<span id="231"> 231</span>
<span id="232"> 232</span>
<span id="233"> 233</span>
<span id="234"> 234</span>
<span id="235"> 235</span>
<span id="236"> 236</span>
<span id="237"> 237</span>
<span id="238"> 238</span>
<span id="239"> 239</span>
<span id="240"> 240</span>
<span id="241"> 241</span>
<span id="242"> 242</span>
<span id="243"> 243</span>
<span id="244"> 244</span>
<span id="245"> 245</span>
<span id="246"> 246</span>
<span id="247"> 247</span>
<span id="248"> 248</span>
<span id="249"> 249</span>
<span id="250"> 250</span>
<span id="251"> 251</span>
<span id="252"> 252</span>
<span id="253"> 253</span>
<span id="254"> 254</span>
<span id="255"> 255</span>
<span id="256"> 256</span>
<span id="257"> 257</span>
<span id="258"> 258</span>
<span id="259"> 259</span>
<span id="260"> 260</span>
<span id="261"> 261</span>
<span id="262"> 262</span>
<span id="263"> 263</span>
<span id="264"> 264</span>
<span id="265"> 265</span>
<span id="266"> 266</span>
<span id="267"> 267</span>
<span id="268"> 268</span>
<span id="269"> 269</span>
<span id="270"> 270</span>
<span id="271"> 271</span>
<span id="272"> 272</span>
<span id="273"> 273</span>
<span id="274"> 274</span>
<span id="275"> 275</span>
<span id="276"> 276</span>
<span id="277"> 277</span>
<span id="278"> 278</span>
<span id="279"> 279</span>
<span id="280"> 280</span>
<span id="281"> 281</span>
<span id="282"> 282</span>
<span id="283"> 283</span>
<span id="284"> 284</span>
<span id="285"> 285</span>
<span id="286"> 286</span>
<span id="287"> 287</span>
<span id="288"> 288</span>
<span id="289"> 289</span>
<span id="290"> 290</span>
<span id="291"> 291</span>
<span id="292"> 292</span>
<span id="293"> 293</span>
<span id="294"> 294</span>
<span id="295"> 295</span>
<span id="296"> 296</span>
<span id="297"> 297</span>
<span id="298"> 298</span>
<span id="299"> 299</span>
<span id="300"> 300</span>
<span id="301"> 301</span>
<span id="302"> 302</span>
<span id="303"> 303</span>
<span id="304"> 304</span>
<span id="305"> 305</span>
<span id="306"> 306</span>
<span id="307"> 307</span>
<span id="308"> 308</span>
<span id="309"> 309</span>
<span id="310"> 310</span>
<span id="311"> 311</span>
<span id="312"> 312</span>
<span id="313"> 313</span>
<span id="314"> 314</span>
<span id="315"> 315</span>
<span id="316"> 316</span>
<span id="317"> 317</span>
<span id="318"> 318</span>
<span id="319"> 319</span>
<span id="320"> 320</span>
<span id="321"> 321</span>
<span id="322"> 322</span>
<span id="323"> 323</span>
<span id="324"> 324</span>
<span id="325"> 325</span>
<span id="326"> 326</span>
<span id="327"> 327</span>
<span id="328"> 328</span>
<span id="329"> 329</span>
<span id="330"> 330</span>
<span id="331"> 331</span>
<span id="332"> 332</span>
<span id="333"> 333</span>
<span id="334"> 334</span>
<span id="335"> 335</span>
<span id="336"> 336</span>
<span id="337"> 337</span>
<span id="338"> 338</span>
<span id="339"> 339</span>
<span id="340"> 340</span>
<span id="341"> 341</span>
<span id="342"> 342</span>
<span id="343"> 343</span>
<span id="344"> 344</span>
<span id="345"> 345</span>
<span id="346"> 346</span>
<span id="347"> 347</span>
<span id="348"> 348</span>
<span id="349"> 349</span>
<span id="350"> 350</span>
<span id="351"> 351</span>
<span id="352"> 352</span>
<span id="353"> 353</span>
<span id="354"> 354</span>
<span id="355"> 355</span>
<span id="356"> 356</span>
<span id="357"> 357</span>
<span id="358"> 358</span>
<span id="359"> 359</span>
<span id="360"> 360</span>
<span id="361"> 361</span>
<span id="362"> 362</span>
<span id="363"> 363</span>
<span id="364"> 364</span>
<span id="365"> 365</span>
<span id="366"> 366</span>
<span id="367"> 367</span>
<span id="368"> 368</span>
<span id="369"> 369</span>
<span id="370"> 370</span>
<span id="371"> 371</span>
<span id="372"> 372</span>
<span id="373"> 373</span>
<span id="374"> 374</span>
<span id="375"> 375</span>
<span id="376"> 376</span>
<span id="377"> 377</span>
<span id="378"> 378</span>
<span id="379"> 379</span>
<span id="380"> 380</span>
<span id="381"> 381</span>
<span id="382"> 382</span>
<span id="383"> 383</span>
<span id="384"> 384</span>
<span id="385"> 385</span>
<span id="386"> 386</span>
<span id="387"> 387</span>
<span id="388"> 388</span>
<span id="389"> 389</span>
<span id="390"> 390</span>
<span id="391"> 391</span>
<span id="392"> 392</span>
<span id="393"> 393</span>
<span id="394"> 394</span>
<span id="395"> 395</span>
<span id="396"> 396</span>
<span id="397"> 397</span>
<span id="398"> 398</span>
<span id="399"> 399</span>
<span id="400"> 400</span>
<span id="401"> 401</span>
<span id="402"> 402</span>
<span id="403"> 403</span>
<span id="404"> 404</span>
<span id="405"> 405</span>
<span id="406"> 406</span>
<span id="407"> 407</span>
<span id="408"> 408</span>
<span id="409"> 409</span>
<span id="410"> 410</span>
<span id="411"> 411</span>
<span id="412"> 412</span>
<span id="413"> 413</span>
<span id="414"> 414</span>
<span id="415"> 415</span>
<span id="416"> 416</span>
<span id="417"> 417</span>
<span id="418"> 418</span>
<span id="419"> 419</span>
<span id="420"> 420</span>
<span id="421"> 421</span>
<span id="422"> 422</span>
<span id="423"> 423</span>
<span id="424"> 424</span>
<span id="425"> 425</span>
<span id="426"> 426</span>
<span id="427"> 427</span>
<span id="428"> 428</span>
<span id="429"> 429</span>
<span id="430"> 430</span>
<span id="431"> 431</span>
<span id="432"> 432</span>
<span id="433"> 433</span>
<span id="434"> 434</span>
<span id="435"> 435</span>
<span id="436"> 436</span>
<span id="437"> 437</span>
<span id="438"> 438</span>
<span id="439"> 439</span>
<span id="440"> 440</span>
<span id="441"> 441</span>
<span id="442"> 442</span>
<span id="443"> 443</span>
<span id="444"> 444</span>
<span id="445"> 445</span>
<span id="446"> 446</span>
<span id="447"> 447</span>
<span id="448"> 448</span>
<span id="449"> 449</span>
<span id="450"> 450</span>
<span id="451"> 451</span>
<span id="452"> 452</span>
<span id="453"> 453</span>
<span id="454"> 454</span>
<span id="455"> 455</span>
<span id="456"> 456</span>
<span id="457"> 457</span>
<span id="458"> 458</span>
<span id="459"> 459</span>
<span id="460"> 460</span>
<span id="461"> 461</span>
<span id="462"> 462</span>
<span id="463"> 463</span>
<span id="464"> 464</span>
<span id="465"> 465</span>
<span id="466"> 466</span>
<span id="467"> 467</span>
<span id="468"> 468</span>
<span id="469"> 469</span>
<span id="470"> 470</span>
<span id="471"> 471</span>
<span id="472"> 472</span>
<span id="473"> 473</span>
<span id="474"> 474</span>
<span id="475"> 475</span>
<span id="476"> 476</span>
<span id="477"> 477</span>
<span id="478"> 478</span>
<span id="479"> 479</span>
<span id="480"> 480</span>
<span id="481"> 481</span>
<span id="482"> 482</span>
<span id="483"> 483</span>
<span id="484"> 484</span>
<span id="485"> 485</span>
<span id="486"> 486</span>
<span id="487"> 487</span>
<span id="488"> 488</span>
<span id="489"> 489</span>
<span id="490"> 490</span>
<span id="491"> 491</span>
<span id="492"> 492</span>
<span id="493"> 493</span>
<span id="494"> 494</span>
<span id="495"> 495</span>
<span id="496"> 496</span>
<span id="497"> 497</span>
<span id="498"> 498</span>
<span id="499"> 499</span>
<span id="500"> 500</span>
<span id="501"> 501</span>
<span id="502"> 502</span>
<span id="503"> 503</span>
<span id="504"> 504</span>
<span id="505"> 505</span>
<span id="506"> 506</span>
<span id="507"> 507</span>
<span id="508"> 508</span>
<span id="509"> 509</span>
<span id="510"> 510</span>
<span id="511"> 511</span>
<span id="512"> 512</span>
<span id="513"> 513</span>
<span id="514"> 514</span>
<span id="515"> 515</span>
<span id="516"> 516</span>
<span id="517"> 517</span>
<span id="518"> 518</span>
<span id="519"> 519</span>
<span id="520"> 520</span>
<span id="521"> 521</span>
<span id="522"> 522</span>
<span id="523"> 523</span>
<span id="524"> 524</span>
<span id="525"> 525</span>
<span id="526"> 526</span>
<span id="527"> 527</span>
<span id="528"> 528</span>
<span id="529"> 529</span>
<span id="530"> 530</span>
<span id="531"> 531</span>
<span id="532"> 532</span>
<span id="533"> 533</span>
<span id="534"> 534</span>
<span id="535"> 535</span>
<span id="536"> 536</span>
<span id="537"> 537</span>
<span id="538"> 538</span>
<span id="539"> 539</span>
<span id="540"> 540</span>
<span id="541"> 541</span>
<span id="542"> 542</span>
<span id="543"> 543</span>
<span id="544"> 544</span>
<span id="545"> 545</span>
<span id="546"> 546</span>
<span id="547"> 547</span>
<span id="548"> 548</span>
<span id="549"> 549</span>
<span id="550"> 550</span>
<span id="551"> 551</span>
<span id="552"> 552</span>
<span id="553"> 553</span>
<span id="554"> 554</span>
<span id="555"> 555</span>
<span id="556"> 556</span>
<span id="557"> 557</span>
<span id="558"> 558</span>
<span id="559"> 559</span>
<span id="560"> 560</span>
<span id="561"> 561</span>
<span id="562"> 562</span>
<span id="563"> 563</span>
<span id="564"> 564</span>
<span id="565"> 565</span>
<span id="566"> 566</span>
<span id="567"> 567</span>
<span id="568"> 568</span>
<span id="569"> 569</span>
<span id="570"> 570</span>
<span id="571"> 571</span>
<span id="572"> 572</span>
<span id="573"> 573</span>
<span id="574"> 574</span>
<span id="575"> 575</span>
<span id="576"> 576</span>
<span id="577"> 577</span>
<span id="578"> 578</span>
<span id="579"> 579</span>
<span id="580"> 580</span>
<span id="581"> 581</span>
<span id="582"> 582</span>
<span id="583"> 583</span>
<span id="584"> 584</span>
<span id="585"> 585</span>
<span id="586"> 586</span>
<span id="587"> 587</span>
<span id="588"> 588</span>
<span id="589"> 589</span>
<span id="590"> 590</span>
<span id="591"> 591</span>
<span id="592"> 592</span>
<span id="593"> 593</span>
<span id="594"> 594</span>
<span id="595"> 595</span>
<span id="596"> 596</span>
<span id="597"> 597</span>
<span id="598"> 598</span>
<span id="599"> 599</span>
<span id="600"> 600</span>
<span id="601"> 601</span>
<span id="602"> 602</span>
<span id="603"> 603</span>
<span id="604"> 604</span>
<span id="605"> 605</span>
<span id="606"> 606</span>
<span id="607"> 607</span>
<span id="608"> 608</span>
<span id="609"> 609</span>
<span id="610"> 610</span>
<span id="611"> 611</span>
<span id="612"> 612</span>
<span id="613"> 613</span>
<span id="614"> 614</span>
<span id="615"> 615</span>
<span id="616"> 616</span>
<span id="617"> 617</span>
<span id="618"> 618</span>
<span id="619"> 619</span>
<span id="620"> 620</span>
<span id="621"> 621</span>
<span id="622"> 622</span>
<span id="623"> 623</span>
<span id="624"> 624</span>
<span id="625"> 625</span>
<span id="626"> 626</span>
<span id="627"> 627</span>
<span id="628"> 628</span>
<span id="629"> 629</span>
<span id="630"> 630</span>
<span id="631"> 631</span>
<span id="632"> 632</span>
<span id="633"> 633</span>
<span id="634"> 634</span>
<span id="635"> 635</span>
<span id="636"> 636</span>
<span id="637"> 637</span>
<span id="638"> 638</span>
<span id="639"> 639</span>
<span id="640"> 640</span>
<span id="641"> 641</span>
<span id="642"> 642</span>
<span id="643"> 643</span>
<span id="644"> 644</span>
<span id="645"> 645</span>
<span id="646"> 646</span>
<span id="647"> 647</span>
<span id="648"> 648</span>
<span id="649"> 649</span>
<span id="650"> 650</span>
<span id="651"> 651</span>
<span id="652"> 652</span>
<span id="653"> 653</span>
<span id="654"> 654</span>
<span id="655"> 655</span>
<span id="656"> 656</span>
<span id="657"> 657</span>
<span id="658"> 658</span>
<span id="659"> 659</span>
<span id="660"> 660</span>
<span id="661"> 661</span>
<span id="662"> 662</span>
<span id="663"> 663</span>
<span id="664"> 664</span>
<span id="665"> 665</span>
<span id="666"> 666</span>
<span id="667"> 667</span>
<span id="668"> 668</span>
<span id="669"> 669</span>
<span id="670"> 670</span>
<span id="671"> 671</span>
<span id="672"> 672</span>
<span id="673"> 673</span>
<span id="674"> 674</span>
<span id="675"> 675</span>
<span id="676"> 676</span>
<span id="677"> 677</span>
<span id="678"> 678</span>
<span id="679"> 679</span>
<span id="680"> 680</span>
<span id="681"> 681</span>
<span id="682"> 682</span>
<span id="683"> 683</span>
<span id="684"> 684</span>
<span id="685"> 685</span>
<span id="686"> 686</span>
<span id="687"> 687</span>
<span id="688"> 688</span>
<span id="689"> 689</span>
<span id="690"> 690</span>
<span id="691"> 691</span>
<span id="692"> 692</span>
<span id="693"> 693</span>
<span id="694"> 694</span>
<span id="695"> 695</span>
<span id="696"> 696</span>
<span id="697"> 697</span>
<span id="698"> 698</span>
<span id="699"> 699</span>
<span id="700"> 700</span>
<span id="701"> 701</span>
<span id="702"> 702</span>
<span id="703"> 703</span>
<span id="704"> 704</span>
<span id="705"> 705</span>
<span id="706"> 706</span>
<span id="707"> 707</span>
<span id="708"> 708</span>
<span id="709"> 709</span>
<span id="710"> 710</span>
<span id="711"> 711</span>
<span id="712"> 712</span>
<span id="713"> 713</span>
<span id="714"> 714</span>
<span id="715"> 715</span>
<span id="716"> 716</span>
<span id="717"> 717</span>
<span id="718"> 718</span>
<span id="719"> 719</span>
<span id="720"> 720</span>
<span id="721"> 721</span>
<span id="722"> 722</span>
<span id="723"> 723</span>
<span id="724"> 724</span>
<span id="725"> 725</span>
<span id="726"> 726</span>
<span id="727"> 727</span>
<span id="728"> 728</span>
<span id="729"> 729</span>
<span id="730"> 730</span>
<span id="731"> 731</span>
<span id="732"> 732</span>
<span id="733"> 733</span>
<span id="734"> 734</span>
<span id="735"> 735</span>
<span id="736"> 736</span>
<span id="737"> 737</span>
<span id="738"> 738</span>
<span id="739"> 739</span>
<span id="740"> 740</span>
<span id="741"> 741</span>
<span id="742"> 742</span>
<span id="743"> 743</span>
<span id="744"> 744</span>
<span id="745"> 745</span>
<span id="746"> 746</span>
<span id="747"> 747</span>
<span id="748"> 748</span>
<span id="749"> 749</span>
<span id="750"> 750</span>
<span id="751"> 751</span>
<span id="752"> 752</span>
<span id="753"> 753</span>
<span id="754"> 754</span>
<span id="755"> 755</span>
<span id="756"> 756</span>
<span id="757"> 757</span>
<span id="758"> 758</span>
<span id="759"> 759</span>
<span id="760"> 760</span>
<span id="761"> 761</span>
<span id="762"> 762</span>
<span id="763"> 763</span>
<span id="764"> 764</span>
<span id="765"> 765</span>
<span id="766"> 766</span>
<span id="767"> 767</span>
<span id="768"> 768</span>
<span id="769"> 769</span>
<span id="770"> 770</span>
<span id="771"> 771</span>
<span id="772"> 772</span>
<span id="773"> 773</span>
<span id="774"> 774</span>
<span id="775"> 775</span>
<span id="776"> 776</span>
<span id="777"> 777</span>
<span id="778"> 778</span>
<span id="779"> 779</span>
<span id="780"> 780</span>
<span id="781"> 781</span>
<span id="782"> 782</span>
<span id="783"> 783</span>
<span id="784"> 784</span>
<span id="785"> 785</span>
<span id="786"> 786</span>
<span id="787"> 787</span>
<span id="788"> 788</span>
<span id="789"> 789</span>
<span id="790"> 790</span>
<span id="791"> 791</span>
<span id="792"> 792</span>
<span id="793"> 793</span>
<span id="794"> 794</span>
<span id="795"> 795</span>
<span id="796"> 796</span>
<span id="797"> 797</span>
<span id="798"> 798</span>
<span id="799"> 799</span>
<span id="800"> 800</span>
<span id="801"> 801</span>
<span id="802"> 802</span>
<span id="803"> 803</span>
<span id="804"> 804</span>
<span id="805"> 805</span>
<span id="806"> 806</span>
<span id="807"> 807</span>
<span id="808"> 808</span>
<span id="809"> 809</span>
<span id="810"> 810</span>
<span id="811"> 811</span>
<span id="812"> 812</span>
<span id="813"> 813</span>
<span id="814"> 814</span>
<span id="815"> 815</span>
<span id="816"> 816</span>
<span id="817"> 817</span>
<span id="818"> 818</span>
<span id="819"> 819</span>
<span id="820"> 820</span>
<span id="821"> 821</span>
<span id="822"> 822</span>
<span id="823"> 823</span>
<span id="824"> 824</span>
<span id="825"> 825</span>
<span id="826"> 826</span>
<span id="827"> 827</span>
<span id="828"> 828</span>
<span id="829"> 829</span>
<span id="830"> 830</span>
<span id="831"> 831</span>
<span id="832"> 832</span>
<span id="833"> 833</span>
<span id="834"> 834</span>
<span id="835"> 835</span>
<span id="836"> 836</span>
<span id="837"> 837</span>
<span id="838"> 838</span>
<span id="839"> 839</span>
<span id="840"> 840</span>
<span id="841"> 841</span>
<span id="842"> 842</span>
<span id="843"> 843</span>
<span id="844"> 844</span>
<span id="845"> 845</span>
<span id="846"> 846</span>
<span id="847"> 847</span>
<span id="848"> 848</span>
<span id="849"> 849</span>
<span id="850"> 850</span>
<span id="851"> 851</span>
<span id="852"> 852</span>
<span id="853"> 853</span>
<span id="854"> 854</span>
<span id="855"> 855</span>
<span id="856"> 856</span>
<span id="857"> 857</span>
<span id="858"> 858</span>
<span id="859"> 859</span>
<span id="860"> 860</span>
<span id="861"> 861</span>
<span id="862"> 862</span>
<span id="863"> 863</span>
<span id="864"> 864</span>
<span id="865"> 865</span>
<span id="866"> 866</span>
<span id="867"> 867</span>
<span id="868"> 868</span>
<span id="869"> 869</span>
<span id="870"> 870</span>
<span id="871"> 871</span>
<span id="872"> 872</span>
<span id="873"> 873</span>
<span id="874"> 874</span>
<span id="875"> 875</span>
<span id="876"> 876</span>
<span id="877"> 877</span>
<span id="878"> 878</span>
<span id="879"> 879</span>
<span id="880"> 880</span>
<span id="881"> 881</span>
<span id="882"> 882</span>
<span id="883"> 883</span>
<span id="884"> 884</span>
<span id="885"> 885</span>
<span id="886"> 886</span>
<span id="887"> 887</span>
<span id="888"> 888</span>
<span id="889"> 889</span>
<span id="890"> 890</span>
<span id="891"> 891</span>
<span id="892"> 892</span>
<span id="893"> 893</span>
<span id="894"> 894</span>
<span id="895"> 895</span>
<span id="896"> 896</span>
<span id="897"> 897</span>
<span id="898"> 898</span>
<span id="899"> 899</span>
<span id="900"> 900</span>
<span id="901"> 901</span>
<span id="902"> 902</span>
<span id="903"> 903</span>
<span id="904"> 904</span>
<span id="905"> 905</span>
<span id="906"> 906</span>
<span id="907"> 907</span>
<span id="908"> 908</span>
<span id="909"> 909</span>
<span id="910"> 910</span>
<span id="911"> 911</span>
<span id="912"> 912</span>
<span id="913"> 913</span>
<span id="914"> 914</span>
<span id="915"> 915</span>
<span id="916"> 916</span>
<span id="917"> 917</span>
<span id="918"> 918</span>
<span id="919"> 919</span>
<span id="920"> 920</span>
<span id="921"> 921</span>
<span id="922"> 922</span>
<span id="923"> 923</span>
<span id="924"> 924</span>
<span id="925"> 925</span>
<span id="926"> 926</span>
<span id="927"> 927</span>
<span id="928"> 928</span>
<span id="929"> 929</span>
<span id="930"> 930</span>
<span id="931"> 931</span>
<span id="932"> 932</span>
<span id="933"> 933</span>
<span id="934"> 934</span>
<span id="935"> 935</span>
<span id="936"> 936</span>
<span id="937"> 937</span>
<span id="938"> 938</span>
<span id="939"> 939</span>
<span id="940"> 940</span>
<span id="941"> 941</span>
<span id="942"> 942</span>
<span id="943"> 943</span>
<span id="944"> 944</span>
<span id="945"> 945</span>
<span id="946"> 946</span>
<span id="947"> 947</span>
<span id="948"> 948</span>
<span id="949"> 949</span>
<span id="950"> 950</span>
<span id="951"> 951</span>
<span id="952"> 952</span>
<span id="953"> 953</span>
<span id="954"> 954</span>
<span id="955"> 955</span>
<span id="956"> 956</span>
<span id="957"> 957</span>
<span id="958"> 958</span>
<span id="959"> 959</span>
<span id="960"> 960</span>
<span id="961"> 961</span>
<span id="962"> 962</span>
<span id="963"> 963</span>
<span id="964"> 964</span>
<span id="965"> 965</span>
<span id="966"> 966</span>
<span id="967"> 967</span>
<span id="968"> 968</span>
<span id="969"> 969</span>
<span id="970"> 970</span>
<span id="971"> 971</span>
<span id="972"> 972</span>
<span id="973"> 973</span>
<span id="974"> 974</span>
<span id="975"> 975</span>
<span id="976"> 976</span>
<span id="977"> 977</span>
<span id="978"> 978</span>
<span id="979"> 979</span>
<span id="980"> 980</span>
<span id="981"> 981</span>
<span id="982"> 982</span>
<span id="983"> 983</span>
<span id="984"> 984</span>
<span id="985"> 985</span>
<span id="986"> 986</span>
<span id="987"> 987</span>
<span id="988"> 988</span>
<span id="989"> 989</span>
<span id="990"> 990</span>
<span id="991"> 991</span>
<span id="992"> 992</span>
<span id="993"> 993</span>
<span id="994"> 994</span>
<span id="995"> 995</span>
<span id="996"> 996</span>
<span id="997"> 997</span>
<span id="998"> 998</span>
<span id="999"> 999</span>
<span id="1000">1000</span>
<span id="1001">1001</span>
<span id="1002">1002</span>
<span id="1003">1003</span>
<span id="1004">1004</span>
<span id="1005">1005</span>
<span id="1006">1006</span>
<span id="1007">1007</span>
<span id="1008">1008</span>
<span id="1009">1009</span>
<span id="1010">1010</span>
<span id="1011">1011</span>
<span id="1012">1012</span>
<span id="1013">1013</span>
<span id="1014">1014</span>
<span id="1015">1015</span>
<span id="1016">1016</span>
<span id="1017">1017</span>
<span id="1018">1018</span>
<span id="1019">1019</span>
<span id="1020">1020</span>
<span id="1021">1021</span>
<span id="1022">1022</span>
<span id="1023">1023</span>
<span id="1024">1024</span>
<span id="1025">1025</span>
<span id="1026">1026</span>
<span id="1027">1027</span>
<span id="1028">1028</span>
<span id="1029">1029</span>
<span id="1030">1030</span>
<span id="1031">1031</span>
<span id="1032">1032</span>
<span id="1033">1033</span>
<span id="1034">1034</span>
<span id="1035">1035</span>
<span id="1036">1036</span>
<span id="1037">1037</span>
<span id="1038">1038</span>
<span id="1039">1039</span>
<span id="1040">1040</span>
<span id="1041">1041</span>
<span id="1042">1042</span>
<span id="1043">1043</span>
<span id="1044">1044</span>
<span id="1045">1045</span>
<span id="1046">1046</span>
<span id="1047">1047</span>
<span id="1048">1048</span>
<span id="1049">1049</span>
<span id="1050">1050</span>
<span id="1051">1051</span>
<span id="1052">1052</span>
<span id="1053">1053</span>
<span id="1054">1054</span>
<span id="1055">1055</span>
<span id="1056">1056</span>
<span id="1057">1057</span>
<span id="1058">1058</span>
<span id="1059">1059</span>
<span id="1060">1060</span>
<span id="1061">1061</span>
<span id="1062">1062</span>
<span id="1063">1063</span>
<span id="1064">1064</span>
<span id="1065">1065</span>
<span id="1066">1066</span>
<span id="1067">1067</span>
<span id="1068">1068</span>
<span id="1069">1069</span>
<span id="1070">1070</span>
<span id="1071">1071</span>
<span id="1072">1072</span>
<span id="1073">1073</span>
<span id="1074">1074</span>
<span id="1075">1075</span>
<span id="1076">1076</span>
<span id="1077">1077</span>
<span id="1078">1078</span>
<span id="1079">1079</span>
<span id="1080">1080</span>
<span id="1081">1081</span>
<span id="1082">1082</span>
<span id="1083">1083</span>
<span id="1084">1084</span>
<span id="1085">1085</span>
<span id="1086">1086</span>
<span id="1087">1087</span>
<span id="1088">1088</span>
<span id="1089">1089</span>
<span id="1090">1090</span>
<span id="1091">1091</span>
<span id="1092">1092</span>
<span id="1093">1093</span>
<span id="1094">1094</span>
<span id="1095">1095</span>
<span id="1096">1096</span>
<span id="1097">1097</span>
<span id="1098">1098</span>
<span id="1099">1099</span>
<span id="1100">1100</span>
<span id="1101">1101</span>
<span id="1102">1102</span>
<span id="1103">1103</span>
<span id="1104">1104</span>
<span id="1105">1105</span>
<span id="1106">1106</span>
<span id="1107">1107</span>
<span id="1108">1108</span>
<span id="1109">1109</span>
<span id="1110">1110</span>
<span id="1111">1111</span>
<span id="1112">1112</span>
<span id="1113">1113</span>
<span id="1114">1114</span>
<span id="1115">1115</span>
<span id="1116">1116</span>
<span id="1117">1117</span>
<span id="1118">1118</span>
<span id="1119">1119</span>
<span id="1120">1120</span>
<span id="1121">1121</span>
<span id="1122">1122</span>
<span id="1123">1123</span>
<span id="1124">1124</span>
<span id="1125">1125</span>
<span id="1126">1126</span>
<span id="1127">1127</span>
<span id="1128">1128</span>
<span id="1129">1129</span>
<span id="1130">1130</span>
<span id="1131">1131</span>
<span id="1132">1132</span>
<span id="1133">1133</span>
<span id="1134">1134</span>
<span id="1135">1135</span>
<span id="1136">1136</span>
<span id="1137">1137</span>
<span id="1138">1138</span>
<span id="1139">1139</span>
<span id="1140">1140</span>
<span id="1141">1141</span>
<span id="1142">1142</span>
<span id="1143">1143</span>
<span id="1144">1144</span>
<span id="1145">1145</span>
<span id="1146">1146</span>
<span id="1147">1147</span>
<span id="1148">1148</span>
<span id="1149">1149</span>
<span id="1150">1150</span>
<span id="1151">1151</span>
<span id="1152">1152</span>
<span id="1153">1153</span>
<span id="1154">1154</span>
<span id="1155">1155</span>
<span id="1156">1156</span>
<span id="1157">1157</span>
<span id="1158">1158</span>
<span id="1159">1159</span>
<span id="1160">1160</span>
<span id="1161">1161</span>
<span id="1162">1162</span>
<span id="1163">1163</span>
<span id="1164">1164</span>
<span id="1165">1165</span>
<span id="1166">1166</span>
<span id="1167">1167</span>
<span id="1168">1168</span>
<span id="1169">1169</span>
<span id="1170">1170</span>
<span id="1171">1171</span>
<span id="1172">1172</span>
<span id="1173">1173</span>
<span id="1174">1174</span>
<span id="1175">1175</span>
<span id="1176">1176</span>
<span id="1177">1177</span>
<span id="1178">1178</span>
<span id="1179">1179</span>
<span id="1180">1180</span>
<span id="1181">1181</span>
<span id="1182">1182</span>
<span id="1183">1183</span>
<span id="1184">1184</span>
<span id="1185">1185</span>
<span id="1186">1186</span>
<span id="1187">1187</span>
<span id="1188">1188</span>
<span id="1189">1189</span>
<span id="1190">1190</span>
<span id="1191">1191</span>
<span id="1192">1192</span>
<span id="1193">1193</span>
<span id="1194">1194</span>
<span id="1195">1195</span>
<span id="1196">1196</span>
<span id="1197">1197</span>
<span id="1198">1198</span>
<span id="1199">1199</span>
<span id="1200">1200</span>
<span id="1201">1201</span>
<span id="1202">1202</span>
<span id="1203">1203</span>
<span id="1204">1204</span>
<span id="1205">1205</span>
<span id="1206">1206</span>
<span id="1207">1207</span>
<span id="1208">1208</span>
<span id="1209">1209</span>
<span id="1210">1210</span>
<span id="1211">1211</span>
<span id="1212">1212</span>
<span id="1213">1213</span>
<span id="1214">1214</span>
<span id="1215">1215</span>
<span id="1216">1216</span>
<span id="1217">1217</span>
<span id="1218">1218</span>
<span id="1219">1219</span>
<span id="1220">1220</span>
<span id="1221">1221</span>
<span id="1222">1222</span>
<span id="1223">1223</span>
<span id="1224">1224</span>
<span id="1225">1225</span>
<span id="1226">1226</span>
<span id="1227">1227</span>
<span id="1228">1228</span>
<span id="1229">1229</span>
<span id="1230">1230</span>
<span id="1231">1231</span>
<span id="1232">1232</span>
<span id="1233">1233</span>
<span id="1234">1234</span>
<span id="1235">1235</span>
<span id="1236">1236</span>
<span id="1237">1237</span>
<span id="1238">1238</span>
<span id="1239">1239</span>
<span id="1240">1240</span>
<span id="1241">1241</span>
<span id="1242">1242</span>
<span id="1243">1243</span>
<span id="1244">1244</span>
<span id="1245">1245</span>
<span id="1246">1246</span>
<span id="1247">1247</span>
<span id="1248">1248</span>
<span id="1249">1249</span>
<span id="1250">1250</span>
<span id="1251">1251</span>
<span id="1252">1252</span>
<span id="1253">1253</span>
<span id="1254">1254</span>
<span id="1255">1255</span>
<span id="1256">1256</span>
<span id="1257">1257</span>
<span id="1258">1258</span>
<span id="1259">1259</span>
<span id="1260">1260</span>
<span id="1261">1261</span>
<span id="1262">1262</span>
<span id="1263">1263</span>
<span id="1264">1264</span>
<span id="1265">1265</span>
<span id="1266">1266</span>
<span id="1267">1267</span>
<span id="1268">1268</span>
<span id="1269">1269</span>
<span id="1270">1270</span>
<span id="1271">1271</span>
<span id="1272">1272</span>
<span id="1273">1273</span>
<span id="1274">1274</span>
<span id="1275">1275</span>
<span id="1276">1276</span>
<span id="1277">1277</span>
<span id="1278">1278</span>
<span id="1279">1279</span>
<span id="1280">1280</span>
<span id="1281">1281</span>
<span id="1282">1282</span>
<span id="1283">1283</span>
<span id="1284">1284</span>
<span id="1285">1285</span>
<span id="1286">1286</span>
<span id="1287">1287</span>
<span id="1288">1288</span>
<span id="1289">1289</span>
<span id="1290">1290</span>
<span id="1291">1291</span>
<span id="1292">1292</span>
<span id="1293">1293</span>
<span id="1294">1294</span>
<span id="1295">1295</span>
<span id="1296">1296</span>
<span id="1297">1297</span>
<span id="1298">1298</span>
<span id="1299">1299</span>
<span id="1300">1300</span>
<span id="1301">1301</span>
<span id="1302">1302</span>
<span id="1303">1303</span>
<span id="1304">1304</span>
<span id="1305">1305</span>
<span id="1306">1306</span>
<span id="1307">1307</span>
<span id="1308">1308</span>
<span id="1309">1309</span>
<span id="1310">1310</span>
<span id="1311">1311</span>
<span id="1312">1312</span>
<span id="1313">1313</span>
<span id="1314">1314</span>
<span id="1315">1315</span>
<span id="1316">1316</span>
<span id="1317">1317</span>
<span id="1318">1318</span>
<span id="1319">1319</span>
<span id="1320">1320</span>
<span id="1321">1321</span>
<span id="1322">1322</span>
<span id="1323">1323</span>
<span id="1324">1324</span>
<span id="1325">1325</span>
<span id="1326">1326</span>
<span id="1327">1327</span>
<span id="1328">1328</span>
<span id="1329">1329</span>
<span id="1330">1330</span>
<span id="1331">1331</span>
<span id="1332">1332</span>
<span id="1333">1333</span>
<span id="1334">1334</span>
<span id="1335">1335</span>
<span id="1336">1336</span>
<span id="1337">1337</span>
<span id="1338">1338</span>
<span id="1339">1339</span>
<span id="1340">1340</span>
<span id="1341">1341</span>
<span id="1342">1342</span>
<span id="1343">1343</span>
<span id="1344">1344</span>
<span id="1345">1345</span>
<span id="1346">1346</span>
<span id="1347">1347</span>
<span id="1348">1348</span>
<span id="1349">1349</span>
<span id="1350">1350</span>
<span id="1351">1351</span>
<span id="1352">1352</span>
<span id="1353">1353</span>
<span id="1354">1354</span>
<span id="1355">1355</span>
<span id="1356">1356</span>
<span id="1357">1357</span>
<span id="1358">1358</span>
<span id="1359">1359</span>
<span id="1360">1360</span>
<span id="1361">1361</span>
<span id="1362">1362</span>
<span id="1363">1363</span>
<span id="1364">1364</span>
<span id="1365">1365</span>
<span id="1366">1366</span>
<span id="1367">1367</span>
<span id="1368">1368</span>
<span id="1369">1369</span>
<span id="1370">1370</span>
<span id="1371">1371</span>
<span id="1372">1372</span>
<span id="1373">1373</span>
<span id="1374">1374</span>
<span id="1375">1375</span>
<span id="1376">1376</span>
<span id="1377">1377</span>
<span id="1378">1378</span>
<span id="1379">1379</span>
<span id="1380">1380</span>
<span id="1381">1381</span>
<span id="1382">1382</span>
<span id="1383">1383</span>
<span id="1384">1384</span>
<span id="1385">1385</span>
<span id="1386">1386</span>
<span id="1387">1387</span>
<span id="1388">1388</span>
<span id="1389">1389</span>
<span id="1390">1390</span>
<span id="1391">1391</span>
<span id="1392">1392</span>
<span id="1393">1393</span>
<span id="1394">1394</span>
<span id="1395">1395</span>
<span id="1396">1396</span>
<span id="1397">1397</span>
<span id="1398">1398</span>
<span id="1399">1399</span>
<span id="1400">1400</span>
<span id="1401">1401</span>
<span id="1402">1402</span>
<span id="1403">1403</span>
<span id="1404">1404</span>
<span id="1405">1405</span>
<span id="1406">1406</span>
<span id="1407">1407</span>
<span id="1408">1408</span>
<span id="1409">1409</span>
<span id="1410">1410</span>
<span id="1411">1411</span>
<span id="1412">1412</span>
<span id="1413">1413</span>
<span id="1414">1414</span>
<span id="1415">1415</span>
<span id="1416">1416</span>
<span id="1417">1417</span>
<span id="1418">1418</span>
<span id="1419">1419</span>
<span id="1420">1420</span>
<span id="1421">1421</span>
<span id="1422">1422</span>
<span id="1423">1423</span>
<span id="1424">1424</span>
<span id="1425">1425</span>
<span id="1426">1426</span>
<span id="1427">1427</span>
<span id="1428">1428</span>
<span id="1429">1429</span>
<span id="1430">1430</span>
<span id="1431">1431</span>
<span id="1432">1432</span>
<span id="1433">1433</span>
<span id="1434">1434</span>
<span id="1435">1435</span>
<span id="1436">1436</span>
<span id="1437">1437</span>
<span id="1438">1438</span>
<span id="1439">1439</span>
<span id="1440">1440</span>
<span id="1441">1441</span>
<span id="1442">1442</span>
<span id="1443">1443</span>
<span id="1444">1444</span>
<span id="1445">1445</span>
<span id="1446">1446</span>
<span id="1447">1447</span>
<span id="1448">1448</span>
<span id="1449">1449</span>
<span id="1450">1450</span>
<span id="1451">1451</span>
<span id="1452">1452</span>
<span id="1453">1453</span>
<span id="1454">1454</span>
<span id="1455">1455</span>
<span id="1456">1456</span>
<span id="1457">1457</span>
<span id="1458">1458</span>
<span id="1459">1459</span>
<span id="1460">1460</span>
<span id="1461">1461</span>
<span id="1462">1462</span>
<span id="1463">1463</span>
<span id="1464">1464</span>
<span id="1465">1465</span>
<span id="1466">1466</span>
<span id="1467">1467</span>
<span id="1468">1468</span>
<span id="1469">1469</span>
<span id="1470">1470</span>
<span id="1471">1471</span>
<span id="1472">1472</span>
<span id="1473">1473</span>
<span id="1474">1474</span>
<span id="1475">1475</span>
<span id="1476">1476</span>
<span id="1477">1477</span>
<span id="1478">1478</span>
<span id="1479">1479</span>
<span id="1480">1480</span>
<span id="1481">1481</span>
<span id="1482">1482</span>
<span id="1483">1483</span>
<span id="1484">1484</span>
<span id="1485">1485</span>
<span id="1486">1486</span>
<span id="1487">1487</span>
<span id="1488">1488</span>
<span id="1489">1489</span>
<span id="1490">1490</span>
<span id="1491">1491</span>
<span id="1492">1492</span>
<span id="1493">1493</span>
<span id="1494">1494</span>
<span id="1495">1495</span>
<span id="1496">1496</span>
<span id="1497">1497</span>
<span id="1498">1498</span>
<span id="1499">1499</span>
<span id="1500">1500</span>
<span id="1501">1501</span>
<span id="1502">1502</span>
<span id="1503">1503</span>
<span id="1504">1504</span>
<span id="1505">1505</span>
<span id="1506">1506</span>
<span id="1507">1507</span>
<span id="1508">1508</span>
<span id="1509">1509</span>
<span id="1510">1510</span>
<span id="1511">1511</span>
<span id="1512">1512</span>
<span id="1513">1513</span>
<span id="1514">1514</span>
<span id="1515">1515</span>
<span id="1516">1516</span>
<span id="1517">1517</span>
<span id="1518">1518</span>
<span id="1519">1519</span>
<span id="1520">1520</span>
<span id="1521">1521</span>
<span id="1522">1522</span>
<span id="1523">1523</span>
<span id="1524">1524</span>
<span id="1525">1525</span>
<span id="1526">1526</span>
<span id="1527">1527</span>
<span id="1528">1528</span>
<span id="1529">1529</span>
<span id="1530">1530</span>
<span id="1531">1531</span>
<span id="1532">1532</span>
<span id="1533">1533</span>
<span id="1534">1534</span>
<span id="1535">1535</span>
<span id="1536">1536</span>
<span id="1537">1537</span>
<span id="1538">1538</span>
<span id="1539">1539</span>
<span id="1540">1540</span>
<span id="1541">1541</span>
<span id="1542">1542</span>
<span id="1543">1543</span>
<span id="1544">1544</span>
<span id="1545">1545</span>
<span id="1546">1546</span>
<span id="1547">1547</span>
<span id="1548">1548</span>
<span id="1549">1549</span>
<span id="1550">1550</span>
<span id="1551">1551</span>
<span id="1552">1552</span>
<span id="1553">1553</span>
<span id="1554">1554</span>
<span id="1555">1555</span>
<span id="1556">1556</span>
<span id="1557">1557</span>
<span id="1558">1558</span>
<span id="1559">1559</span>
<span id="1560">1560</span>
<span id="1561">1561</span>
<span id="1562">1562</span>
<span id="1563">1563</span>
<span id="1564">1564</span>
<span id="1565">1565</span>
<span id="1566">1566</span>
<span id="1567">1567</span>
<span id="1568">1568</span>
<span id="1569">1569</span>
<span id="1570">1570</span>
<span id="1571">1571</span>
<span id="1572">1572</span>
<span id="1573">1573</span>
<span id="1574">1574</span>
<span id="1575">1575</span>
<span id="1576">1576</span>
<span id="1577">1577</span>
<span id="1578">1578</span>
<span id="1579">1579</span>
<span id="1580">1580</span>
<span id="1581">1581</span>
<span id="1582">1582</span>
<span id="1583">1583</span>
<span id="1584">1584</span>
<span id="1585">1585</span>
<span id="1586">1586</span>
<span id="1587">1587</span>
<span id="1588">1588</span>
<span id="1589">1589</span>
<span id="1590">1590</span>
<span id="1591">1591</span>
<span id="1592">1592</span>
<span id="1593">1593</span>
<span id="1594">1594</span>
<span id="1595">1595</span>
<span id="1596">1596</span>
<span id="1597">1597</span>
<span id="1598">1598</span>
<span id="1599">1599</span>
<span id="1600">1600</span>
<span id="1601">1601</span>
<span id="1602">1602</span>
<span id="1603">1603</span>
<span id="1604">1604</span>
<span id="1605">1605</span>
<span id="1606">1606</span>
<span id="1607">1607</span>
<span id="1608">1608</span>
<span id="1609">1609</span>
<span id="1610">1610</span>
<span id="1611">1611</span>
<span id="1612">1612</span>
<span id="1613">1613</span>
<span id="1614">1614</span>
<span id="1615">1615</span>
<span id="1616">1616</span>
<span id="1617">1617</span>
<span id="1618">1618</span>
<span id="1619">1619</span>
<span id="1620">1620</span>
<span id="1621">1621</span>
<span id="1622">1622</span>
<span id="1623">1623</span>
<span id="1624">1624</span>
<span id="1625">1625</span>
<span id="1626">1626</span>
<span id="1627">1627</span>
<span id="1628">1628</span>
<span id="1629">1629</span>
<span id="1630">1630</span>
<span id="1631">1631</span>
<span id="1632">1632</span>
<span id="1633">1633</span>
<span id="1634">1634</span>
<span id="1635">1635</span>
<span id="1636">1636</span>
<span id="1637">1637</span>
<span id="1638">1638</span>
<span id="1639">1639</span>
<span id="1640">1640</span>
<span id="1641">1641</span>
<span id="1642">1642</span>
<span id="1643">1643</span>
<span id="1644">1644</span>
<span id="1645">1645</span>
<span id="1646">1646</span>
<span id="1647">1647</span>
<span id="1648">1648</span>
<span id="1649">1649</span>
<span id="1650">1650</span>
<span id="1651">1651</span>
<span id="1652">1652</span>
<span id="1653">1653</span>
<span id="1654">1654</span>
<span id="1655">1655</span>
<span id="1656">1656</span>
<span id="1657">1657</span>
<span id="1658">1658</span>
<span id="1659">1659</span>
<span id="1660">1660</span>
<span id="1661">1661</span>
<span id="1662">1662</span>
<span id="1663">1663</span>
<span id="1664">1664</span>
<span id="1665">1665</span>
<span id="1666">1666</span>
<span id="1667">1667</span>
<span id="1668">1668</span>
<span id="1669">1669</span>
<span id="1670">1670</span>
<span id="1671">1671</span>
<span id="1672">1672</span>
<span id="1673">1673</span>
<span id="1674">1674</span>
<span id="1675">1675</span>
<span id="1676">1676</span>
<span id="1677">1677</span>
<span id="1678">1678</span>
<span id="1679">1679</span>
<span id="1680">1680</span>
<span id="1681">1681</span>
<span id="1682">1682</span>
<span id="1683">1683</span>
<span id="1684">1684</span>
<span id="1685">1685</span>
<span id="1686">1686</span>
<span id="1687">1687</span>
<span id="1688">1688</span>
<span id="1689">1689</span>
<span id="1690">1690</span>
<span id="1691">1691</span>
<span id="1692">1692</span>
<span id="1693">1693</span>
<span id="1694">1694</span>
<span id="1695">1695</span>
<span id="1696">1696</span>
<span id="1697">1697</span>
<span id="1698">1698</span>
<span id="1699">1699</span>
<span id="1700">1700</span>
<span id="1701">1701</span>
<span id="1702">1702</span>
<span id="1703">1703</span>
<span id="1704">1704</span>
<span id="1705">1705</span>
<span id="1706">1706</span>
<span id="1707">1707</span>
<span id="1708">1708</span>
<span id="1709">1709</span>
<span id="1710">1710</span>
<span id="1711">1711</span>
<span id="1712">1712</span>
<span id="1713">1713</span>
<span id="1714">1714</span>
<span id="1715">1715</span>
<span id="1716">1716</span>
<span id="1717">1717</span>
<span id="1718">1718</span>
<span id="1719">1719</span>
<span id="1720">1720</span>
<span id="1721">1721</span>
<span id="1722">1722</span>
<span id="1723">1723</span>
<span id="1724">1724</span>
<span id="1725">1725</span>
<span id="1726">1726</span>
<span id="1727">1727</span>
<span id="1728">1728</span>
<span id="1729">1729</span>
<span id="1730">1730</span>
<span id="1731">1731</span>
<span id="1732">1732</span>
<span id="1733">1733</span>
<span id="1734">1734</span>
<span id="1735">1735</span>
<span id="1736">1736</span>
<span id="1737">1737</span>
<span id="1738">1738</span>
<span id="1739">1739</span>
<span id="1740">1740</span>
<span id="1741">1741</span>
<span id="1742">1742</span>
<span id="1743">1743</span>
<span id="1744">1744</span>
<span id="1745">1745</span>
<span id="1746">1746</span>
<span id="1747">1747</span>
<span id="1748">1748</span>
<span id="1749">1749</span>
<span id="1750">1750</span>
<span id="1751">1751</span>
<span id="1752">1752</span>
<span id="1753">1753</span>
<span id="1754">1754</span>
<span id="1755">1755</span>
<span id="1756">1756</span>
<span id="1757">1757</span>
<span id="1758">1758</span>
<span id="1759">1759</span>
<span id="1760">1760</span>
<span id="1761">1761</span>
<span id="1762">1762</span>
<span id="1763">1763</span>
<span id="1764">1764</span>
<span id="1765">1765</span>
<span id="1766">1766</span>
<span id="1767">1767</span>
<span id="1768">1768</span>
<span id="1769">1769</span>
<span id="1770">1770</span>
<span id="1771">1771</span>
<span id="1772">1772</span>
<span id="1773">1773</span>
<span id="1774">1774</span>
<span id="1775">1775</span>
<span id="1776">1776</span>
<span id="1777">1777</span>
<span id="1778">1778</span>
<span id="1779">1779</span>
<span id="1780">1780</span>
<span id="1781">1781</span>
<span id="1782">1782</span>
<span id="1783">1783</span>
<span id="1784">1784</span>
<span id="1785">1785</span>
<span id="1786">1786</span>
<span id="1787">1787</span>
<span id="1788">1788</span>
<span id="1789">1789</span>
<span id="1790">1790</span>
<span id="1791">1791</span>
<span id="1792">1792</span>
<span id="1793">1793</span>
<span id="1794">1794</span>
<span id="1795">1795</span>
<span id="1796">1796</span>
<span id="1797">1797</span>
<span id="1798">1798</span>
<span id="1799">1799</span>
<span id="1800">1800</span>
<span id="1801">1801</span>
<span id="1802">1802</span>
<span id="1803">1803</span>
<span id="1804">1804</span>
<span id="1805">1805</span>
<span id="1806">1806</span>
<span id="1807">1807</span>
<span id="1808">1808</span>
<span id="1809">1809</span>
<span id="1810">1810</span>
<span id="1811">1811</span>
<span id="1812">1812</span>
<span id="1813">1813</span>
<span id="1814">1814</span>
<span id="1815">1815</span>
<span id="1816">1816</span>
<span id="1817">1817</span>
<span id="1818">1818</span>
<span id="1819">1819</span>
<span id="1820">1820</span>
<span id="1821">1821</span>
<span id="1822">1822</span>
<span id="1823">1823</span>
<span id="1824">1824</span>
<span id="1825">1825</span>
<span id="1826">1826</span>
<span id="1827">1827</span>
<span id="1828">1828</span>
<span id="1829">1829</span>
<span id="1830">1830</span>
<span id="1831">1831</span>
<span id="1832">1832</span>
<span id="1833">1833</span>
<span id="1834">1834</span>
<span id="1835">1835</span>
<span id="1836">1836</span>
<span id="1837">1837</span>
<span id="1838">1838</span>
<span id="1839">1839</span>
<span id="1840">1840</span>
<span id="1841">1841</span>
<span id="1842">1842</span>
<span id="1843">1843</span>
<span id="1844">1844</span>
<span id="1845">1845</span>
<span id="1846">1846</span>
<span id="1847">1847</span>
<span id="1848">1848</span>
<span id="1849">1849</span>
<span id="1850">1850</span>
<span id="1851">1851</span>
<span id="1852">1852</span>
<span id="1853">1853</span>
<span id="1854">1854</span>
<span id="1855">1855</span>
<span id="1856">1856</span>
<span id="1857">1857</span>
<span id="1858">1858</span>
<span id="1859">1859</span>
<span id="1860">1860</span>
<span id="1861">1861</span>
<span id="1862">1862</span>
<span id="1863">1863</span>
<span id="1864">1864</span>
<span id="1865">1865</span>
<span id="1866">1866</span>
<span id="1867">1867</span>
<span id="1868">1868</span>
<span id="1869">1869</span>
<span id="1870">1870</span>
<span id="1871">1871</span>
<span id="1872">1872</span>
<span id="1873">1873</span>
<span id="1874">1874</span>
<span id="1875">1875</span>
<span id="1876">1876</span>
<span id="1877">1877</span>
<span id="1878">1878</span>
<span id="1879">1879</span>
<span id="1880">1880</span>
<span id="1881">1881</span>
<span id="1882">1882</span>
<span id="1883">1883</span>
<span id="1884">1884</span>
<span id="1885">1885</span>
<span id="1886">1886</span>
<span id="1887">1887</span>
<span id="1888">1888</span>
<span id="1889">1889</span>
<span id="1890">1890</span>
<span id="1891">1891</span>
<span id="1892">1892</span>
<span id="1893">1893</span>
<span id="1894">1894</span>
<span id="1895">1895</span>
<span id="1896">1896</span>
<span id="1897">1897</span>
<span id="1898">1898</span>
<span id="1899">1899</span>
<span id="1900">1900</span>
<span id="1901">1901</span>
<span id="1902">1902</span>
<span id="1903">1903</span>
<span id="1904">1904</span>
<span id="1905">1905</span>
<span id="1906">1906</span>
<span id="1907">1907</span>
<span id="1908">1908</span>
<span id="1909">1909</span>
<span id="1910">1910</span>
<span id="1911">1911</span>
<span id="1912">1912</span>
<span id="1913">1913</span>
<span id="1914">1914</span>
<span id="1915">1915</span>
<span id="1916">1916</span>
<span id="1917">1917</span>
<span id="1918">1918</span>
<span id="1919">1919</span>
<span id="1920">1920</span>
<span id="1921">1921</span>
<span id="1922">1922</span>
<span id="1923">1923</span>
<span id="1924">1924</span>
<span id="1925">1925</span>
<span id="1926">1926</span>
<span id="1927">1927</span>
<span id="1928">1928</span>
<span id="1929">1929</span>
<span id="1930">1930</span>
<span id="1931">1931</span>
<span id="1932">1932</span>
<span id="1933">1933</span>
<span id="1934">1934</span>
<span id="1935">1935</span>
<span id="1936">1936</span>
<span id="1937">1937</span>
<span id="1938">1938</span>
<span id="1939">1939</span>
<span id="1940">1940</span>
<span id="1941">1941</span>
<span id="1942">1942</span>
<span id="1943">1943</span>
<span id="1944">1944</span>
<span id="1945">1945</span>
<span id="1946">1946</span>
<span id="1947">1947</span>
<span id="1948">1948</span>
<span id="1949">1949</span>
<span id="1950">1950</span>
<span id="1951">1951</span>
<span id="1952">1952</span>
<span id="1953">1953</span>
<span id="1954">1954</span>
<span id="1955">1955</span>
<span id="1956">1956</span>
<span id="1957">1957</span>
<span id="1958">1958</span>
<span id="1959">1959</span>
<span id="1960">1960</span>
<span id="1961">1961</span>
<span id="1962">1962</span>
<span id="1963">1963</span>
<span id="1964">1964</span>
<span id="1965">1965</span>
<span id="1966">1966</span>
<span id="1967">1967</span>
<span id="1968">1968</span>
<span id="1969">1969</span>
<span id="1970">1970</span>
<span id="1971">1971</span>
<span id="1972">1972</span>
<span id="1973">1973</span>
<span id="1974">1974</span>
<span id="1975">1975</span>
<span id="1976">1976</span>
<span id="1977">1977</span>
<span id="1978">1978</span>
<span id="1979">1979</span>
<span id="1980">1980</span>
<span id="1981">1981</span>
<span id="1982">1982</span>
<span id="1983">1983</span>
<span id="1984">1984</span>
<span id="1985">1985</span>
<span id="1986">1986</span>
<span id="1987">1987</span>
<span id="1988">1988</span>
<span id="1989">1989</span>
<span id="1990">1990</span>
<span id="1991">1991</span>
<span id="1992">1992</span>
<span id="1993">1993</span>
<span id="1994">1994</span>
<span id="1995">1995</span>
<span id="1996">1996</span>
<span id="1997">1997</span>
<span id="1998">1998</span>
<span id="1999">1999</span>
<span id="2000">2000</span>
<span id="2001">2001</span>
<span id="2002">2002</span>
<span id="2003">2003</span>
<span id="2004">2004</span>
<span id="2005">2005</span>
<span id="2006">2006</span>
<span id="2007">2007</span>
<span id="2008">2008</span>
<span id="2009">2009</span>
<span id="2010">2010</span>
<span id="2011">2011</span>
<span id="2012">2012</span>
<span id="2013">2013</span>
<span id="2014">2014</span>
<span id="2015">2015</span>
<span id="2016">2016</span>
<span id="2017">2017</span>
<span id="2018">2018</span>
<span id="2019">2019</span>
<span id="2020">2020</span>
<span id="2021">2021</span>
<span id="2022">2022</span>
<span id="2023">2023</span>
<span id="2024">2024</span>
<span id="2025">2025</span>
<span id="2026">2026</span>
<span id="2027">2027</span>
<span id="2028">2028</span>
<span id="2029">2029</span>
<span id="2030">2030</span>
<span id="2031">2031</span>
<span id="2032">2032</span>
<span id="2033">2033</span>
<span id="2034">2034</span>
<span id="2035">2035</span>
<span id="2036">2036</span>
<span id="2037">2037</span>
<span id="2038">2038</span>
<span id="2039">2039</span>
<span id="2040">2040</span>
<span id="2041">2041</span>
<span id="2042">2042</span>
<span id="2043">2043</span>
<span id="2044">2044</span>
<span id="2045">2045</span>
<span id="2046">2046</span>
<span id="2047">2047</span>
<span id="2048">2048</span>
<span id="2049">2049</span>
<span id="2050">2050</span>
<span id="2051">2051</span>
<span id="2052">2052</span>
<span id="2053">2053</span>
<span id="2054">2054</span>
<span id="2055">2055</span>
<span id="2056">2056</span>
<span id="2057">2057</span>
<span id="2058">2058</span>
<span id="2059">2059</span>
<span id="2060">2060</span>
<span id="2061">2061</span>
<span id="2062">2062</span>
<span id="2063">2063</span>
<span id="2064">2064</span>
<span id="2065">2065</span>
<span id="2066">2066</span>
<span id="2067">2067</span>
<span id="2068">2068</span>
<span id="2069">2069</span>
<span id="2070">2070</span>
<span id="2071">2071</span>
<span id="2072">2072</span>
<span id="2073">2073</span>
<span id="2074">2074</span>
<span id="2075">2075</span>
<span id="2076">2076</span>
<span id="2077">2077</span>
<span id="2078">2078</span>
<span id="2079">2079</span>
<span id="2080">2080</span>
<span id="2081">2081</span>
<span id="2082">2082</span>
<span id="2083">2083</span>
<span id="2084">2084</span>
<span id="2085">2085</span>
<span id="2086">2086</span>
<span id="2087">2087</span>
<span id="2088">2088</span>
<span id="2089">2089</span>
<span id="2090">2090</span>
<span id="2091">2091</span>
<span id="2092">2092</span>
<span id="2093">2093</span>
<span id="2094">2094</span>
<span id="2095">2095</span>
<span id="2096">2096</span>
<span id="2097">2097</span>
<span id="2098">2098</span>
<span id="2099">2099</span>
<span id="2100">2100</span>
<span id="2101">2101</span>
<span id="2102">2102</span>
<span id="2103">2103</span>
<span id="2104">2104</span>
<span id="2105">2105</span>
<span id="2106">2106</span>
<span id="2107">2107</span>
<span id="2108">2108</span>
<span id="2109">2109</span>
<span id="2110">2110</span>
<span id="2111">2111</span>
<span id="2112">2112</span>
<span id="2113">2113</span>
<span id="2114">2114</span>
<span id="2115">2115</span>
<span id="2116">2116</span>
<span id="2117">2117</span>
<span id="2118">2118</span>
<span id="2119">2119</span>
<span id="2120">2120</span>
<span id="2121">2121</span>
</pre><pre class="rust ">
<span class="comment">// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT</span>
<span class="comment">// file at the top-level directory of this distribution and at</span>
<span class="comment">// http://rust-lang.org/COPYRIGHT.</span>
<span class="comment">//</span>
<span class="comment">// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or</span>
<span class="comment">// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license</span>
<span class="comment">// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your</span>
<span class="comment">// option. This file may not be copied, modified, or distributed</span>
<span class="comment">// except according to those terms.</span>
<span class="doccomment">//! Support code for rustc's built in unit-test and micro-benchmarking</span>
<span class="doccomment">//! framework.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Almost all user code will only be interested in `Bencher` and</span>
<span class="doccomment">//! `black_box`. All other interactions (such as writing tests and</span>
<span class="doccomment">//! benchmarks themselves) should be done via the `#[test]` and</span>
<span class="doccomment">//! `#[bench]` attributes.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! See the [Testing Chapter](../book/first-edition/testing.html) of the book for more details.</span>
<span class="comment">// Currently, not much of this is meant for users. It is intended to</span>
<span class="comment">// support the simplest interface possible for representing and</span>
<span class="comment">// running tests while providing a base that other test frameworks may</span>
<span class="comment">// build off of.</span>
<span class="comment">// NB: this is also specified in this crate's Cargo.toml, but libsyntax contains logic specific to</span>
<span class="comment">// this crate, which relies on this attribute (rather than the value of `--crate-name` passed by</span>
<span class="comment">// cargo) to detect this crate.</span>
<span class="attribute">#![<span class="ident">crate_name</span> <span class="op">=</span> <span class="string">"test"</span>]</span>
<span class="attribute">#![<span class="ident">unstable</span>(<span class="ident">feature</span> <span class="op">=</span> <span class="string">"test"</span>, <span class="ident">issue</span> <span class="op">=</span> <span class="string">"27812"</span>)]</span>
<span class="attribute">#![<span class="ident">doc</span>(<span class="ident">html_logo_url</span> <span class="op">=</span> <span class="string">"https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png"</span>,
<span class="ident">html_favicon_url</span> <span class="op">=</span> <span class="string">"https://doc.rust-lang.org/favicon.ico"</span>,
<span class="ident">html_root_url</span> <span class="op">=</span> <span class="string">"https://doc.rust-lang.org/nightly/"</span>, <span class="ident">test</span>(<span class="ident">attr</span>(<span class="ident">deny</span>(<span class="ident">warnings</span>))))]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">asm</span>)]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">fnbox</span>)]</span>
<span class="attribute">#![<span class="ident">cfg_attr</span>(<span class="ident">any</span>(<span class="ident">unix</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"cloudabi"</span>), <span class="ident">feature</span>(<span class="ident">libc</span>))]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">set_stdio</span>)]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">panic_unwind</span>)]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">staged_api</span>)]</span>
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">termination_trait_lib</span>)]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">getopts</span>;
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">unix</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"cloudabi"</span>))]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">libc</span>;
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">panic_unwind</span>;
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">term</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">TestFn</span>::<span class="kw-2">*</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">ColorConfig</span>::<span class="kw-2">*</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">TestResult</span>::<span class="kw-2">*</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="self">self</span>::<span class="ident">TestName</span>::<span class="kw-2">*</span>;
<span class="kw">use</span> <span class="self">self</span>::<span class="ident">TestEvent</span>::<span class="kw-2">*</span>;
<span class="kw">use</span> <span class="self">self</span>::<span class="ident">NamePadding</span>::<span class="kw-2">*</span>;
<span class="kw">use</span> <span class="self">self</span>::<span class="ident">OutputLocation</span>::<span class="kw-2">*</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">panic</span>::{<span class="ident">catch_unwind</span>, <span class="ident">AssertUnwindSafe</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">any</span>::<span class="ident">Any</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">boxed</span>::<span class="ident">FnBox</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">BTreeMap</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">env</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fs</span>::<span class="ident">File</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>::<span class="ident">prelude</span>::<span class="kw-2">*</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">iter</span>::<span class="ident">repeat</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">path</span>::<span class="ident">PathBuf</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Termination</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">mpsc</span>::{<span class="ident">channel</span>, <span class="ident">Sender</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::{<span class="ident">Arc</span>, <span class="ident">Mutex</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">thread</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::{<span class="ident">Duration</span>, <span class="ident">Instant</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">borrow</span>::<span class="ident">Cow</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>;
<span class="kw">const</span> <span class="ident">TEST_WARN_TIMEOUT_S</span>: <span class="ident">u64</span> <span class="op">=</span> <span class="number">60</span>;
<span class="kw">const</span> <span class="ident">QUIET_MODE_MAX_COLUMN</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">100</span>; <span class="comment">// insert a '\n' after 100 tests in quiet mode</span>
<span class="comment">// to be used by rustc to compile tests in libtest</span>
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">test</span> {
<span class="kw">pub</span> <span class="kw">use</span> {<span class="ident">assert_test_result</span>, <span class="ident">filter_tests</span>, <span class="ident">parse_opts</span>, <span class="ident">run_test</span>, <span class="ident">test_main</span>, <span class="ident">test_main_static</span>,
<span class="ident">Bencher</span>, <span class="ident">DynTestFn</span>, <span class="ident">DynTestName</span>, <span class="ident">Metric</span>, <span class="ident">MetricMap</span>, <span class="ident">Options</span>, <span class="ident">ShouldPanic</span>,
<span class="ident">StaticBenchFn</span>, <span class="ident">StaticTestFn</span>, <span class="ident">StaticTestName</span>, <span class="ident">TestDesc</span>, <span class="ident">TestDescAndFn</span>, <span class="ident">TestName</span>,
<span class="ident">TestOpts</span>, <span class="ident">TestResult</span>, <span class="ident">TrFailed</span>, <span class="ident">TrFailedMsg</span>, <span class="ident">TrIgnored</span>, <span class="ident">TrOk</span>};
}
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">stats</span>;
<span class="kw">mod</span> <span class="ident">formatters</span>;
<span class="kw">use</span> <span class="ident">formatters</span>::{<span class="ident">JsonFormatter</span>, <span class="ident">OutputFormatter</span>, <span class="ident">PrettyFormatter</span>, <span class="ident">TerseFormatter</span>};
<span class="comment">// The name of a test. By convention this follows the rules for rust</span>
<span class="comment">// paths; i.e. it should be a series of identifiers separated by double</span>
<span class="comment">// colons. This way if some test runner wants to arrange the tests</span>
<span class="comment">// hierarchically it may.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>, <span class="ident">Hash</span>, <span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">TestName</span> {
<span class="ident">StaticTestName</span>(<span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span>),
<span class="ident">DynTestName</span>(<span class="ident">String</span>),
<span class="ident">AlignedTestName</span>(<span class="ident">Cow</span><span class="op"><</span><span class="lifetime">'static</span>, <span class="ident">str</span><span class="op">></span>, <span class="ident">NamePadding</span>),
}
<span class="kw">impl</span> <span class="ident">TestName</span> {
<span class="kw">fn</span> <span class="ident">as_slice</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="kw-2">&</span><span class="ident">str</span> {
<span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
<span class="ident">StaticTestName</span>(<span class="ident">s</span>) <span class="op">=></span> <span class="ident">s</span>,
<span class="ident">DynTestName</span>(<span class="kw-2">ref</span> <span class="ident">s</span>) <span class="op">=></span> <span class="ident">s</span>,
<span class="ident">AlignedTestName</span>(<span class="kw-2">ref</span> <span class="ident">s</span>, <span class="kw">_</span>) <span class="op">=></span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="ident">s</span>,
}
}
<span class="kw">fn</span> <span class="ident">padding</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">NamePadding</span> {
<span class="kw">match</span> <span class="self">self</span> {
<span class="kw-2">&</span><span class="ident">AlignedTestName</span>(<span class="kw">_</span>, <span class="ident">p</span>) <span class="op">=></span> <span class="ident">p</span>,
<span class="kw">_</span> <span class="op">=></span> <span class="ident">PadNone</span>,
}
}
<span class="kw">fn</span> <span class="ident">with_padding</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">padding</span>: <span class="ident">NamePadding</span>) <span class="op">-></span> <span class="ident">TestName</span> {
<span class="kw">let</span> <span class="ident">name</span> <span class="op">=</span> <span class="kw">match</span> <span class="self">self</span> {
<span class="kw-2">&</span><span class="ident">TestName</span>::<span class="ident">StaticTestName</span>(<span class="ident">name</span>) <span class="op">=></span> <span class="ident">Cow</span>::<span class="ident">Borrowed</span>(<span class="ident">name</span>),
<span class="kw-2">&</span><span class="ident">TestName</span>::<span class="ident">DynTestName</span>(<span class="kw-2">ref</span> <span class="ident">name</span>) <span class="op">=></span> <span class="ident">Cow</span>::<span class="ident">Owned</span>(<span class="ident">name</span>.<span class="ident">clone</span>()),
<span class="kw-2">&</span><span class="ident">TestName</span>::<span class="ident">AlignedTestName</span>(<span class="kw-2">ref</span> <span class="ident">name</span>, <span class="kw">_</span>) <span class="op">=></span> <span class="ident">name</span>.<span class="ident">clone</span>(),
};
<span class="ident">TestName</span>::<span class="ident">AlignedTestName</span>(<span class="ident">name</span>, <span class="ident">padding</span>)
}
}
<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Display</span> <span class="kw">for</span> <span class="ident">TestName</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">fmt</span>::<span class="ident">Display</span>::<span class="ident">fmt</span>(<span class="self">self</span>.<span class="ident">as_slice</span>(), <span class="ident">f</span>)
}
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">Copy</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>, <span class="ident">Hash</span>, <span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">NamePadding</span> {
<span class="ident">PadNone</span>,
<span class="ident">PadOnRight</span>,
}
<span class="kw">impl</span> <span class="ident">TestDesc</span> {
<span class="kw">fn</span> <span class="ident">padded_name</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">column_count</span>: <span class="ident">usize</span>, <span class="ident">align</span>: <span class="ident">NamePadding</span>) <span class="op">-></span> <span class="ident">String</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">name</span> <span class="op">=</span> <span class="ident">String</span>::<span class="ident">from</span>(<span class="self">self</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>());
<span class="kw">let</span> <span class="ident">fill</span> <span class="op">=</span> <span class="ident">column_count</span>.<span class="ident">saturating_sub</span>(<span class="ident">name</span>.<span class="ident">len</span>());
<span class="kw">let</span> <span class="ident">pad</span> <span class="op">=</span> <span class="ident">repeat</span>(<span class="string">" "</span>).<span class="ident">take</span>(<span class="ident">fill</span>).<span class="ident">collect</span>::<span class="op"><</span><span class="ident">String</span><span class="op">></span>();
<span class="kw">match</span> <span class="ident">align</span> {
<span class="ident">PadNone</span> <span class="op">=></span> <span class="ident">name</span>,
<span class="ident">PadOnRight</span> <span class="op">=></span> {
<span class="ident">name</span>.<span class="ident">push_str</span>(<span class="kw-2">&</span><span class="ident">pad</span>);
<span class="ident">name</span>
}
}
}
}
<span class="doccomment">/// Represents a benchmark function.</span>
<span class="kw">pub</span> <span class="kw">trait</span> <span class="ident">TDynBenchFn</span>: <span class="ident">Send</span> {
<span class="kw">fn</span> <span class="ident">run</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">harness</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>);
}
<span class="comment">// A function that runs a test. If the function returns successfully,</span>
<span class="comment">// the test succeeds; if the function panics then the test fails. We</span>
<span class="comment">// may need to come up with a more clever definition of test in order</span>
<span class="comment">// to support isolation of tests into threads.</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">TestFn</span> {
<span class="ident">StaticTestFn</span>(<span class="kw">fn</span>()),
<span class="ident">StaticBenchFn</span>(<span class="kw">fn</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>)),
<span class="ident">DynTestFn</span>(<span class="ident">Box</span><span class="op"><</span><span class="ident">FnBox</span>() <span class="op">+</span> <span class="ident">Send</span><span class="op">></span>),
<span class="ident">DynBenchFn</span>(<span class="ident">Box</span><span class="op"><</span><span class="ident">TDynBenchFn</span> <span class="op">+</span> <span class="lifetime">'static</span><span class="op">></span>),
}
<span class="kw">impl</span> <span class="ident">TestFn</span> {
<span class="kw">fn</span> <span class="ident">padding</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">NamePadding</span> {
<span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
<span class="ident">StaticTestFn</span>(..) <span class="op">=></span> <span class="ident">PadNone</span>,
<span class="ident">StaticBenchFn</span>(..) <span class="op">=></span> <span class="ident">PadOnRight</span>,
<span class="ident">DynTestFn</span>(..) <span class="op">=></span> <span class="ident">PadNone</span>,
<span class="ident">DynBenchFn</span>(..) <span class="op">=></span> <span class="ident">PadOnRight</span>,
}
}
}
<span class="kw">impl</span> <span class="ident">fmt</span>::<span class="ident">Debug</span> <span class="kw">for</span> <span class="ident">TestFn</span> {
<span class="kw">fn</span> <span class="ident">fmt</span>(<span class="kw-2">&</span><span class="self">self</span>, <span class="ident">f</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">fmt</span>::<span class="ident">Formatter</span>) <span class="op">-></span> <span class="ident">fmt</span>::<span class="prelude-ty">Result</span> {
<span class="ident">f</span>.<span class="ident">write_str</span>(<span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
<span class="ident">StaticTestFn</span>(..) <span class="op">=></span> <span class="string">"StaticTestFn(..)"</span>,
<span class="ident">StaticBenchFn</span>(..) <span class="op">=></span> <span class="string">"StaticBenchFn(..)"</span>,
<span class="ident">DynTestFn</span>(..) <span class="op">=></span> <span class="string">"DynTestFn(..)"</span>,
<span class="ident">DynBenchFn</span>(..) <span class="op">=></span> <span class="string">"DynBenchFn(..)"</span>,
})
}
}
<span class="doccomment">/// Manager of the benchmarking runs.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This is fed into functions marked with `#[bench]` to allow for</span>
<span class="doccomment">/// set-up & tear-down before running a piece of code repeatedly via a</span>
<span class="doccomment">/// call to `iter`.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Bencher</span> {
<span class="ident">mode</span>: <span class="ident">BenchMode</span>,
<span class="ident">summary</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">stats</span>::<span class="ident">Summary</span><span class="op">></span>,
<span class="kw">pub</span> <span class="ident">bytes</span>: <span class="ident">u64</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">BenchMode</span> {
<span class="ident">Auto</span>,
<span class="ident">Single</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>, <span class="ident">Hash</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">ShouldPanic</span> {
<span class="ident">No</span>,
<span class="ident">Yes</span>,
<span class="ident">YesWithMessage</span>(<span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span>),
}
<span class="comment">// The definition of a single test. A test runner will run a list of</span>
<span class="comment">// these.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>, <span class="ident">Hash</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TestDesc</span> {
<span class="kw">pub</span> <span class="ident">name</span>: <span class="ident">TestName</span>,
<span class="kw">pub</span> <span class="ident">ignore</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>,
<span class="kw">pub</span> <span class="ident">allow_fail</span>: <span class="ident">bool</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TestDescAndFn</span> {
<span class="kw">pub</span> <span class="ident">desc</span>: <span class="ident">TestDesc</span>,
<span class="kw">pub</span> <span class="ident">testfn</span>: <span class="ident">TestFn</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>, <span class="ident">Debug</span>, <span class="ident">Copy</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Metric</span> {
<span class="ident">value</span>: <span class="ident">f64</span>,
<span class="ident">noise</span>: <span class="ident">f64</span>,
}
<span class="kw">impl</span> <span class="ident">Metric</span> {
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">value</span>: <span class="ident">f64</span>, <span class="ident">noise</span>: <span class="ident">f64</span>) <span class="op">-></span> <span class="ident">Metric</span> {
<span class="ident">Metric</span> { <span class="ident">value</span>, <span class="ident">noise</span> }
}
}
<span class="doccomment">/// In case we want to add other options as well, just add them in this struct.</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">Options</span> {
<span class="ident">display_output</span>: <span class="ident">bool</span>,
}
<span class="kw">impl</span> <span class="ident">Options</span> {
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">Options</span> {
<span class="ident">Options</span> {
<span class="ident">display_output</span>: <span class="bool-val">false</span>,
}
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">display_output</span>(<span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">display_output</span>: <span class="ident">bool</span>) <span class="op">-></span> <span class="ident">Options</span> {
<span class="self">self</span>.<span class="ident">display_output</span> <span class="op">=</span> <span class="ident">display_output</span>;
<span class="self">self</span>
}
}
<span class="comment">// The default console test runner. It accepts the command line</span>
<span class="comment">// arguments and a vector of test_descs.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_main</span>(<span class="ident">args</span>: <span class="kw-2">&</span>[<span class="ident">String</span>], <span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>, <span class="ident">options</span>: <span class="ident">Options</span>) {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">opts</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">parse_opts</span>(<span class="ident">args</span>) {
<span class="prelude-val">Some</span>(<span class="prelude-val">Ok</span>(<span class="ident">o</span>)) <span class="op">=></span> <span class="ident">o</span>,
<span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="ident">msg</span>)) <span class="op">=></span> {
<span class="macro">eprintln</span><span class="macro">!</span>(<span class="string">"error: {}"</span>, <span class="ident">msg</span>);
<span class="ident">process</span>::<span class="ident">exit</span>(<span class="number">101</span>);
}
<span class="prelude-val">None</span> <span class="op">=></span> <span class="kw">return</span>,
};
<span class="ident">opts</span>.<span class="ident">options</span> <span class="op">=</span> <span class="ident">options</span>;
<span class="kw">if</span> <span class="ident">opts</span>.<span class="ident">list</span> {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=</span> <span class="ident">list_tests_console</span>(<span class="kw-2">&</span><span class="ident">opts</span>, <span class="ident">tests</span>) {
<span class="macro">eprintln</span><span class="macro">!</span>(<span class="string">"error: io error when listing tests: {:?}"</span>, <span class="ident">e</span>);
<span class="ident">process</span>::<span class="ident">exit</span>(<span class="number">101</span>);
}
} <span class="kw">else</span> {
<span class="kw">match</span> <span class="ident">run_tests_console</span>(<span class="kw-2">&</span><span class="ident">opts</span>, <span class="ident">tests</span>) {
<span class="prelude-val">Ok</span>(<span class="bool-val">true</span>) <span class="op">=></span> {}
<span class="prelude-val">Ok</span>(<span class="bool-val">false</span>) <span class="op">=></span> <span class="ident">process</span>::<span class="ident">exit</span>(<span class="number">101</span>),
<span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
<span class="macro">eprintln</span><span class="macro">!</span>(<span class="string">"error: io error when listing tests: {:?}"</span>, <span class="ident">e</span>);
<span class="ident">process</span>::<span class="ident">exit</span>(<span class="number">101</span>);
}
}
}
}
<span class="comment">// A variant optimized for invocation with a static test vector.</span>
<span class="comment">// This will panic (intentionally) when fed any dynamic tests, because</span>
<span class="comment">// it is copying the static values out into a dynamic vector and cannot</span>
<span class="comment">// copy dynamic values. It is doing this because from this point on</span>
<span class="comment">// a Vec<TestDescAndFn> is used in order to effect ownership-transfer</span>
<span class="comment">// semantics into parallel test runners, which in turn requires a Vec<></span>
<span class="comment">// rather than a &[].</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_main_static</span>(<span class="ident">tests</span>: <span class="kw-2">&</span>[<span class="ident">TestDescAndFn</span>]) {
<span class="kw">let</span> <span class="ident">args</span> <span class="op">=</span> <span class="ident">env</span>::<span class="ident">args</span>().<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="kw">_</span><span class="op">>></span>();
<span class="kw">let</span> <span class="ident">owned_tests</span> <span class="op">=</span> <span class="ident">tests</span>
.<span class="ident">iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> <span class="kw">match</span> <span class="ident">t</span>.<span class="ident">testfn</span> {
<span class="ident">StaticTestFn</span>(<span class="ident">f</span>) <span class="op">=></span> <span class="ident">TestDescAndFn</span> {
<span class="ident">testfn</span>: <span class="ident">StaticTestFn</span>(<span class="ident">f</span>),
<span class="ident">desc</span>: <span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">clone</span>(),
},
<span class="ident">StaticBenchFn</span>(<span class="ident">f</span>) <span class="op">=></span> <span class="ident">TestDescAndFn</span> {
<span class="ident">testfn</span>: <span class="ident">StaticBenchFn</span>(<span class="ident">f</span>),
<span class="ident">desc</span>: <span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">clone</span>(),
},
<span class="kw">_</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"non-static tests passed to test::test_main_static"</span>),
})
.<span class="ident">collect</span>();
<span class="ident">test_main</span>(<span class="kw-2">&</span><span class="ident">args</span>, <span class="ident">owned_tests</span>, <span class="ident">Options</span>::<span class="ident">new</span>())
}
<span class="doccomment">/// Invoked when unit tests terminate. Should panic if the unit</span>
<span class="doccomment">/// test is considered a failure. By default, invokes `report()`</span>
<span class="doccomment">/// and checks for a `0` result.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">assert_test_result</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Termination</span><span class="op">></span>(<span class="ident">result</span>: <span class="ident">T</span>) {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">result</span>.<span class="ident">report</span>(), <span class="number">0</span>);
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">ColorConfig</span> {
<span class="ident">AutoColor</span>,
<span class="ident">AlwaysColor</span>,
<span class="ident">NeverColor</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Copy</span>, <span class="ident">Clone</span>, <span class="ident">Debug</span>, <span class="ident">PartialEq</span>, <span class="ident">Eq</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">OutputFormat</span> {
<span class="ident">Pretty</span>,
<span class="ident">Terse</span>,
<span class="ident">Json</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">TestOpts</span> {
<span class="kw">pub</span> <span class="ident">list</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">filter</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">String</span><span class="op">></span>,
<span class="kw">pub</span> <span class="ident">filter_exact</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">run_ignored</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">run_tests</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">bench_benchmarks</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">logfile</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">PathBuf</span><span class="op">></span>,
<span class="kw">pub</span> <span class="ident">nocapture</span>: <span class="ident">bool</span>,
<span class="kw">pub</span> <span class="ident">color</span>: <span class="ident">ColorConfig</span>,
<span class="kw">pub</span> <span class="ident">format</span>: <span class="ident">OutputFormat</span>,
<span class="kw">pub</span> <span class="ident">test_threads</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span>,
<span class="kw">pub</span> <span class="ident">skip</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">String</span><span class="op">></span>,
<span class="kw">pub</span> <span class="ident">options</span>: <span class="ident">Options</span>,
}
<span class="kw">impl</span> <span class="ident">TestOpts</span> {
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">test</span>)]</span>
<span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">TestOpts</span> {
<span class="ident">TestOpts</span> {
<span class="ident">list</span>: <span class="bool-val">false</span>,
<span class="ident">filter</span>: <span class="prelude-val">None</span>,
<span class="ident">filter_exact</span>: <span class="bool-val">false</span>,
<span class="ident">run_ignored</span>: <span class="bool-val">false</span>,
<span class="ident">run_tests</span>: <span class="bool-val">false</span>,
<span class="ident">bench_benchmarks</span>: <span class="bool-val">false</span>,
<span class="ident">logfile</span>: <span class="prelude-val">None</span>,
<span class="ident">nocapture</span>: <span class="bool-val">false</span>,
<span class="ident">color</span>: <span class="ident">AutoColor</span>,
<span class="ident">format</span>: <span class="ident">OutputFormat</span>::<span class="ident">Pretty</span>,
<span class="ident">test_threads</span>: <span class="prelude-val">None</span>,
<span class="ident">skip</span>: <span class="macro">vec</span><span class="macro">!</span>[],
<span class="ident">options</span>: <span class="ident">Options</span>::<span class="ident">new</span>(),
}
}
}
<span class="doccomment">/// Result of parsing the options.</span>
<span class="kw">pub</span> <span class="kw">type</span> <span class="ident">OptRes</span> <span class="op">=</span> <span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">TestOpts</span>, <span class="ident">String</span><span class="op">></span>;
<span class="kw">fn</span> <span class="ident">optgroups</span>() <span class="op">-></span> <span class="ident">getopts</span>::<span class="ident">Options</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">opts</span> <span class="op">=</span> <span class="ident">getopts</span>::<span class="ident">Options</span>::<span class="ident">new</span>();
<span class="ident">opts</span>.<span class="ident">optflag</span>(<span class="string">""</span>, <span class="string">"ignored"</span>, <span class="string">"Run ignored tests"</span>)
.<span class="ident">optflag</span>(<span class="string">""</span>, <span class="string">"test"</span>, <span class="string">"Run tests and not benchmarks"</span>)
.<span class="ident">optflag</span>(<span class="string">""</span>, <span class="string">"bench"</span>, <span class="string">"Run benchmarks instead of tests"</span>)
.<span class="ident">optflag</span>(<span class="string">""</span>, <span class="string">"list"</span>, <span class="string">"List all tests and benchmarks"</span>)
.<span class="ident">optflag</span>(<span class="string">"h"</span>, <span class="string">"help"</span>, <span class="string">"Display this message (longer with --help)"</span>)
.<span class="ident">optopt</span>(
<span class="string">""</span>,
<span class="string">"logfile"</span>,
<span class="string">"Write logs to the specified file instead \
of stdout"</span>,
<span class="string">"PATH"</span>,
)
.<span class="ident">optflag</span>(
<span class="string">""</span>,
<span class="string">"nocapture"</span>,
<span class="string">"don't capture stdout/stderr of each \
task, allow printing directly"</span>,
)
.<span class="ident">optopt</span>(
<span class="string">""</span>,
<span class="string">"test-threads"</span>,
<span class="string">"Number of threads used for running tests \
in parallel"</span>,
<span class="string">"n_threads"</span>,
)
.<span class="ident">optmulti</span>(
<span class="string">""</span>,
<span class="string">"skip"</span>,
<span class="string">"Skip tests whose names contain FILTER (this flag can \
be used multiple times)"</span>,
<span class="string">"FILTER"</span>,
)
.<span class="ident">optflag</span>(
<span class="string">"q"</span>,
<span class="string">"quiet"</span>,
<span class="string">"Display one character per test instead of one line. \
Alias to --format=terse"</span>,
)
.<span class="ident">optflag</span>(
<span class="string">""</span>,
<span class="string">"exact"</span>,
<span class="string">"Exactly match filters rather than by substring"</span>,
)
.<span class="ident">optopt</span>(
<span class="string">""</span>,
<span class="string">"color"</span>,
<span class="string">"Configure coloring of output:
auto = colorize if stdout is a tty and tests are run on serially (default);
always = always colorize output;
never = never colorize output;"</span>,
<span class="string">"auto|always|never"</span>,
)
.<span class="ident">optopt</span>(
<span class="string">""</span>,
<span class="string">"format"</span>,
<span class="string">"Configure formatting of output:
pretty = Print verbose output;
terse = Display one character per test;
json = Output a json document"</span>,
<span class="string">"pretty|terse|json"</span>,
)
.<span class="ident">optopt</span>(
<span class="string">"Z"</span>,
<span class="string">""</span>,
<span class="string">"Enable nightly-only flags:
unstable-options = Allow use of experimental features"</span>,
<span class="string">"unstable-options"</span>,
);
<span class="kw">return</span> <span class="ident">opts</span>;
}
<span class="kw">fn</span> <span class="ident">usage</span>(<span class="ident">binary</span>: <span class="kw-2">&</span><span class="ident">str</span>, <span class="ident">options</span>: <span class="kw-2">&</span><span class="ident">getopts</span>::<span class="ident">Options</span>) {
<span class="kw">let</span> <span class="ident">message</span> <span class="op">=</span> <span class="macro">format</span><span class="macro">!</span>(<span class="string">"Usage: {} [OPTIONS] [FILTER]"</span>, <span class="ident">binary</span>);
<span class="macro">println</span><span class="macro">!</span>(
<span class="string">r#"{usage}
The FILTER string is tested against the name of all tests, and only those
tests whose names contain the filter are run.
By default, all tests are run in parallel. This can be altered with the
--test-threads flag or the RUST_TEST_THREADS environment variable when running
tests (set it to 1).
All tests have their standard output and standard error captured by default.
This can be overridden with the --nocapture flag or setting RUST_TEST_NOCAPTURE
environment variable to a value other than "0". Logging is not captured by default.
Test Attributes:
#[test] - Indicates a function is a test to be run. This function
takes no arguments.
#[bench] - Indicates a function is a benchmark to be run. This
function takes one argument (test::Bencher).
#[should_panic] - This function (also labeled with #[test]) will only pass if
the code causes a panic (an assertion failure or panic!)
A message may be provided, which the failure string must
contain: #[should_panic(expected = "foo")].
#[ignore] - When applied to a function which is already attributed as a
test, then the test runner will ignore these tests during
normal test runs. Running with --ignored will run these
tests."#</span>,
<span class="ident">usage</span> <span class="op">=</span> <span class="ident">options</span>.<span class="ident">usage</span>(<span class="kw-2">&</span><span class="ident">message</span>)
);
}
<span class="comment">// FIXME: Copied from libsyntax until linkage errors are resolved. Issue #47566</span>
<span class="kw">fn</span> <span class="ident">is_nightly</span>() <span class="op">-></span> <span class="ident">bool</span> {
<span class="comment">// Whether this is a feature-staged build, i.e. on the beta or stable channel</span>
<span class="kw">let</span> <span class="ident">disable_unstable_features</span> <span class="op">=</span> <span class="macro">option_env</span><span class="macro">!</span>(<span class="string">"CFG_DISABLE_UNSTABLE_FEATURES"</span>).<span class="ident">is_some</span>();
<span class="comment">// Whether we should enable unstable features for bootstrapping</span>
<span class="kw">let</span> <span class="ident">bootstrap</span> <span class="op">=</span> <span class="ident">env</span>::<span class="ident">var</span>(<span class="string">"RUSTC_BOOTSTRAP"</span>).<span class="ident">is_ok</span>();
<span class="ident">bootstrap</span> <span class="op">||</span> <span class="op">!</span><span class="ident">disable_unstable_features</span>
}
<span class="comment">// Parses command line arguments into test options</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">parse_opts</span>(<span class="ident">args</span>: <span class="kw-2">&</span>[<span class="ident">String</span>]) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">OptRes</span><span class="op">></span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">allow_unstable</span> <span class="op">=</span> <span class="bool-val">false</span>;
<span class="kw">let</span> <span class="ident">opts</span> <span class="op">=</span> <span class="ident">optgroups</span>();
<span class="kw">let</span> <span class="ident">args</span> <span class="op">=</span> <span class="ident">args</span>.<span class="ident">get</span>(<span class="number">1</span>..).<span class="ident">unwrap_or</span>(<span class="ident">args</span>);
<span class="kw">let</span> <span class="ident">matches</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">opts</span>.<span class="ident">parse</span>(<span class="ident">args</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">m</span>) <span class="op">=></span> <span class="ident">m</span>,
<span class="prelude-val">Err</span>(<span class="ident">f</span>) <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="ident">f</span>.<span class="ident">to_string</span>())),
};
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">opt</span>) <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_str</span>(<span class="string">"Z"</span>) {
<span class="kw">if</span> <span class="op">!</span><span class="ident">is_nightly</span>() {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(
<span class="string">"the option `Z` is only accepted on the nightly compiler"</span>.<span class="ident">into</span>(),
));
}
<span class="kw">match</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="ident">opt</span> {
<span class="string">"unstable-options"</span> <span class="op">=></span> {
<span class="ident">allow_unstable</span> <span class="op">=</span> <span class="bool-val">true</span>;
}
<span class="kw">_</span> <span class="op">=></span> {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="string">"Unrecognized option to `Z`"</span>.<span class="ident">into</span>()));
}
}
};
<span class="kw">if</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"h"</span>) {
<span class="ident">usage</span>(<span class="kw-2">&</span><span class="ident">args</span>[<span class="number">0</span>], <span class="kw-2">&</span><span class="ident">opts</span>);
<span class="kw">return</span> <span class="prelude-val">None</span>;
}
<span class="kw">let</span> <span class="ident">filter</span> <span class="op">=</span> <span class="kw">if</span> <span class="op">!</span><span class="ident">matches</span>.<span class="ident">free</span>.<span class="ident">is_empty</span>() {
<span class="prelude-val">Some</span>(<span class="ident">matches</span>.<span class="ident">free</span>[<span class="number">0</span>].<span class="ident">clone</span>())
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
};
<span class="kw">let</span> <span class="ident">run_ignored</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"ignored"</span>);
<span class="kw">let</span> <span class="ident">quiet</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"quiet"</span>);
<span class="kw">let</span> <span class="ident">exact</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"exact"</span>);
<span class="kw">let</span> <span class="ident">list</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"list"</span>);
<span class="kw">let</span> <span class="ident">logfile</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_str</span>(<span class="string">"logfile"</span>);
<span class="kw">let</span> <span class="ident">logfile</span> <span class="op">=</span> <span class="ident">logfile</span>.<span class="ident">map</span>(<span class="op">|</span><span class="ident">s</span><span class="op">|</span> <span class="ident">PathBuf</span>::<span class="ident">from</span>(<span class="kw-2">&</span><span class="ident">s</span>));
<span class="kw">let</span> <span class="ident">bench_benchmarks</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"bench"</span>);
<span class="kw">let</span> <span class="ident">run_tests</span> <span class="op">=</span> <span class="op">!</span><span class="ident">bench_benchmarks</span> <span class="op">||</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"test"</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">nocapture</span> <span class="op">=</span> <span class="ident">matches</span>.<span class="ident">opt_present</span>(<span class="string">"nocapture"</span>);
<span class="kw">if</span> <span class="op">!</span><span class="ident">nocapture</span> {
<span class="ident">nocapture</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">env</span>::<span class="ident">var</span>(<span class="string">"RUST_TEST_NOCAPTURE"</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">val</span>) <span class="op">=></span> <span class="kw-2">&</span><span class="ident">val</span> <span class="op">!=</span> <span class="string">"0"</span>,
<span class="prelude-val">Err</span>(<span class="kw">_</span>) <span class="op">=></span> <span class="bool-val">false</span>,
};
}
<span class="kw">let</span> <span class="ident">test_threads</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">matches</span>.<span class="ident">opt_str</span>(<span class="string">"test-threads"</span>) {
<span class="prelude-val">Some</span>(<span class="ident">n_str</span>) <span class="op">=></span> <span class="kw">match</span> <span class="ident">n_str</span>.<span class="ident">parse</span>::<span class="op"><</span><span class="ident">usize</span><span class="op">></span>() {
<span class="prelude-val">Ok</span>(<span class="number">0</span>) <span class="op">=></span> <span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="macro">format</span><span class="macro">!</span>(<span class="string">"argument for --test-threads must not be 0"</span>))),
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) <span class="op">=></span> <span class="prelude-val">Some</span>(<span class="ident">n</span>),
<span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=></span> {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="macro">format</span><span class="macro">!</span>(
<span class="string">"argument for --test-threads must be a number > 0 \
(error: {})"</span>,
<span class="ident">e</span>
)))
}
},
<span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">None</span>,
};
<span class="kw">let</span> <span class="ident">color</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">matches</span>.<span class="ident">opt_str</span>(<span class="string">"color"</span>).<span class="ident">as_ref</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">s</span><span class="op">|</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="kw-2">*</span><span class="ident">s</span>) {
<span class="prelude-val">Some</span>(<span class="string">"auto"</span>) <span class="op">|</span> <span class="prelude-val">None</span> <span class="op">=></span> <span class="ident">AutoColor</span>,
<span class="prelude-val">Some</span>(<span class="string">"always"</span>) <span class="op">=></span> <span class="ident">AlwaysColor</span>,
<span class="prelude-val">Some</span>(<span class="string">"never"</span>) <span class="op">=></span> <span class="ident">NeverColor</span>,
<span class="prelude-val">Some</span>(<span class="ident">v</span>) <span class="op">=></span> {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="macro">format</span><span class="macro">!</span>(
<span class="string">"argument for --color must be auto, always, or never (was \
{})"</span>,
<span class="ident">v</span>
)))
}
};
<span class="kw">let</span> <span class="ident">format</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">matches</span>.<span class="ident">opt_str</span>(<span class="string">"format"</span>).<span class="ident">as_ref</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">s</span><span class="op">|</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="kw-2">*</span><span class="ident">s</span>) {
<span class="prelude-val">None</span> <span class="kw">if</span> <span class="ident">quiet</span> <span class="op">=></span> <span class="ident">OutputFormat</span>::<span class="ident">Terse</span>,
<span class="prelude-val">Some</span>(<span class="string">"pretty"</span>) <span class="op">|</span> <span class="prelude-val">None</span> <span class="op">=></span> <span class="ident">OutputFormat</span>::<span class="ident">Pretty</span>,
<span class="prelude-val">Some</span>(<span class="string">"terse"</span>) <span class="op">=></span> <span class="ident">OutputFormat</span>::<span class="ident">Terse</span>,
<span class="prelude-val">Some</span>(<span class="string">"json"</span>) <span class="op">=></span> {
<span class="kw">if</span> <span class="op">!</span><span class="ident">allow_unstable</span> {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(
<span class="string">"The \"json\" format is only accepted on the nightly compiler"</span>.<span class="ident">into</span>(),
));
}
<span class="ident">OutputFormat</span>::<span class="ident">Json</span>
}
<span class="prelude-val">Some</span>(<span class="ident">v</span>) <span class="op">=></span> {
<span class="kw">return</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Err</span>(<span class="macro">format</span><span class="macro">!</span>(
<span class="string">"argument for --format must be pretty, terse, or json (was \
{})"</span>,
<span class="ident">v</span>
)))
}
};
<span class="kw">let</span> <span class="ident">test_opts</span> <span class="op">=</span> <span class="ident">TestOpts</span> {
<span class="ident">list</span>,
<span class="ident">filter</span>,
<span class="ident">filter_exact</span>: <span class="ident">exact</span>,
<span class="ident">run_ignored</span>,
<span class="ident">run_tests</span>,
<span class="ident">bench_benchmarks</span>,
<span class="ident">logfile</span>,
<span class="ident">nocapture</span>,
<span class="ident">color</span>,
<span class="ident">format</span>,
<span class="ident">test_threads</span>,
<span class="ident">skip</span>: <span class="ident">matches</span>.<span class="ident">opt_strs</span>(<span class="string">"skip"</span>),
<span class="ident">options</span>: <span class="ident">Options</span>::<span class="ident">new</span>(),
};
<span class="prelude-val">Some</span>(<span class="prelude-val">Ok</span>(<span class="ident">test_opts</span>))
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">BenchSamples</span> {
<span class="ident">ns_iter_summ</span>: <span class="ident">stats</span>::<span class="ident">Summary</span>,
<span class="ident">mb_s</span>: <span class="ident">usize</span>,
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">TestResult</span> {
<span class="ident">TrOk</span>,
<span class="ident">TrFailed</span>,
<span class="ident">TrFailedMsg</span>(<span class="ident">String</span>),
<span class="ident">TrIgnored</span>,
<span class="ident">TrAllowedFail</span>,
<span class="ident">TrBench</span>(<span class="ident">BenchSamples</span>),
}
<span class="kw">unsafe</span> <span class="kw">impl</span> <span class="ident">Send</span> <span class="kw">for</span> <span class="ident">TestResult</span> {}
<span class="kw">enum</span> <span class="ident">OutputLocation</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
<span class="ident">Pretty</span>(<span class="ident">Box</span><span class="op"><</span><span class="ident">term</span>::<span class="ident">StdoutTerminal</span><span class="op">></span>),
<span class="ident">Raw</span>(<span class="ident">T</span>),
}
<span class="kw">impl</span><span class="op"><</span><span class="ident">T</span>: <span class="ident">Write</span><span class="op">></span> <span class="ident">Write</span> <span class="kw">for</span> <span class="ident">OutputLocation</span><span class="op"><</span><span class="ident">T</span><span class="op">></span> {
<span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">buf</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
<span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
<span class="ident">Pretty</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">term</span>) <span class="op">=></span> <span class="ident">term</span>.<span class="ident">write</span>(<span class="ident">buf</span>),
<span class="ident">Raw</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">stdout</span>) <span class="op">=></span> <span class="ident">stdout</span>.<span class="ident">write</span>(<span class="ident">buf</span>),
}
}
<span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="kw">match</span> <span class="kw-2">*</span><span class="self">self</span> {
<span class="ident">Pretty</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">term</span>) <span class="op">=></span> <span class="ident">term</span>.<span class="ident">flush</span>(),
<span class="ident">Raw</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">stdout</span>) <span class="op">=></span> <span class="ident">stdout</span>.<span class="ident">flush</span>(),
}
}
}
<span class="kw">struct</span> <span class="ident">ConsoleTestState</span> {
<span class="ident">log_out</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">File</span><span class="op">></span>,
<span class="ident">total</span>: <span class="ident">usize</span>,
<span class="ident">passed</span>: <span class="ident">usize</span>,
<span class="ident">failed</span>: <span class="ident">usize</span>,
<span class="ident">ignored</span>: <span class="ident">usize</span>,
<span class="ident">allowed_fail</span>: <span class="ident">usize</span>,
<span class="ident">filtered_out</span>: <span class="ident">usize</span>,
<span class="ident">measured</span>: <span class="ident">usize</span>,
<span class="ident">metrics</span>: <span class="ident">MetricMap</span>,
<span class="ident">failures</span>: <span class="ident">Vec</span><span class="op"><</span>(<span class="ident">TestDesc</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>)<span class="op">></span>,
<span class="ident">not_failures</span>: <span class="ident">Vec</span><span class="op"><</span>(<span class="ident">TestDesc</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>)<span class="op">></span>,
<span class="ident">options</span>: <span class="ident">Options</span>,
}
<span class="kw">impl</span> <span class="ident">ConsoleTestState</span> {
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">ConsoleTestState</span><span class="op">></span> {
<span class="kw">let</span> <span class="ident">log_out</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">opts</span>.<span class="ident">logfile</span> {
<span class="prelude-val">Some</span>(<span class="kw-2">ref</span> <span class="ident">path</span>) <span class="op">=></span> <span class="prelude-val">Some</span>(<span class="ident">File</span>::<span class="ident">create</span>(<span class="ident">path</span>)<span class="question-mark">?</span>),
<span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">None</span>,
};
<span class="prelude-val">Ok</span>(<span class="ident">ConsoleTestState</span> {
<span class="ident">log_out</span>,
<span class="ident">total</span>: <span class="number">0</span>,
<span class="ident">passed</span>: <span class="number">0</span>,
<span class="ident">failed</span>: <span class="number">0</span>,
<span class="ident">ignored</span>: <span class="number">0</span>,
<span class="ident">allowed_fail</span>: <span class="number">0</span>,
<span class="ident">filtered_out</span>: <span class="number">0</span>,
<span class="ident">measured</span>: <span class="number">0</span>,
<span class="ident">metrics</span>: <span class="ident">MetricMap</span>::<span class="ident">new</span>(),
<span class="ident">failures</span>: <span class="ident">Vec</span>::<span class="ident">new</span>(),
<span class="ident">not_failures</span>: <span class="ident">Vec</span>::<span class="ident">new</span>(),
<span class="ident">options</span>: <span class="ident">opts</span>.<span class="ident">options</span>,
})
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">write_log</span><span class="op"><</span><span class="ident">S</span>: <span class="ident">AsRef</span><span class="op"><</span><span class="ident">str</span><span class="op">>></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">msg</span>: <span class="ident">S</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="kw">let</span> <span class="ident">msg</span> <span class="op">=</span> <span class="ident">msg</span>.<span class="ident">as_ref</span>();
<span class="kw">match</span> <span class="self">self</span>.<span class="ident">log_out</span> {
<span class="prelude-val">None</span> <span class="op">=></span> <span class="prelude-val">Ok</span>(()),
<span class="prelude-val">Some</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">o</span>) <span class="op">=></span> <span class="ident">o</span>.<span class="ident">write_all</span>(<span class="ident">msg</span>.<span class="ident">as_bytes</span>()),
}
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">write_log_result</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">test</span>: <span class="kw-2">&</span><span class="ident">TestDesc</span>, <span class="ident">result</span>: <span class="kw-2">&</span><span class="ident">TestResult</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="self">self</span>.<span class="ident">write_log</span>(<span class="macro">format</span><span class="macro">!</span>(
<span class="string">"{} {}\n"</span>,
<span class="kw">match</span> <span class="kw-2">*</span><span class="ident">result</span> {
<span class="ident">TrOk</span> <span class="op">=></span> <span class="string">"ok"</span>.<span class="ident">to_owned</span>(),
<span class="ident">TrFailed</span> <span class="op">=></span> <span class="string">"failed"</span>.<span class="ident">to_owned</span>(),
<span class="ident">TrFailedMsg</span>(<span class="kw-2">ref</span> <span class="ident">msg</span>) <span class="op">=></span> <span class="macro">format</span><span class="macro">!</span>(<span class="string">"failed: {}"</span>, <span class="ident">msg</span>),
<span class="ident">TrIgnored</span> <span class="op">=></span> <span class="string">"ignored"</span>.<span class="ident">to_owned</span>(),
<span class="ident">TrAllowedFail</span> <span class="op">=></span> <span class="string">"failed (allowed)"</span>.<span class="ident">to_owned</span>(),
<span class="ident">TrBench</span>(<span class="kw-2">ref</span> <span class="ident">bs</span>) <span class="op">=></span> <span class="ident">fmt_bench_samples</span>(<span class="ident">bs</span>),
},
<span class="ident">test</span>.<span class="ident">name</span>
))
}
<span class="kw">fn</span> <span class="ident">current_test_count</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">usize</span> {
<span class="self">self</span>.<span class="ident">passed</span> <span class="op">+</span> <span class="self">self</span>.<span class="ident">failed</span> <span class="op">+</span> <span class="self">self</span>.<span class="ident">ignored</span> <span class="op">+</span> <span class="self">self</span>.<span class="ident">measured</span> <span class="op">+</span> <span class="self">self</span>.<span class="ident">allowed_fail</span>
}
}
<span class="comment">// Format a number with thousands separators</span>
<span class="kw">fn</span> <span class="ident">fmt_thousands_sep</span>(<span class="kw-2">mut</span> <span class="ident">n</span>: <span class="ident">usize</span>, <span class="ident">sep</span>: <span class="ident">char</span>) <span class="op">-></span> <span class="ident">String</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>::<span class="ident">Write</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">output</span> <span class="op">=</span> <span class="ident">String</span>::<span class="ident">new</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">trailing</span> <span class="op">=</span> <span class="bool-val">false</span>;
<span class="kw">for</span> <span class="kw-2">&</span><span class="ident">pow</span> <span class="kw">in</span> <span class="kw-2">&</span>[<span class="number">9</span>, <span class="number">6</span>, <span class="number">3</span>, <span class="number">0</span>] {
<span class="kw">let</span> <span class="ident">base</span> <span class="op">=</span> <span class="number">10_usize</span>.<span class="ident">pow</span>(<span class="ident">pow</span>);
<span class="kw">if</span> <span class="ident">pow</span> <span class="op">==</span> <span class="number">0</span> <span class="op">||</span> <span class="ident">trailing</span> <span class="op">||</span> <span class="ident">n</span> <span class="op">/</span> <span class="ident">base</span> <span class="op">!=</span> <span class="number">0</span> {
<span class="kw">if</span> <span class="op">!</span><span class="ident">trailing</span> {
<span class="ident">output</span>.<span class="ident">write_fmt</span>(<span class="macro">format_args</span><span class="macro">!</span>(<span class="string">"{}"</span>, <span class="ident">n</span> <span class="op">/</span> <span class="ident">base</span>)).<span class="ident">unwrap</span>();
} <span class="kw">else</span> {
<span class="ident">output</span>.<span class="ident">write_fmt</span>(<span class="macro">format_args</span><span class="macro">!</span>(<span class="string">"{:03}"</span>, <span class="ident">n</span> <span class="op">/</span> <span class="ident">base</span>)).<span class="ident">unwrap</span>();
}
<span class="kw">if</span> <span class="ident">pow</span> <span class="op">!=</span> <span class="number">0</span> {
<span class="ident">output</span>.<span class="ident">push</span>(<span class="ident">sep</span>);
}
<span class="ident">trailing</span> <span class="op">=</span> <span class="bool-val">true</span>;
}
<span class="ident">n</span> <span class="op">%=</span> <span class="ident">base</span>;
}
<span class="ident">output</span>
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">fmt_bench_samples</span>(<span class="ident">bs</span>: <span class="kw-2">&</span><span class="ident">BenchSamples</span>) <span class="op">-></span> <span class="ident">String</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">fmt</span>::<span class="ident">Write</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">output</span> <span class="op">=</span> <span class="ident">String</span>::<span class="ident">new</span>();
<span class="kw">let</span> <span class="ident">median</span> <span class="op">=</span> <span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">median</span> <span class="kw">as</span> <span class="ident">usize</span>;
<span class="kw">let</span> <span class="ident">deviation</span> <span class="op">=</span> (<span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">max</span> <span class="op">-</span> <span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">min</span>) <span class="kw">as</span> <span class="ident">usize</span>;
<span class="ident">output</span>
.<span class="ident">write_fmt</span>(<span class="macro">format_args</span><span class="macro">!</span>(
<span class="string">"{:>11} ns/iter (+/- {})"</span>,
<span class="ident">fmt_thousands_sep</span>(<span class="ident">median</span>, <span class="string">','</span>),
<span class="ident">fmt_thousands_sep</span>(<span class="ident">deviation</span>, <span class="string">','</span>)
))
.<span class="ident">unwrap</span>();
<span class="kw">if</span> <span class="ident">bs</span>.<span class="ident">mb_s</span> <span class="op">!=</span> <span class="number">0</span> {
<span class="ident">output</span>
.<span class="ident">write_fmt</span>(<span class="macro">format_args</span><span class="macro">!</span>(<span class="string">" = {} MB/s"</span>, <span class="ident">bs</span>.<span class="ident">mb_s</span>))
.<span class="ident">unwrap</span>();
}
<span class="ident">output</span>
}
<span class="comment">// List the tests to console, and optionally to logfile. Filters are honored.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">list_tests_console</span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>, <span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">output</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">term</span>::<span class="ident">stdout</span>() {
<span class="prelude-val">None</span> <span class="op">=></span> <span class="ident">Raw</span>(<span class="ident">io</span>::<span class="ident">stdout</span>()),
<span class="prelude-val">Some</span>(<span class="ident">t</span>) <span class="op">=></span> <span class="ident">Pretty</span>(<span class="ident">t</span>),
};
<span class="kw">let</span> <span class="ident">quiet</span> <span class="op">=</span> <span class="ident">opts</span>.<span class="ident">format</span> <span class="op">==</span> <span class="ident">OutputFormat</span>::<span class="ident">Terse</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">st</span> <span class="op">=</span> <span class="ident">ConsoleTestState</span>::<span class="ident">new</span>(<span class="ident">opts</span>)<span class="question-mark">?</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">ntest</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">nbench</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">for</span> <span class="ident">test</span> <span class="kw">in</span> <span class="ident">filter_tests</span>(<span class="kw-2">&</span><span class="ident">opts</span>, <span class="ident">tests</span>) {
<span class="kw">use</span> <span class="ident">TestFn</span>::<span class="kw-2">*</span>;
<span class="kw">let</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> { <span class="ident">name</span>, .. },
<span class="ident">testfn</span>,
} <span class="op">=</span> <span class="ident">test</span>;
<span class="kw">let</span> <span class="ident">fntype</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">testfn</span> {
<span class="ident">StaticTestFn</span>(..) <span class="op">|</span> <span class="ident">DynTestFn</span>(..) <span class="op">=></span> {
<span class="ident">ntest</span> <span class="op">+=</span> <span class="number">1</span>;
<span class="string">"test"</span>
}
<span class="ident">StaticBenchFn</span>(..) <span class="op">|</span> <span class="ident">DynBenchFn</span>(..) <span class="op">=></span> {
<span class="ident">nbench</span> <span class="op">+=</span> <span class="number">1</span>;
<span class="string">"benchmark"</span>
}
};
<span class="macro">writeln</span><span class="macro">!</span>(<span class="ident">output</span>, <span class="string">"{}: {}"</span>, <span class="ident">name</span>, <span class="ident">fntype</span>)<span class="question-mark">?</span>;
<span class="ident">st</span>.<span class="ident">write_log</span>(<span class="macro">format</span><span class="macro">!</span>(<span class="string">"{} {}\n"</span>, <span class="ident">fntype</span>, <span class="ident">name</span>))<span class="question-mark">?</span>;
}
<span class="kw">fn</span> <span class="ident">plural</span>(<span class="ident">count</span>: <span class="ident">u32</span>, <span class="ident">s</span>: <span class="kw-2">&</span><span class="ident">str</span>) <span class="op">-></span> <span class="ident">String</span> {
<span class="kw">match</span> <span class="ident">count</span> {
<span class="number">1</span> <span class="op">=></span> <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{} {}"</span>, <span class="number">1</span>, <span class="ident">s</span>),
<span class="ident">n</span> <span class="op">=></span> <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{} {}s"</span>, <span class="ident">n</span>, <span class="ident">s</span>),
}
}
<span class="kw">if</span> <span class="op">!</span><span class="ident">quiet</span> {
<span class="kw">if</span> <span class="ident">ntest</span> <span class="op">!=</span> <span class="number">0</span> <span class="op">||</span> <span class="ident">nbench</span> <span class="op">!=</span> <span class="number">0</span> {
<span class="macro">writeln</span><span class="macro">!</span>(<span class="ident">output</span>, <span class="string">""</span>)<span class="question-mark">?</span>;
}
<span class="macro">writeln</span><span class="macro">!</span>(
<span class="ident">output</span>,
<span class="string">"{}, {}"</span>,
<span class="ident">plural</span>(<span class="ident">ntest</span>, <span class="string">"test"</span>),
<span class="ident">plural</span>(<span class="ident">nbench</span>, <span class="string">"benchmark"</span>)
)<span class="question-mark">?</span>;
}
<span class="prelude-val">Ok</span>(())
}
<span class="comment">// A simple console test runner</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">run_tests_console</span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>, <span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">bool</span><span class="op">></span> {
<span class="kw">fn</span> <span class="ident">callback</span>(
<span class="ident">event</span>: <span class="kw-2">&</span><span class="ident">TestEvent</span>,
<span class="ident">st</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">ConsoleTestState</span>,
<span class="ident">out</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">OutputFormatter</span>,
) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="kw">match</span> (<span class="kw-2">*</span><span class="ident">event</span>).<span class="ident">clone</span>() {
<span class="ident">TeFiltered</span>(<span class="kw-2">ref</span> <span class="ident">filtered_tests</span>) <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">total</span> <span class="op">=</span> <span class="ident">filtered_tests</span>.<span class="ident">len</span>();
<span class="ident">out</span>.<span class="ident">write_run_start</span>(<span class="ident">filtered_tests</span>.<span class="ident">len</span>())
}
<span class="ident">TeFilteredOut</span>(<span class="ident">filtered_out</span>) <span class="op">=></span> <span class="prelude-val">Ok</span>(<span class="ident">st</span>.<span class="ident">filtered_out</span> <span class="op">=</span> <span class="ident">filtered_out</span>),
<span class="ident">TeWait</span>(<span class="kw-2">ref</span> <span class="ident">test</span>) <span class="op">=></span> <span class="ident">out</span>.<span class="ident">write_test_start</span>(<span class="ident">test</span>),
<span class="ident">TeTimeout</span>(<span class="kw-2">ref</span> <span class="ident">test</span>) <span class="op">=></span> <span class="ident">out</span>.<span class="ident">write_timeout</span>(<span class="ident">test</span>),
<span class="ident">TeResult</span>(<span class="ident">test</span>, <span class="ident">result</span>, <span class="ident">stdout</span>) <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">write_log_result</span>(<span class="kw-2">&</span><span class="ident">test</span>, <span class="kw-2">&</span><span class="ident">result</span>)<span class="question-mark">?</span>;
<span class="ident">out</span>.<span class="ident">write_result</span>(<span class="kw-2">&</span><span class="ident">test</span>, <span class="kw-2">&</span><span class="ident">result</span>, <span class="kw-2">&</span><span class="kw-2">*</span><span class="ident">stdout</span>)<span class="question-mark">?</span>;
<span class="kw">match</span> <span class="ident">result</span> {
<span class="ident">TrOk</span> <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">passed</span> <span class="op">+=</span> <span class="number">1</span>;
<span class="ident">st</span>.<span class="ident">not_failures</span>.<span class="ident">push</span>((<span class="ident">test</span>, <span class="ident">stdout</span>));
}
<span class="ident">TrIgnored</span> <span class="op">=></span> <span class="ident">st</span>.<span class="ident">ignored</span> <span class="op">+=</span> <span class="number">1</span>,
<span class="ident">TrAllowedFail</span> <span class="op">=></span> <span class="ident">st</span>.<span class="ident">allowed_fail</span> <span class="op">+=</span> <span class="number">1</span>,
<span class="ident">TrBench</span>(<span class="ident">bs</span>) <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">metrics</span>.<span class="ident">insert_metric</span>(
<span class="ident">test</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>(),
<span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">median</span>,
<span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">max</span> <span class="op">-</span> <span class="ident">bs</span>.<span class="ident">ns_iter_summ</span>.<span class="ident">min</span>,
);
<span class="ident">st</span>.<span class="ident">measured</span> <span class="op">+=</span> <span class="number">1</span>
}
<span class="ident">TrFailed</span> <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">failed</span> <span class="op">+=</span> <span class="number">1</span>;
<span class="ident">st</span>.<span class="ident">failures</span>.<span class="ident">push</span>((<span class="ident">test</span>, <span class="ident">stdout</span>));
}
<span class="ident">TrFailedMsg</span>(<span class="ident">msg</span>) <span class="op">=></span> {
<span class="ident">st</span>.<span class="ident">failed</span> <span class="op">+=</span> <span class="number">1</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">stdout</span> <span class="op">=</span> <span class="ident">stdout</span>;
<span class="ident">stdout</span>.<span class="ident">extend_from_slice</span>(<span class="macro">format</span><span class="macro">!</span>(<span class="string">"note: {}"</span>, <span class="ident">msg</span>).<span class="ident">as_bytes</span>());
<span class="ident">st</span>.<span class="ident">failures</span>.<span class="ident">push</span>((<span class="ident">test</span>, <span class="ident">stdout</span>));
}
}
<span class="prelude-val">Ok</span>(())
}
}
}
<span class="kw">let</span> <span class="ident">output</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">term</span>::<span class="ident">stdout</span>() {
<span class="prelude-val">None</span> <span class="op">=></span> <span class="ident">Raw</span>(<span class="ident">io</span>::<span class="ident">stdout</span>()),
<span class="prelude-val">Some</span>(<span class="ident">t</span>) <span class="op">=></span> <span class="ident">Pretty</span>(<span class="ident">t</span>),
};
<span class="kw">let</span> <span class="ident">max_name_len</span> <span class="op">=</span> <span class="ident">tests</span>
.<span class="ident">iter</span>()
.<span class="ident">max_by_key</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> <span class="ident">len_if_padded</span>(<span class="kw-2">*</span><span class="ident">t</span>))
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> <span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">len</span>())
.<span class="ident">unwrap_or</span>(<span class="number">0</span>);
<span class="kw">let</span> <span class="ident">is_multithreaded</span> <span class="op">=</span> <span class="ident">opts</span>.<span class="ident">test_threads</span>.<span class="ident">unwrap_or_else</span>(<span class="ident">get_concurrency</span>) <span class="op">></span> <span class="number">1</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">out</span>: <span class="ident">Box</span><span class="op"><</span><span class="ident">OutputFormatter</span><span class="op">></span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">opts</span>.<span class="ident">format</span> {
<span class="ident">OutputFormat</span>::<span class="ident">Pretty</span> <span class="op">=></span> <span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">PrettyFormatter</span>::<span class="ident">new</span>(
<span class="ident">output</span>,
<span class="ident">use_color</span>(<span class="ident">opts</span>),
<span class="ident">max_name_len</span>,
<span class="ident">is_multithreaded</span>,
)),
<span class="ident">OutputFormat</span>::<span class="ident">Terse</span> <span class="op">=></span> <span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">TerseFormatter</span>::<span class="ident">new</span>(
<span class="ident">output</span>,
<span class="ident">use_color</span>(<span class="ident">opts</span>),
<span class="ident">max_name_len</span>,
<span class="ident">is_multithreaded</span>,
)),
<span class="ident">OutputFormat</span>::<span class="ident">Json</span> <span class="op">=></span> <span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">JsonFormatter</span>::<span class="ident">new</span>(<span class="ident">output</span>)),
};
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">st</span> <span class="op">=</span> <span class="ident">ConsoleTestState</span>::<span class="ident">new</span>(<span class="ident">opts</span>)<span class="question-mark">?</span>;
<span class="kw">fn</span> <span class="ident">len_if_padded</span>(<span class="ident">t</span>: <span class="kw-2">&</span><span class="ident">TestDescAndFn</span>) <span class="op">-></span> <span class="ident">usize</span> {
<span class="kw">match</span> <span class="ident">t</span>.<span class="ident">testfn</span>.<span class="ident">padding</span>() {
<span class="ident">PadNone</span> <span class="op">=></span> <span class="number">0</span>,
<span class="ident">PadOnRight</span> <span class="op">=></span> <span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">len</span>(),
}
}
<span class="ident">run_tests</span>(<span class="ident">opts</span>, <span class="ident">tests</span>, <span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">callback</span>(<span class="kw-2">&</span><span class="ident">x</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">st</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">*</span><span class="ident">out</span>))<span class="question-mark">?</span>;
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">st</span>.<span class="ident">current_test_count</span>() <span class="op">==</span> <span class="ident">st</span>.<span class="ident">total</span>);
<span class="kw">return</span> <span class="ident">out</span>.<span class="ident">write_run_finish</span>(<span class="kw-2">&</span><span class="ident">st</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">should_sort_failures_before_printing_them</span>() {
<span class="kw">let</span> <span class="ident">test_a</span> <span class="op">=</span> <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"a"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
};
<span class="kw">let</span> <span class="ident">test_b</span> <span class="op">=</span> <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"b"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
};
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">out</span> <span class="op">=</span> <span class="ident">PrettyFormatter</span>::<span class="ident">new</span>(<span class="ident">Raw</span>(<span class="ident">Vec</span>::<span class="ident">new</span>()), <span class="bool-val">false</span>, <span class="number">10</span>, <span class="bool-val">false</span>);
<span class="kw">let</span> <span class="ident">st</span> <span class="op">=</span> <span class="ident">ConsoleTestState</span> {
<span class="ident">log_out</span>: <span class="prelude-val">None</span>,
<span class="ident">total</span>: <span class="number">0</span>,
<span class="ident">passed</span>: <span class="number">0</span>,
<span class="ident">failed</span>: <span class="number">0</span>,
<span class="ident">ignored</span>: <span class="number">0</span>,
<span class="ident">allowed_fail</span>: <span class="number">0</span>,
<span class="ident">filtered_out</span>: <span class="number">0</span>,
<span class="ident">measured</span>: <span class="number">0</span>,
<span class="ident">metrics</span>: <span class="ident">MetricMap</span>::<span class="ident">new</span>(),
<span class="ident">failures</span>: <span class="macro">vec</span><span class="macro">!</span>[(<span class="ident">test_b</span>, <span class="ident">Vec</span>::<span class="ident">new</span>()), (<span class="ident">test_a</span>, <span class="ident">Vec</span>::<span class="ident">new</span>())],
<span class="ident">options</span>: <span class="ident">Options</span>::<span class="ident">new</span>(),
<span class="ident">not_failures</span>: <span class="ident">Vec</span>::<span class="ident">new</span>(),
};
<span class="ident">out</span>.<span class="ident">write_failures</span>(<span class="kw-2">&</span><span class="ident">st</span>).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">s</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">out</span>.<span class="ident">output_location</span>() {
<span class="kw-2">&</span><span class="ident">Raw</span>(<span class="kw-2">ref</span> <span class="ident">m</span>) <span class="op">=></span> <span class="ident">String</span>::<span class="ident">from_utf8_lossy</span>(<span class="kw-2">&</span><span class="ident">m</span>[..]),
<span class="kw-2">&</span><span class="ident">Pretty</span>(<span class="kw">_</span>) <span class="op">=></span> <span class="macro">unreachable</span><span class="macro">!</span>(),
};
<span class="kw">let</span> <span class="ident">apos</span> <span class="op">=</span> <span class="ident">s</span>.<span class="ident">find</span>(<span class="string">"a"</span>).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bpos</span> <span class="op">=</span> <span class="ident">s</span>.<span class="ident">find</span>(<span class="string">"b"</span>).<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">apos</span> <span class="op"><</span> <span class="ident">bpos</span>);
}
<span class="kw">fn</span> <span class="ident">use_color</span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>) <span class="op">-></span> <span class="ident">bool</span> {
<span class="kw">match</span> <span class="ident">opts</span>.<span class="ident">color</span> {
<span class="ident">AutoColor</span> <span class="op">=></span> <span class="op">!</span><span class="ident">opts</span>.<span class="ident">nocapture</span> <span class="op">&&</span> <span class="ident">stdout_isatty</span>(),
<span class="ident">AlwaysColor</span> <span class="op">=></span> <span class="bool-val">true</span>,
<span class="ident">NeverColor</span> <span class="op">=></span> <span class="bool-val">false</span>,
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"cloudabi"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"redox"</span>,
<span class="ident">all</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>, <span class="ident">not</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"emscripten"</span>))))]</span>
<span class="kw">fn</span> <span class="ident">stdout_isatty</span>() <span class="op">-></span> <span class="ident">bool</span> {
<span class="comment">// FIXME: Implement isatty on Redox</span>
<span class="bool-val">false</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">unix</span>)]</span>
<span class="kw">fn</span> <span class="ident">stdout_isatty</span>() <span class="op">-></span> <span class="ident">bool</span> {
<span class="kw">unsafe</span> { <span class="ident">libc</span>::<span class="ident">isatty</span>(<span class="ident">libc</span>::<span class="ident">STDOUT_FILENO</span>) <span class="op">!=</span> <span class="number">0</span> }
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">windows</span>)]</span>
<span class="kw">fn</span> <span class="ident">stdout_isatty</span>() <span class="op">-></span> <span class="ident">bool</span> {
<span class="kw">type</span> <span class="ident">DWORD</span> <span class="op">=</span> <span class="ident">u32</span>;
<span class="kw">type</span> <span class="ident">BOOL</span> <span class="op">=</span> <span class="ident">i32</span>;
<span class="kw">type</span> <span class="ident">HANDLE</span> <span class="op">=</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">u8</span>;
<span class="kw">type</span> <span class="ident">LPDWORD</span> <span class="op">=</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">u32</span>;
<span class="kw">const</span> <span class="ident">STD_OUTPUT_HANDLE</span>: <span class="ident">DWORD</span> <span class="op">=</span> <span class="op">-</span><span class="number">11i32</span> <span class="kw">as</span> <span class="ident">DWORD</span>;
<span class="kw">extern</span> <span class="string">"system"</span> {
<span class="kw">fn</span> <span class="ident">GetStdHandle</span>(<span class="ident">which</span>: <span class="ident">DWORD</span>) <span class="op">-></span> <span class="ident">HANDLE</span>;
<span class="kw">fn</span> <span class="ident">GetConsoleMode</span>(<span class="ident">hConsoleHandle</span>: <span class="ident">HANDLE</span>, <span class="ident">lpMode</span>: <span class="ident">LPDWORD</span>) <span class="op">-></span> <span class="ident">BOOL</span>;
}
<span class="kw">unsafe</span> {
<span class="kw">let</span> <span class="ident">handle</span> <span class="op">=</span> <span class="ident">GetStdHandle</span>(<span class="ident">STD_OUTPUT_HANDLE</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">out</span> <span class="op">=</span> <span class="number">0</span>;
<span class="ident">GetConsoleMode</span>(<span class="ident">handle</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">out</span>) <span class="op">!=</span> <span class="number">0</span>
}
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>)]</span>
<span class="kw">pub</span> <span class="kw">enum</span> <span class="ident">TestEvent</span> {
<span class="ident">TeFiltered</span>(<span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDesc</span><span class="op">></span>),
<span class="ident">TeWait</span>(<span class="ident">TestDesc</span>),
<span class="ident">TeResult</span>(<span class="ident">TestDesc</span>, <span class="ident">TestResult</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>),
<span class="ident">TeTimeout</span>(<span class="ident">TestDesc</span>),
<span class="ident">TeFilteredOut</span>(<span class="ident">usize</span>),
}
<span class="kw">pub</span> <span class="kw">type</span> <span class="ident">MonitorMsg</span> <span class="op">=</span> (<span class="ident">TestDesc</span>, <span class="ident">TestResult</span>, <span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span>);
<span class="kw">struct</span> <span class="ident">Sink</span>(<span class="ident">Arc</span><span class="op"><</span><span class="ident">Mutex</span><span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u8</span><span class="op">>></span><span class="op">></span>);
<span class="kw">impl</span> <span class="ident">Write</span> <span class="kw">for</span> <span class="ident">Sink</span> {
<span class="kw">fn</span> <span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">data</span>: <span class="kw-2">&</span>[<span class="ident">u8</span>]) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> {
<span class="ident">Write</span>::<span class="ident">write</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">*</span><span class="self">self</span>.<span class="number">0</span>.<span class="ident">lock</span>().<span class="ident">unwrap</span>(), <span class="ident">data</span>)
}
<span class="kw">fn</span> <span class="ident">flush</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span> {
<span class="prelude-val">Ok</span>(())
}
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">run_tests</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>, <span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>, <span class="kw-2">mut</span> <span class="ident">callback</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span>
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>(<span class="ident">TestEvent</span>) <span class="op">-></span> <span class="ident">io</span>::<span class="prelude-ty">Result</span><span class="op"><</span>()<span class="op">></span>,
{
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">mpsc</span>::<span class="ident">RecvTimeoutError</span>;
<span class="kw">let</span> <span class="ident">tests_len</span> <span class="op">=</span> <span class="ident">tests</span>.<span class="ident">len</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">filtered_tests</span> <span class="op">=</span> <span class="ident">filter_tests</span>(<span class="ident">opts</span>, <span class="ident">tests</span>);
<span class="kw">if</span> <span class="op">!</span><span class="ident">opts</span>.<span class="ident">bench_benchmarks</span> {
<span class="ident">filtered_tests</span> <span class="op">=</span> <span class="ident">convert_benchmarks_to_tests</span>(<span class="ident">filtered_tests</span>);
}
<span class="kw">let</span> <span class="ident">filtered_tests</span> <span class="op">=</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">filtered_tests</span> <span class="op">=</span> <span class="ident">filtered_tests</span>;
<span class="kw">for</span> <span class="ident">test</span> <span class="kw">in</span> <span class="ident">filtered_tests</span>.<span class="ident">iter_mut</span>() {
<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">name</span> <span class="op">=</span> <span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">with_padding</span>(<span class="ident">test</span>.<span class="ident">testfn</span>.<span class="ident">padding</span>());
}
<span class="ident">filtered_tests</span>
};
<span class="kw">let</span> <span class="ident">filtered_out</span> <span class="op">=</span> <span class="ident">tests_len</span> <span class="op">-</span> <span class="ident">filtered_tests</span>.<span class="ident">len</span>();
<span class="ident">callback</span>(<span class="ident">TeFilteredOut</span>(<span class="ident">filtered_out</span>))<span class="question-mark">?</span>;
<span class="kw">let</span> <span class="ident">filtered_descs</span> <span class="op">=</span> <span class="ident">filtered_tests</span>.<span class="ident">iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> <span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">clone</span>()).<span class="ident">collect</span>();
<span class="ident">callback</span>(<span class="ident">TeFiltered</span>(<span class="ident">filtered_descs</span>))<span class="question-mark">?</span>;
<span class="kw">let</span> (<span class="ident">filtered_tests</span>, <span class="ident">filtered_benchs</span>): (<span class="ident">Vec</span><span class="op"><</span><span class="kw">_</span><span class="op">></span>, <span class="kw">_</span>) <span class="op">=</span>
<span class="ident">filtered_tests</span>.<span class="ident">into_iter</span>().<span class="ident">partition</span>(<span class="op">|</span><span class="ident">e</span><span class="op">|</span> <span class="kw">match</span> <span class="ident">e</span>.<span class="ident">testfn</span> {
<span class="ident">StaticTestFn</span>(<span class="kw">_</span>) <span class="op">|</span> <span class="ident">DynTestFn</span>(<span class="kw">_</span>) <span class="op">=></span> <span class="bool-val">true</span>,
<span class="kw">_</span> <span class="op">=></span> <span class="bool-val">false</span>,
});
<span class="kw">let</span> <span class="ident">concurrency</span> <span class="op">=</span> <span class="ident">opts</span>.<span class="ident">test_threads</span>.<span class="ident">unwrap_or_else</span>(<span class="ident">get_concurrency</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">remaining</span> <span class="op">=</span> <span class="ident">filtered_tests</span>;
<span class="ident">remaining</span>.<span class="ident">reverse</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">pending</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>::<span class="op"><</span><span class="ident">MonitorMsg</span><span class="op">></span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">running_tests</span>: <span class="ident">HashMap</span><span class="op"><</span><span class="ident">TestDesc</span>, <span class="ident">Instant</span><span class="op">></span> <span class="op">=</span> <span class="ident">HashMap</span>::<span class="ident">new</span>();
<span class="kw">fn</span> <span class="ident">get_timed_out_tests</span>(<span class="ident">running_tests</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">HashMap</span><span class="op"><</span><span class="ident">TestDesc</span>, <span class="ident">Instant</span><span class="op">></span>) <span class="op">-></span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDesc</span><span class="op">></span> {
<span class="kw">let</span> <span class="ident">now</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
<span class="kw">let</span> <span class="ident">timed_out</span> <span class="op">=</span> <span class="ident">running_tests</span>
.<span class="ident">iter</span>()
.<span class="ident">filter_map</span>(<span class="op">|</span>(<span class="ident">desc</span>, <span class="ident">timeout</span>)<span class="op">|</span> {
<span class="kw">if</span> <span class="kw-2">&</span><span class="ident">now</span> <span class="op">>=</span> <span class="ident">timeout</span> {
<span class="prelude-val">Some</span>(<span class="ident">desc</span>.<span class="ident">clone</span>())
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
}
})
.<span class="ident">collect</span>();
<span class="kw">for</span> <span class="ident">test</span> <span class="kw">in</span> <span class="kw-2">&</span><span class="ident">timed_out</span> {
<span class="ident">running_tests</span>.<span class="ident">remove</span>(<span class="ident">test</span>);
}
<span class="ident">timed_out</span>
};
<span class="kw">fn</span> <span class="ident">calc_timeout</span>(<span class="ident">running_tests</span>: <span class="kw-2">&</span><span class="ident">HashMap</span><span class="op"><</span><span class="ident">TestDesc</span>, <span class="ident">Instant</span><span class="op">></span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">Duration</span><span class="op">></span> {
<span class="ident">running_tests</span>.<span class="ident">values</span>().<span class="ident">min</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">next_timeout</span><span class="op">|</span> {
<span class="kw">let</span> <span class="ident">now</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
<span class="kw">if</span> <span class="kw-2">*</span><span class="ident">next_timeout</span> <span class="op">>=</span> <span class="ident">now</span> {
<span class="kw-2">*</span><span class="ident">next_timeout</span> <span class="op">-</span> <span class="ident">now</span>
} <span class="kw">else</span> {
<span class="ident">Duration</span>::<span class="ident">new</span>(<span class="number">0</span>, <span class="number">0</span>)
}
})
};
<span class="kw">if</span> <span class="ident">concurrency</span> <span class="op">==</span> <span class="number">1</span> {
<span class="kw">while</span> <span class="op">!</span><span class="ident">remaining</span>.<span class="ident">is_empty</span>() {
<span class="kw">let</span> <span class="ident">test</span> <span class="op">=</span> <span class="ident">remaining</span>.<span class="ident">pop</span>().<span class="ident">unwrap</span>();
<span class="ident">callback</span>(<span class="ident">TeWait</span>(<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">clone</span>()))<span class="question-mark">?</span>;
<span class="ident">run_test</span>(<span class="ident">opts</span>, <span class="op">!</span><span class="ident">opts</span>.<span class="ident">run_tests</span>, <span class="ident">test</span>, <span class="ident">tx</span>.<span class="ident">clone</span>());
<span class="kw">let</span> (<span class="ident">test</span>, <span class="ident">result</span>, <span class="ident">stdout</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="ident">callback</span>(<span class="ident">TeResult</span>(<span class="ident">test</span>, <span class="ident">result</span>, <span class="ident">stdout</span>))<span class="question-mark">?</span>;
}
} <span class="kw">else</span> {
<span class="kw">while</span> <span class="ident">pending</span> <span class="op">></span> <span class="number">0</span> <span class="op">||</span> <span class="op">!</span><span class="ident">remaining</span>.<span class="ident">is_empty</span>() {
<span class="kw">while</span> <span class="ident">pending</span> <span class="op"><</span> <span class="ident">concurrency</span> <span class="op">&&</span> <span class="op">!</span><span class="ident">remaining</span>.<span class="ident">is_empty</span>() {
<span class="kw">let</span> <span class="ident">test</span> <span class="op">=</span> <span class="ident">remaining</span>.<span class="ident">pop</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">timeout</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>() <span class="op">+</span> <span class="ident">Duration</span>::<span class="ident">from_secs</span>(<span class="ident">TEST_WARN_TIMEOUT_S</span>);
<span class="ident">running_tests</span>.<span class="ident">insert</span>(<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">clone</span>(), <span class="ident">timeout</span>);
<span class="ident">callback</span>(<span class="ident">TeWait</span>(<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">clone</span>()))<span class="question-mark">?</span>; <span class="comment">//here no pad</span>
<span class="ident">run_test</span>(<span class="ident">opts</span>, <span class="op">!</span><span class="ident">opts</span>.<span class="ident">run_tests</span>, <span class="ident">test</span>, <span class="ident">tx</span>.<span class="ident">clone</span>());
<span class="ident">pending</span> <span class="op">+=</span> <span class="number">1</span>;
}
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">res</span>;
<span class="kw">loop</span> {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">timeout</span>) <span class="op">=</span> <span class="ident">calc_timeout</span>(<span class="kw-2">&</span><span class="ident">running_tests</span>) {
<span class="ident">res</span> <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv_timeout</span>(<span class="ident">timeout</span>);
<span class="kw">for</span> <span class="ident">test</span> <span class="kw">in</span> <span class="ident">get_timed_out_tests</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">running_tests</span>) {
<span class="ident">callback</span>(<span class="ident">TeTimeout</span>(<span class="ident">test</span>))<span class="question-mark">?</span>;
}
<span class="kw">if</span> <span class="ident">res</span> <span class="op">!=</span> <span class="prelude-val">Err</span>(<span class="ident">RecvTimeoutError</span>::<span class="ident">Timeout</span>) {
<span class="kw">break</span>;
}
} <span class="kw">else</span> {
<span class="ident">res</span> <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">map_err</span>(<span class="op">|</span><span class="kw">_</span><span class="op">|</span> <span class="ident">RecvTimeoutError</span>::<span class="ident">Disconnected</span>);
<span class="kw">break</span>;
}
}
<span class="kw">let</span> (<span class="ident">desc</span>, <span class="ident">result</span>, <span class="ident">stdout</span>) <span class="op">=</span> <span class="ident">res</span>.<span class="ident">unwrap</span>();
<span class="ident">running_tests</span>.<span class="ident">remove</span>(<span class="kw-2">&</span><span class="ident">desc</span>);
<span class="ident">callback</span>(<span class="ident">TeResult</span>(<span class="ident">desc</span>, <span class="ident">result</span>, <span class="ident">stdout</span>))<span class="question-mark">?</span>;
<span class="ident">pending</span> <span class="op">-=</span> <span class="number">1</span>;
}
}
<span class="kw">if</span> <span class="ident">opts</span>.<span class="ident">bench_benchmarks</span> {
<span class="comment">// All benchmarks run at the end, in serial.</span>
<span class="kw">for</span> <span class="ident">b</span> <span class="kw">in</span> <span class="ident">filtered_benchs</span> {
<span class="ident">callback</span>(<span class="ident">TeWait</span>(<span class="ident">b</span>.<span class="ident">desc</span>.<span class="ident">clone</span>()))<span class="question-mark">?</span>;
<span class="ident">run_test</span>(<span class="ident">opts</span>, <span class="bool-val">false</span>, <span class="ident">b</span>, <span class="ident">tx</span>.<span class="ident">clone</span>());
<span class="kw">let</span> (<span class="ident">test</span>, <span class="ident">result</span>, <span class="ident">stdout</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="ident">callback</span>(<span class="ident">TeResult</span>(<span class="ident">test</span>, <span class="ident">result</span>, <span class="ident">stdout</span>))<span class="question-mark">?</span>;
}
}
<span class="prelude-val">Ok</span>(())
}
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">deprecated</span>)]</span>
<span class="kw">fn</span> <span class="ident">get_concurrency</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="kw">return</span> <span class="kw">match</span> <span class="ident">env</span>::<span class="ident">var</span>(<span class="string">"RUST_TEST_THREADS"</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">s</span>) <span class="op">=></span> {
<span class="kw">let</span> <span class="ident">opt_n</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> <span class="op">=</span> <span class="ident">s</span>.<span class="ident">parse</span>().<span class="ident">ok</span>();
<span class="kw">match</span> <span class="ident">opt_n</span> {
<span class="prelude-val">Some</span>(<span class="ident">n</span>) <span class="kw">if</span> <span class="ident">n</span> <span class="op">></span> <span class="number">0</span> <span class="op">=></span> <span class="ident">n</span>,
<span class="kw">_</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(
<span class="string">"RUST_TEST_THREADS is `{}`, should be a positive integer."</span>,
<span class="ident">s</span>
),
}
}
<span class="prelude-val">Err</span>(..) <span class="op">=></span> <span class="ident">num_cpus</span>(),
};
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">windows</span>)]</span>
<span class="attribute">#[<span class="ident">allow</span>(<span class="ident">bad_style</span>)]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="attribute">#[<span class="ident">repr</span>(<span class="ident">C</span>)]</span>
<span class="kw">struct</span> <span class="ident">SYSTEM_INFO</span> {
<span class="ident">wProcessorArchitecture</span>: <span class="ident">u16</span>,
<span class="ident">wReserved</span>: <span class="ident">u16</span>,
<span class="ident">dwPageSize</span>: <span class="ident">u32</span>,
<span class="ident">lpMinimumApplicationAddress</span>: <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">u8</span>,
<span class="ident">lpMaximumApplicationAddress</span>: <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">u8</span>,
<span class="ident">dwActiveProcessorMask</span>: <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">u8</span>,
<span class="ident">dwNumberOfProcessors</span>: <span class="ident">u32</span>,
<span class="ident">dwProcessorType</span>: <span class="ident">u32</span>,
<span class="ident">dwAllocationGranularity</span>: <span class="ident">u32</span>,
<span class="ident">wProcessorLevel</span>: <span class="ident">u16</span>,
<span class="ident">wProcessorRevision</span>: <span class="ident">u16</span>,
}
<span class="kw">extern</span> <span class="string">"system"</span> {
<span class="kw">fn</span> <span class="ident">GetSystemInfo</span>(<span class="ident">info</span>: <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="ident">SYSTEM_INFO</span>) <span class="op">-></span> <span class="ident">i32</span>;
}
<span class="kw">unsafe</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sysinfo</span> <span class="op">=</span> <span class="ident">std</span>::<span class="ident">mem</span>::<span class="ident">zeroed</span>();
<span class="ident">GetSystemInfo</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">sysinfo</span>);
<span class="ident">sysinfo</span>.<span class="ident">dwNumberOfProcessors</span> <span class="kw">as</span> <span class="ident">usize</span>
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"redox"</span>)]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="comment">// FIXME: Implement num_cpus on Redox</span>
<span class="number">1</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">all</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>, <span class="ident">not</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"emscripten"</span>)))]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="number">1</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"android"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"cloudabi"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"emscripten"</span>,
<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"fuchsia"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"ios"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"linux"</span>,
<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"macos"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"solaris"</span>))]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="kw">unsafe</span> { <span class="ident">libc</span>::<span class="ident">sysconf</span>(<span class="ident">libc</span>::<span class="ident">_SC_NPROCESSORS_ONLN</span>) <span class="kw">as</span> <span class="ident">usize</span> }
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"freebsd"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"dragonfly"</span>, <span class="ident">target_os</span> <span class="op">=</span> <span class="string">"bitrig"</span>,
<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"netbsd"</span>))]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ptr</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">cpus</span>: <span class="ident">libc</span>::<span class="ident">c_uint</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">cpus_size</span> <span class="op">=</span> <span class="ident">std</span>::<span class="ident">mem</span>::<span class="ident">size_of_val</span>(<span class="kw-2">&</span><span class="ident">cpus</span>);
<span class="kw">unsafe</span> {
<span class="ident">cpus</span> <span class="op">=</span> <span class="ident">libc</span>::<span class="ident">sysconf</span>(<span class="ident">libc</span>::<span class="ident">_SC_NPROCESSORS_ONLN</span>) <span class="kw">as</span> <span class="ident">libc</span>::<span class="ident">c_uint</span>;
}
<span class="kw">if</span> <span class="ident">cpus</span> <span class="op"><</span> <span class="number">1</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">mib</span> <span class="op">=</span> [<span class="ident">libc</span>::<span class="ident">CTL_HW</span>, <span class="ident">libc</span>::<span class="ident">HW_NCPU</span>, <span class="number">0</span>, <span class="number">0</span>];
<span class="kw">unsafe</span> {
<span class="ident">libc</span>::<span class="ident">sysctl</span>(
<span class="ident">mib</span>.<span class="ident">as_mut_ptr</span>(),
<span class="number">2</span>,
<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">cpus</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span>,
<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">cpus_size</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span>,
<span class="ident">ptr</span>::<span class="ident">null_mut</span>(),
<span class="number">0</span>,
);
}
<span class="kw">if</span> <span class="ident">cpus</span> <span class="op"><</span> <span class="number">1</span> {
<span class="ident">cpus</span> <span class="op">=</span> <span class="number">1</span>;
}
}
<span class="ident">cpus</span> <span class="kw">as</span> <span class="ident">usize</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"openbsd"</span>)]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ptr</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">cpus</span>: <span class="ident">libc</span>::<span class="ident">c_uint</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">cpus_size</span> <span class="op">=</span> <span class="ident">std</span>::<span class="ident">mem</span>::<span class="ident">size_of_val</span>(<span class="kw-2">&</span><span class="ident">cpus</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">mib</span> <span class="op">=</span> [<span class="ident">libc</span>::<span class="ident">CTL_HW</span>, <span class="ident">libc</span>::<span class="ident">HW_NCPU</span>, <span class="number">0</span>, <span class="number">0</span>];
<span class="kw">unsafe</span> {
<span class="ident">libc</span>::<span class="ident">sysctl</span>(
<span class="ident">mib</span>.<span class="ident">as_mut_ptr</span>(),
<span class="number">2</span>,
<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">cpus</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span>,
<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">cpus_size</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span> <span class="kw">as</span> <span class="kw-2">*</span><span class="kw-2">mut</span> <span class="kw">_</span>,
<span class="ident">ptr</span>::<span class="ident">null_mut</span>(),
<span class="number">0</span>,
);
}
<span class="kw">if</span> <span class="ident">cpus</span> <span class="op"><</span> <span class="number">1</span> {
<span class="ident">cpus</span> <span class="op">=</span> <span class="number">1</span>;
}
<span class="ident">cpus</span> <span class="kw">as</span> <span class="ident">usize</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"haiku"</span>)]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="comment">// FIXME: implement</span>
<span class="number">1</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"l4re"</span>)]</span>
<span class="kw">fn</span> <span class="ident">num_cpus</span>() <span class="op">-></span> <span class="ident">usize</span> {
<span class="comment">// FIXME: implement</span>
<span class="number">1</span>
}
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">filter_tests</span>(<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>, <span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>) <span class="op">-></span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">filtered</span> <span class="op">=</span> <span class="ident">tests</span>;
<span class="comment">// Remove tests that don't match the test filter</span>
<span class="ident">filtered</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">opts</span>.<span class="ident">filter</span> {
<span class="prelude-val">None</span> <span class="op">=></span> <span class="ident">filtered</span>,
<span class="prelude-val">Some</span>(<span class="kw-2">ref</span> <span class="ident">filter</span>) <span class="op">=></span> <span class="ident">filtered</span>
.<span class="ident">into_iter</span>()
.<span class="ident">filter</span>(<span class="op">|</span><span class="ident">test</span><span class="op">|</span> {
<span class="kw">if</span> <span class="ident">opts</span>.<span class="ident">filter_exact</span> {
<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>() <span class="op">==</span> <span class="kw-2">&</span><span class="ident">filter</span>[..]
} <span class="kw">else</span> {
<span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">contains</span>(<span class="kw-2">&</span><span class="ident">filter</span>[..])
}
})
.<span class="ident">collect</span>(),
};
<span class="comment">// Skip tests that match any of the skip filters</span>
<span class="ident">filtered</span> <span class="op">=</span> <span class="ident">filtered</span>
.<span class="ident">into_iter</span>()
.<span class="ident">filter</span>(<span class="op">|</span><span class="ident">t</span><span class="op">|</span> {
<span class="op">!</span><span class="ident">opts</span>.<span class="ident">skip</span>.<span class="ident">iter</span>().<span class="ident">any</span>(<span class="op">|</span><span class="ident">sf</span><span class="op">|</span> {
<span class="kw">if</span> <span class="ident">opts</span>.<span class="ident">filter_exact</span> {
<span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>() <span class="op">==</span> <span class="kw-2">&</span><span class="ident">sf</span>[..]
} <span class="kw">else</span> {
<span class="ident">t</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">contains</span>(<span class="kw-2">&</span><span class="ident">sf</span>[..])
}
})
})
.<span class="ident">collect</span>();
<span class="comment">// Maybe pull out the ignored test and unignore them</span>
<span class="ident">filtered</span> <span class="op">=</span> <span class="kw">if</span> <span class="op">!</span><span class="ident">opts</span>.<span class="ident">run_ignored</span> {
<span class="ident">filtered</span>
} <span class="kw">else</span> {
<span class="kw">fn</span> <span class="ident">filter</span>(<span class="ident">test</span>: <span class="ident">TestDescAndFn</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span> {
<span class="kw">if</span> <span class="ident">test</span>.<span class="ident">desc</span>.<span class="ident">ignore</span> {
<span class="kw">let</span> <span class="ident">TestDescAndFn</span> { <span class="ident">desc</span>, <span class="ident">testfn</span> } <span class="op">=</span> <span class="ident">test</span>;
<span class="prelude-val">Some</span>(<span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
..<span class="ident">desc</span>
},
<span class="ident">testfn</span>,
})
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
}
}
<span class="ident">filtered</span>.<span class="ident">into_iter</span>().<span class="ident">filter_map</span>(<span class="ident">filter</span>).<span class="ident">collect</span>()
};
<span class="comment">// Sort the tests alphabetically</span>
<span class="ident">filtered</span>.<span class="ident">sort_by</span>(<span class="op">|</span><span class="ident">t1</span>, <span class="ident">t2</span><span class="op">|</span> <span class="ident">t1</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">cmp</span>(<span class="ident">t2</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">as_slice</span>()));
<span class="ident">filtered</span>
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">convert_benchmarks_to_tests</span>(<span class="ident">tests</span>: <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span>) <span class="op">-></span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span> {
<span class="comment">// convert benchmarks to tests, if we're not benchmarking them</span>
<span class="ident">tests</span>
.<span class="ident">into_iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> {
<span class="kw">let</span> <span class="ident">testfn</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">x</span>.<span class="ident">testfn</span> {
<span class="ident">DynBenchFn</span>(<span class="ident">bench</span>) <span class="op">=></span> <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> {
<span class="ident">bench</span>::<span class="ident">run_once</span>(<span class="op">|</span><span class="ident">b</span><span class="op">|</span> <span class="ident">__rust_begin_short_backtrace</span>(<span class="op">||</span> <span class="ident">bench</span>.<span class="ident">run</span>(<span class="ident">b</span>)))
})),
<span class="ident">StaticBenchFn</span>(<span class="ident">benchfn</span>) <span class="op">=></span> <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> {
<span class="ident">bench</span>::<span class="ident">run_once</span>(<span class="op">|</span><span class="ident">b</span><span class="op">|</span> <span class="ident">__rust_begin_short_backtrace</span>(<span class="op">||</span> <span class="ident">benchfn</span>(<span class="ident">b</span>)))
})),
<span class="ident">f</span> <span class="op">=></span> <span class="ident">f</span>,
};
<span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">x</span>.<span class="ident">desc</span>,
<span class="ident">testfn</span>,
}
})
.<span class="ident">collect</span>()
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">run_test</span>(
<span class="ident">opts</span>: <span class="kw-2">&</span><span class="ident">TestOpts</span>,
<span class="ident">force_ignore</span>: <span class="ident">bool</span>,
<span class="ident">test</span>: <span class="ident">TestDescAndFn</span>,
<span class="ident">monitor_ch</span>: <span class="ident">Sender</span><span class="op"><</span><span class="ident">MonitorMsg</span><span class="op">></span>,
) {
<span class="kw">let</span> <span class="ident">TestDescAndFn</span> { <span class="ident">desc</span>, <span class="ident">testfn</span> } <span class="op">=</span> <span class="ident">test</span>;
<span class="kw">let</span> <span class="ident">ignore_because_panic_abort</span> <span class="op">=</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>) <span class="op">&&</span> <span class="op">!</span><span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"emscripten"</span>)
<span class="op">&&</span> <span class="ident">desc</span>.<span class="ident">should_panic</span> <span class="op">!=</span> <span class="ident">ShouldPanic</span>::<span class="ident">No</span>;
<span class="kw">if</span> <span class="ident">force_ignore</span> <span class="op">||</span> <span class="ident">desc</span>.<span class="ident">ignore</span> <span class="op">||</span> <span class="ident">ignore_because_panic_abort</span> {
<span class="ident">monitor_ch</span>.<span class="ident">send</span>((<span class="ident">desc</span>, <span class="ident">TrIgnored</span>, <span class="ident">Vec</span>::<span class="ident">new</span>())).<span class="ident">unwrap</span>();
<span class="kw">return</span>;
}
<span class="kw">fn</span> <span class="ident">run_test_inner</span>(
<span class="ident">desc</span>: <span class="ident">TestDesc</span>,
<span class="ident">monitor_ch</span>: <span class="ident">Sender</span><span class="op"><</span><span class="ident">MonitorMsg</span><span class="op">></span>,
<span class="ident">nocapture</span>: <span class="ident">bool</span>,
<span class="ident">testfn</span>: <span class="ident">Box</span><span class="op"><</span><span class="ident">FnBox</span>() <span class="op">+</span> <span class="ident">Send</span><span class="op">></span>,
) {
<span class="comment">// Buffer for capturing standard I/O</span>
<span class="kw">let</span> <span class="ident">data</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">Mutex</span>::<span class="ident">new</span>(<span class="ident">Vec</span>::<span class="ident">new</span>()));
<span class="kw">let</span> <span class="ident">data2</span> <span class="op">=</span> <span class="ident">data</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">name</span> <span class="op">=</span> <span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">runtest</span> <span class="op">=</span> <span class="kw">move</span> <span class="op">||</span> {
<span class="kw">let</span> <span class="ident">oldio</span> <span class="op">=</span> <span class="kw">if</span> <span class="op">!</span><span class="ident">nocapture</span> {
<span class="prelude-val">Some</span>((
<span class="ident">io</span>::<span class="ident">set_print</span>(<span class="prelude-val">Some</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">Sink</span>(<span class="ident">data2</span>.<span class="ident">clone</span>())))),
<span class="ident">io</span>::<span class="ident">set_panic</span>(<span class="prelude-val">Some</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">Sink</span>(<span class="ident">data2</span>)))),
))
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
};
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">catch_unwind</span>(<span class="ident">AssertUnwindSafe</span>(<span class="ident">testfn</span>));
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>((<span class="ident">printio</span>, <span class="ident">panicio</span>)) <span class="op">=</span> <span class="ident">oldio</span> {
<span class="ident">io</span>::<span class="ident">set_print</span>(<span class="ident">printio</span>);
<span class="ident">io</span>::<span class="ident">set_panic</span>(<span class="ident">panicio</span>);
};
<span class="kw">let</span> <span class="ident">test_result</span> <span class="op">=</span> <span class="ident">calc_result</span>(<span class="kw-2">&</span><span class="ident">desc</span>, <span class="ident">result</span>);
<span class="kw">let</span> <span class="ident">stdout</span> <span class="op">=</span> <span class="ident">data</span>.<span class="ident">lock</span>().<span class="ident">unwrap</span>().<span class="ident">to_vec</span>();
<span class="ident">monitor_ch</span>
.<span class="ident">send</span>((<span class="ident">desc</span>.<span class="ident">clone</span>(), <span class="ident">test_result</span>, <span class="ident">stdout</span>))
.<span class="ident">unwrap</span>();
};
<span class="comment">// If the platform is single-threaded we're just going to run</span>
<span class="comment">// the test synchronously, regardless of the concurrency</span>
<span class="comment">// level.</span>
<span class="kw">let</span> <span class="ident">supports_threads</span> <span class="op">=</span> <span class="op">!</span><span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"emscripten"</span>) <span class="op">&&</span> <span class="op">!</span><span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>);
<span class="kw">if</span> <span class="ident">supports_threads</span> {
<span class="kw">let</span> <span class="ident">cfg</span> <span class="op">=</span> <span class="ident">thread</span>::<span class="ident">Builder</span>::<span class="ident">new</span>().<span class="ident">name</span>(<span class="ident">name</span>.<span class="ident">as_slice</span>().<span class="ident">to_owned</span>());
<span class="ident">cfg</span>.<span class="ident">spawn</span>(<span class="ident">runtest</span>).<span class="ident">unwrap</span>();
} <span class="kw">else</span> {
<span class="ident">runtest</span>();
}
}
<span class="kw">match</span> <span class="ident">testfn</span> {
<span class="ident">DynBenchFn</span>(<span class="ident">bencher</span>) <span class="op">=></span> {
::<span class="ident">bench</span>::<span class="ident">benchmark</span>(<span class="ident">desc</span>, <span class="ident">monitor_ch</span>, <span class="ident">opts</span>.<span class="ident">nocapture</span>, <span class="op">|</span><span class="ident">harness</span><span class="op">|</span> {
<span class="ident">bencher</span>.<span class="ident">run</span>(<span class="ident">harness</span>)
});
}
<span class="ident">StaticBenchFn</span>(<span class="ident">benchfn</span>) <span class="op">=></span> {
::<span class="ident">bench</span>::<span class="ident">benchmark</span>(<span class="ident">desc</span>, <span class="ident">monitor_ch</span>, <span class="ident">opts</span>.<span class="ident">nocapture</span>, <span class="op">|</span><span class="ident">harness</span><span class="op">|</span> {
(<span class="ident">benchfn</span>.<span class="ident">clone</span>())(<span class="ident">harness</span>)
});
}
<span class="ident">DynTestFn</span>(<span class="ident">f</span>) <span class="op">=></span> {
<span class="kw">let</span> <span class="ident">cb</span> <span class="op">=</span> <span class="kw">move</span> <span class="op">||</span> <span class="ident">__rust_begin_short_backtrace</span>(<span class="ident">f</span>);
<span class="ident">run_test_inner</span>(<span class="ident">desc</span>, <span class="ident">monitor_ch</span>, <span class="ident">opts</span>.<span class="ident">nocapture</span>, <span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">cb</span>))
}
<span class="ident">StaticTestFn</span>(<span class="ident">f</span>) <span class="op">=></span> <span class="ident">run_test_inner</span>(
<span class="ident">desc</span>,
<span class="ident">monitor_ch</span>,
<span class="ident">opts</span>.<span class="ident">nocapture</span>,
<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> <span class="ident">__rust_begin_short_backtrace</span>(<span class="ident">f</span>)),
),
}
}
<span class="doccomment">/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.</span>
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">never</span>)]</span>
<span class="kw">fn</span> <span class="ident">__rust_begin_short_backtrace</span><span class="op"><</span><span class="ident">F</span>: <span class="ident">FnOnce</span>()<span class="op">></span>(<span class="ident">f</span>: <span class="ident">F</span>) {
<span class="ident">f</span>()
}
<span class="kw">fn</span> <span class="ident">calc_result</span>(<span class="ident">desc</span>: <span class="kw-2">&</span><span class="ident">TestDesc</span>, <span class="ident">task_result</span>: <span class="prelude-ty">Result</span><span class="op"><</span>(), <span class="ident">Box</span><span class="op"><</span><span class="ident">Any</span> <span class="op">+</span> <span class="ident">Send</span><span class="op">>></span>) <span class="op">-></span> <span class="ident">TestResult</span> {
<span class="kw">match</span> (<span class="kw-2">&</span><span class="ident">desc</span>.<span class="ident">should_panic</span>, <span class="ident">task_result</span>) {
(<span class="kw-2">&</span><span class="ident">ShouldPanic</span>::<span class="ident">No</span>, <span class="prelude-val">Ok</span>(())) <span class="op">|</span> (<span class="kw-2">&</span><span class="ident">ShouldPanic</span>::<span class="ident">Yes</span>, <span class="prelude-val">Err</span>(<span class="kw">_</span>)) <span class="op">=></span> <span class="ident">TrOk</span>,
(<span class="kw-2">&</span><span class="ident">ShouldPanic</span>::<span class="ident">YesWithMessage</span>(<span class="ident">msg</span>), <span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">err</span>)) <span class="op">=></span> {
<span class="kw">if</span> <span class="ident">err</span>.<span class="ident">downcast_ref</span>::<span class="op"><</span><span class="ident">String</span><span class="op">></span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">e</span><span class="op">|</span> <span class="kw-2">&</span><span class="kw-2">*</span><span class="kw-2">*</span><span class="ident">e</span>)
.<span class="ident">or_else</span>(<span class="op">||</span> <span class="ident">err</span>.<span class="ident">downcast_ref</span>::<span class="op"><</span><span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span><span class="op">></span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">e</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">e</span>))
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">e</span><span class="op">|</span> <span class="ident">e</span>.<span class="ident">contains</span>(<span class="ident">msg</span>))
.<span class="ident">unwrap_or</span>(<span class="bool-val">false</span>)
{
<span class="ident">TrOk</span>
} <span class="kw">else</span> {
<span class="kw">if</span> <span class="ident">desc</span>.<span class="ident">allow_fail</span> {
<span class="ident">TrAllowedFail</span>
} <span class="kw">else</span> {
<span class="ident">TrFailedMsg</span>(<span class="macro">format</span><span class="macro">!</span>(<span class="string">"Panic did not include expected string '{}'"</span>, <span class="ident">msg</span>))
}
}
}
<span class="kw">_</span> <span class="kw">if</span> <span class="ident">desc</span>.<span class="ident">allow_fail</span> <span class="op">=></span> <span class="ident">TrAllowedFail</span>,
<span class="kw">_</span> <span class="op">=></span> <span class="ident">TrFailed</span>,
}
}
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Clone</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">pub</span> <span class="kw">struct</span> <span class="ident">MetricMap</span>(<span class="ident">BTreeMap</span><span class="op"><</span><span class="ident">String</span>, <span class="ident">Metric</span><span class="op">></span>);
<span class="kw">impl</span> <span class="ident">MetricMap</span> {
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">new</span>() <span class="op">-></span> <span class="ident">MetricMap</span> {
<span class="ident">MetricMap</span>(<span class="ident">BTreeMap</span>::<span class="ident">new</span>())
}
<span class="doccomment">/// Insert a named `value` (+/- `noise`) metric into the map. The value</span>
<span class="doccomment">/// must be non-negative. The `noise` indicates the uncertainty of the</span>
<span class="doccomment">/// metric, which doubles as the "noise range" of acceptable</span>
<span class="doccomment">/// pairwise-regressions on this named value, when comparing from one</span>
<span class="doccomment">/// metric to the next using `compare_to_old`.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// If `noise` is positive, then it means this metric is of a value</span>
<span class="doccomment">/// you want to see grow smaller, so a change larger than `noise` in the</span>
<span class="doccomment">/// positive direction represents a regression.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// If `noise` is negative, then it means this metric is of a value</span>
<span class="doccomment">/// you want to see grow larger, so a change larger than `noise` in the</span>
<span class="doccomment">/// negative direction represents a regression.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">insert_metric</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="ident">name</span>: <span class="kw-2">&</span><span class="ident">str</span>, <span class="ident">value</span>: <span class="ident">f64</span>, <span class="ident">noise</span>: <span class="ident">f64</span>) {
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">Metric</span> { <span class="ident">value</span>, <span class="ident">noise</span> };
<span class="self">self</span>.<span class="number">0</span>.<span class="ident">insert</span>(<span class="ident">name</span>.<span class="ident">to_owned</span>(), <span class="ident">m</span>);
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">fmt_metrics</span>(<span class="kw-2">&</span><span class="self">self</span>) <span class="op">-></span> <span class="ident">String</span> {
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="self">self</span>.<span class="number">0</span>
.<span class="ident">iter</span>()
.<span class="ident">map</span>(<span class="op">|</span>(<span class="ident">k</span>, <span class="ident">v</span>)<span class="op">|</span> <span class="macro">format</span><span class="macro">!</span>(<span class="string">"{}: {} (+/- {})"</span>, <span class="kw-2">*</span><span class="ident">k</span>, <span class="ident">v</span>.<span class="ident">value</span>, <span class="ident">v</span>.<span class="ident">noise</span>))
.<span class="ident">collect</span>::<span class="op"><</span><span class="ident">Vec</span><span class="op"><</span><span class="kw">_</span><span class="op">>></span>();
<span class="ident">v</span>.<span class="ident">join</span>(<span class="string">", "</span>)
}
}
<span class="comment">// Benchmarking</span>
<span class="doccomment">/// A function that is opaque to the optimizer, to allow benchmarks to</span>
<span class="doccomment">/// pretend to use outputs to assist in avoiding dead-code</span>
<span class="doccomment">/// elimination.</span>
<span class="doccomment">///</span>
<span class="doccomment">/// This function is a no-op, and does not even read from `dummy`.</span>
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">not</span>(<span class="ident">any</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"asmjs"</span>, <span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>)))]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">black_box</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="ident">dummy</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">T</span> {
<span class="comment">// we need to "use" the argument in some way LLVM can't</span>
<span class="comment">// introspect.</span>
<span class="kw">unsafe</span> { <span class="macro">asm</span><span class="macro">!</span>(<span class="string">""</span> : : <span class="string">"r"</span>(<span class="kw-2">&</span><span class="ident">dummy</span>)) }
<span class="ident">dummy</span>
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">any</span>(<span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"asmjs"</span>, <span class="ident">target_arch</span> <span class="op">=</span> <span class="string">"wasm32"</span>))]</span>
<span class="attribute">#[<span class="ident">inline</span>(<span class="ident">never</span>)]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">black_box</span><span class="op"><</span><span class="ident">T</span><span class="op">></span>(<span class="ident">dummy</span>: <span class="ident">T</span>) <span class="op">-></span> <span class="ident">T</span> {
<span class="ident">dummy</span>
}
<span class="kw">impl</span> <span class="ident">Bencher</span> {
<span class="doccomment">/// Callback for benchmark functions to run in their body.</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">iter</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">F</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="kw-2">mut</span> <span class="ident">inner</span>: <span class="ident">F</span>)
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>() <span class="op">-></span> <span class="ident">T</span>,
{
<span class="kw">if</span> <span class="self">self</span>.<span class="ident">mode</span> <span class="op">==</span> <span class="ident">BenchMode</span>::<span class="ident">Single</span> {
<span class="ident">ns_iter_inner</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">inner</span>, <span class="number">1</span>);
<span class="kw">return</span>;
}
<span class="self">self</span>.<span class="ident">summary</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">iter</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">inner</span>));
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">bench</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>, <span class="kw-2">mut</span> <span class="ident">f</span>: <span class="ident">F</span>) <span class="op">-></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">stats</span>::<span class="ident">Summary</span><span class="op">></span>
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>),
{
<span class="ident">f</span>(<span class="self">self</span>);
<span class="kw">return</span> <span class="self">self</span>.<span class="ident">summary</span>;
}
}
<span class="kw">fn</span> <span class="ident">ns_from_dur</span>(<span class="ident">dur</span>: <span class="ident">Duration</span>) <span class="op">-></span> <span class="ident">u64</span> {
<span class="ident">dur</span>.<span class="ident">as_secs</span>() <span class="op">*</span> <span class="number">1_000_000_000</span> <span class="op">+</span> (<span class="ident">dur</span>.<span class="ident">subsec_nanos</span>() <span class="kw">as</span> <span class="ident">u64</span>)
}
<span class="kw">fn</span> <span class="ident">ns_iter_inner</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">F</span><span class="op">></span>(<span class="ident">inner</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">F</span>, <span class="ident">k</span>: <span class="ident">u64</span>) <span class="op">-></span> <span class="ident">u64</span>
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>() <span class="op">-></span> <span class="ident">T</span>,
{
<span class="kw">let</span> <span class="ident">start</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
<span class="kw">for</span> <span class="kw">_</span> <span class="kw">in</span> <span class="number">0</span>..<span class="ident">k</span> {
<span class="ident">black_box</span>(<span class="ident">inner</span>());
}
<span class="kw">return</span> <span class="ident">ns_from_dur</span>(<span class="ident">start</span>.<span class="ident">elapsed</span>());
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">iter</span><span class="op"><</span><span class="ident">T</span>, <span class="ident">F</span><span class="op">></span>(<span class="ident">inner</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">F</span>) <span class="op">-></span> <span class="ident">stats</span>::<span class="ident">Summary</span>
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>() <span class="op">-></span> <span class="ident">T</span>,
{
<span class="comment">// Initial bench run to get ballpark figure.</span>
<span class="kw">let</span> <span class="ident">ns_single</span> <span class="op">=</span> <span class="ident">ns_iter_inner</span>(<span class="ident">inner</span>, <span class="number">1</span>);
<span class="comment">// Try to estimate iter count for 1ms falling back to 1m</span>
<span class="comment">// iterations if first run took < 1ns.</span>
<span class="kw">let</span> <span class="ident">ns_target_total</span> <span class="op">=</span> <span class="number">1_000_000</span>; <span class="comment">// 1ms</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">ns_target_total</span> <span class="op">/</span> <span class="ident">cmp</span>::<span class="ident">max</span>(<span class="number">1</span>, <span class="ident">ns_single</span>);
<span class="comment">// if the first run took more than 1ms we don't want to just</span>
<span class="comment">// be left doing 0 iterations on every loop. The unfortunate</span>
<span class="comment">// side effect of not being able to do as many runs is</span>
<span class="comment">// automatically handled by the statistical analysis below</span>
<span class="comment">// (i.e. larger error bars).</span>
<span class="ident">n</span> <span class="op">=</span> <span class="ident">cmp</span>::<span class="ident">max</span>(<span class="number">1</span>, <span class="ident">n</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">total_run</span> <span class="op">=</span> <span class="ident">Duration</span>::<span class="ident">new</span>(<span class="number">0</span>, <span class="number">0</span>);
<span class="kw">let</span> <span class="ident">samples</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">f64</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0.0_f64</span>; <span class="number">50</span>];
<span class="kw">loop</span> {
<span class="kw">let</span> <span class="ident">loop_start</span> <span class="op">=</span> <span class="ident">Instant</span>::<span class="ident">now</span>();
<span class="kw">for</span> <span class="ident">p</span> <span class="kw">in</span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">*</span><span class="ident">samples</span> {
<span class="kw-2">*</span><span class="ident">p</span> <span class="op">=</span> <span class="ident">ns_iter_inner</span>(<span class="ident">inner</span>, <span class="ident">n</span>) <span class="kw">as</span> <span class="ident">f64</span> <span class="op">/</span> <span class="ident">n</span> <span class="kw">as</span> <span class="ident">f64</span>;
}
<span class="ident">stats</span>::<span class="ident">winsorize</span>(<span class="ident">samples</span>, <span class="number">5.0</span>);
<span class="kw">let</span> <span class="ident">summ</span> <span class="op">=</span> <span class="ident">stats</span>::<span class="ident">Summary</span>::<span class="ident">new</span>(<span class="ident">samples</span>);
<span class="kw">for</span> <span class="ident">p</span> <span class="kw">in</span> <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="kw-2">*</span><span class="ident">samples</span> {
<span class="kw">let</span> <span class="ident">ns</span> <span class="op">=</span> <span class="ident">ns_iter_inner</span>(<span class="ident">inner</span>, <span class="number">5</span> <span class="op">*</span> <span class="ident">n</span>);
<span class="kw-2">*</span><span class="ident">p</span> <span class="op">=</span> <span class="ident">ns</span> <span class="kw">as</span> <span class="ident">f64</span> <span class="op">/</span> (<span class="number">5</span> <span class="op">*</span> <span class="ident">n</span>) <span class="kw">as</span> <span class="ident">f64</span>;
}
<span class="ident">stats</span>::<span class="ident">winsorize</span>(<span class="ident">samples</span>, <span class="number">5.0</span>);
<span class="kw">let</span> <span class="ident">summ5</span> <span class="op">=</span> <span class="ident">stats</span>::<span class="ident">Summary</span>::<span class="ident">new</span>(<span class="ident">samples</span>);
<span class="kw">let</span> <span class="ident">loop_run</span> <span class="op">=</span> <span class="ident">loop_start</span>.<span class="ident">elapsed</span>();
<span class="comment">// If we've run for 100ms and seem to have converged to a</span>
<span class="comment">// stable median.</span>
<span class="kw">if</span> <span class="ident">loop_run</span> <span class="op">></span> <span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="number">100</span>) <span class="op">&&</span> <span class="ident">summ</span>.<span class="ident">median_abs_dev_pct</span> <span class="op"><</span> <span class="number">1.0</span>
<span class="op">&&</span> <span class="ident">summ</span>.<span class="ident">median</span> <span class="op">-</span> <span class="ident">summ5</span>.<span class="ident">median</span> <span class="op"><</span> <span class="ident">summ5</span>.<span class="ident">median_abs_dev</span>
{
<span class="kw">return</span> <span class="ident">summ5</span>;
}
<span class="ident">total_run</span> <span class="op">=</span> <span class="ident">total_run</span> <span class="op">+</span> <span class="ident">loop_run</span>;
<span class="comment">// Longest we ever run for is 3s.</span>
<span class="kw">if</span> <span class="ident">total_run</span> <span class="op">></span> <span class="ident">Duration</span>::<span class="ident">from_secs</span>(<span class="number">3</span>) {
<span class="kw">return</span> <span class="ident">summ5</span>;
}
<span class="comment">// If we overflow here just return the results so far. We check a</span>
<span class="comment">// multiplier of 10 because we're about to multiply by 2 and the</span>
<span class="comment">// next iteration of the loop will also multiply by 5 (to calculate</span>
<span class="comment">// the summ5 result)</span>
<span class="ident">n</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">n</span>.<span class="ident">checked_mul</span>(<span class="number">10</span>) {
<span class="prelude-val">Some</span>(<span class="kw">_</span>) <span class="op">=></span> <span class="ident">n</span> <span class="op">*</span> <span class="number">2</span>,
<span class="prelude-val">None</span> <span class="op">=></span> {
<span class="kw">return</span> <span class="ident">summ5</span>;
}
};
}
}
<span class="kw">pub</span> <span class="kw">mod</span> <span class="ident">bench</span> {
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">panic</span>::{<span class="ident">catch_unwind</span>, <span class="ident">AssertUnwindSafe</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">io</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::{<span class="ident">Arc</span>, <span class="ident">Mutex</span>};
<span class="kw">use</span> <span class="ident">stats</span>;
<span class="kw">use</span> <span class="kw">super</span>::{<span class="ident">BenchMode</span>, <span class="ident">BenchSamples</span>, <span class="ident">Bencher</span>, <span class="ident">MonitorMsg</span>, <span class="ident">Sender</span>, <span class="ident">Sink</span>, <span class="ident">TestDesc</span>, <span class="ident">TestResult</span>};
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">benchmark</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="ident">desc</span>: <span class="ident">TestDesc</span>, <span class="ident">monitor_ch</span>: <span class="ident">Sender</span><span class="op"><</span><span class="ident">MonitorMsg</span><span class="op">></span>, <span class="ident">nocapture</span>: <span class="ident">bool</span>, <span class="ident">f</span>: <span class="ident">F</span>)
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>),
{
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bs</span> <span class="op">=</span> <span class="ident">Bencher</span> {
<span class="ident">mode</span>: <span class="ident">BenchMode</span>::<span class="ident">Auto</span>,
<span class="ident">summary</span>: <span class="prelude-val">None</span>,
<span class="ident">bytes</span>: <span class="number">0</span>,
};
<span class="kw">let</span> <span class="ident">data</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">Mutex</span>::<span class="ident">new</span>(<span class="ident">Vec</span>::<span class="ident">new</span>()));
<span class="kw">let</span> <span class="ident">data2</span> <span class="op">=</span> <span class="ident">data</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">oldio</span> <span class="op">=</span> <span class="kw">if</span> <span class="op">!</span><span class="ident">nocapture</span> {
<span class="prelude-val">Some</span>((
<span class="ident">io</span>::<span class="ident">set_print</span>(<span class="prelude-val">Some</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">Sink</span>(<span class="ident">data2</span>.<span class="ident">clone</span>())))),
<span class="ident">io</span>::<span class="ident">set_panic</span>(<span class="prelude-val">Some</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">Sink</span>(<span class="ident">data2</span>)))),
))
} <span class="kw">else</span> {
<span class="prelude-val">None</span>
};
<span class="kw">let</span> <span class="ident">result</span> <span class="op">=</span> <span class="ident">catch_unwind</span>(<span class="ident">AssertUnwindSafe</span>(<span class="op">||</span> <span class="ident">bs</span>.<span class="ident">bench</span>(<span class="ident">f</span>)));
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>((<span class="ident">printio</span>, <span class="ident">panicio</span>)) <span class="op">=</span> <span class="ident">oldio</span> {
<span class="ident">io</span>::<span class="ident">set_print</span>(<span class="ident">printio</span>);
<span class="ident">io</span>::<span class="ident">set_panic</span>(<span class="ident">panicio</span>);
};
<span class="kw">let</span> <span class="ident">test_result</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">result</span> {
<span class="comment">//bs.bench(f) {</span>
<span class="prelude-val">Ok</span>(<span class="prelude-val">Some</span>(<span class="ident">ns_iter_summ</span>)) <span class="op">=></span> {
<span class="kw">let</span> <span class="ident">ns_iter</span> <span class="op">=</span> <span class="ident">cmp</span>::<span class="ident">max</span>(<span class="ident">ns_iter_summ</span>.<span class="ident">median</span> <span class="kw">as</span> <span class="ident">u64</span>, <span class="number">1</span>);
<span class="kw">let</span> <span class="ident">mb_s</span> <span class="op">=</span> <span class="ident">bs</span>.<span class="ident">bytes</span> <span class="op">*</span> <span class="number">1000</span> <span class="op">/</span> <span class="ident">ns_iter</span>;
<span class="kw">let</span> <span class="ident">bs</span> <span class="op">=</span> <span class="ident">BenchSamples</span> {
<span class="ident">ns_iter_summ</span>,
<span class="ident">mb_s</span>: <span class="ident">mb_s</span> <span class="kw">as</span> <span class="ident">usize</span>,
};
<span class="ident">TestResult</span>::<span class="ident">TrBench</span>(<span class="ident">bs</span>)
}
<span class="prelude-val">Ok</span>(<span class="prelude-val">None</span>) <span class="op">=></span> {
<span class="comment">// iter not called, so no data.</span>
<span class="comment">// FIXME: error in this case?</span>
<span class="kw">let</span> <span class="ident">samples</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="ident">f64</span>] <span class="op">=</span> <span class="kw-2">&</span><span class="kw-2">mut</span> [<span class="number">0.0_f64</span>; <span class="number">1</span>];
<span class="kw">let</span> <span class="ident">bs</span> <span class="op">=</span> <span class="ident">BenchSamples</span> {
<span class="ident">ns_iter_summ</span>: <span class="ident">stats</span>::<span class="ident">Summary</span>::<span class="ident">new</span>(<span class="ident">samples</span>),
<span class="ident">mb_s</span>: <span class="number">0</span>,
};
<span class="ident">TestResult</span>::<span class="ident">TrBench</span>(<span class="ident">bs</span>)
}
<span class="prelude-val">Err</span>(<span class="kw">_</span>) <span class="op">=></span> <span class="ident">TestResult</span>::<span class="ident">TrFailed</span>,
};
<span class="kw">let</span> <span class="ident">stdout</span> <span class="op">=</span> <span class="ident">data</span>.<span class="ident">lock</span>().<span class="ident">unwrap</span>().<span class="ident">to_vec</span>();
<span class="ident">monitor_ch</span>.<span class="ident">send</span>((<span class="ident">desc</span>, <span class="ident">test_result</span>, <span class="ident">stdout</span>)).<span class="ident">unwrap</span>();
}
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">run_once</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="ident">f</span>: <span class="ident">F</span>)
<span class="kw">where</span>
<span class="ident">F</span>: <span class="ident">FnMut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>),
{
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bs</span> <span class="op">=</span> <span class="ident">Bencher</span> {
<span class="ident">mode</span>: <span class="ident">BenchMode</span>::<span class="ident">Single</span>,
<span class="ident">summary</span>: <span class="prelude-val">None</span>,
<span class="ident">bytes</span>: <span class="number">0</span>,
};
<span class="ident">bs</span>.<span class="ident">bench</span>(<span class="ident">f</span>);
}
}
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">test</span>)]</span>
<span class="kw">mod</span> <span class="ident">tests</span> {
<span class="kw">use</span> <span class="ident">test</span>::{<span class="ident">filter_tests</span>, <span class="ident">parse_opts</span>, <span class="ident">run_test</span>, <span class="ident">DynTestFn</span>, <span class="ident">DynTestName</span>, <span class="ident">MetricMap</span>, <span class="ident">ShouldPanic</span>,
<span class="ident">StaticTestName</span>, <span class="ident">TestDesc</span>, <span class="ident">TestDescAndFn</span>, <span class="ident">TestOpts</span>, <span class="ident">TrFailed</span>, <span class="ident">TrFailedMsg</span>,
<span class="ident">TrIgnored</span>, <span class="ident">TrOk</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">mpsc</span>::<span class="ident">channel</span>;
<span class="kw">use</span> <span class="ident">bench</span>;
<span class="kw">use</span> <span class="ident">Bencher</span>;
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">do_not_run_ignored_tests</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {
<span class="macro">panic</span><span class="macro">!</span>();
}
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">true</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">!=</span> <span class="ident">TrOk</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">ignored_tests_result_in_ignored</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {}
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">true</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">==</span> <span class="ident">TrIgnored</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">test_should_panic</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {
<span class="macro">panic</span><span class="macro">!</span>();
}
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">Yes</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">==</span> <span class="ident">TrOk</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">test_should_panic_good_message</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {
<span class="macro">panic</span><span class="macro">!</span>(<span class="string">"an error message"</span>);
}
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">YesWithMessage</span>(<span class="string">"error message"</span>),
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">==</span> <span class="ident">TrOk</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">test_should_panic_bad_message</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {
<span class="macro">panic</span><span class="macro">!</span>(<span class="string">"an error message"</span>);
}
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="string">"foobar"</span>;
<span class="kw">let</span> <span class="ident">failed_msg</span> <span class="op">=</span> <span class="string">"Panic did not include expected string"</span>;
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">YesWithMessage</span>(<span class="ident">expected</span>),
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">==</span> <span class="ident">TrFailedMsg</span>(<span class="macro">format</span><span class="macro">!</span>(<span class="string">"{} '{}'"</span>, <span class="ident">failed_msg</span>, <span class="ident">expected</span>)));
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">test_should_panic_but_succeeds</span>() {
<span class="kw">fn</span> <span class="ident">f</span>() {}
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"whatever"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">Yes</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">f</span>)),
};
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="ident">run_test</span>(<span class="kw-2">&</span><span class="ident">TestOpts</span>::<span class="ident">new</span>(), <span class="bool-val">false</span>, <span class="ident">desc</span>, <span class="ident">tx</span>);
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">res</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">res</span> <span class="op">==</span> <span class="ident">TrFailed</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">fn</span> <span class="ident">parse_ignored_flag</span>() {
<span class="kw">let</span> <span class="ident">args</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[
<span class="string">"progname"</span>.<span class="ident">to_string</span>(),
<span class="string">"filter"</span>.<span class="ident">to_string</span>(),
<span class="string">"--ignored"</span>.<span class="ident">to_string</span>(),
];
<span class="kw">let</span> <span class="ident">opts</span> <span class="op">=</span> <span class="kw">match</span> <span class="ident">parse_opts</span>(<span class="kw-2">&</span><span class="ident">args</span>) {
<span class="prelude-val">Some</span>(<span class="prelude-val">Ok</span>(<span class="ident">o</span>)) <span class="op">=></span> <span class="ident">o</span>,
<span class="kw">_</span> <span class="op">=></span> <span class="macro">panic</span><span class="macro">!</span>(<span class="string">"Malformed arg in parse_ignored_flag"</span>),
};
<span class="macro">assert</span><span class="macro">!</span>((<span class="ident">opts</span>.<span class="ident">run_ignored</span>));
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">filter_for_ignored_option</span>() {
<span class="comment">// When we run ignored tests the test filter should filter out all the</span>
<span class="comment">// unignored tests and flip the ignore flag on the rest to false</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">opts</span> <span class="op">=</span> <span class="ident">TestOpts</span>::<span class="ident">new</span>();
<span class="ident">opts</span>.<span class="ident">run_tests</span> <span class="op">=</span> <span class="bool-val">true</span>;
<span class="ident">opts</span>.<span class="ident">run_ignored</span> <span class="op">=</span> <span class="bool-val">true</span>;
<span class="kw">let</span> <span class="ident">tests</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[
<span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"1"</span>),
<span class="ident">ignore</span>: <span class="bool-val">true</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> {})),
},
<span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"2"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> {})),
},
];
<span class="kw">let</span> <span class="ident">filtered</span> <span class="op">=</span> <span class="ident">filter_tests</span>(<span class="kw-2">&</span><span class="ident">opts</span>, <span class="ident">tests</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">filtered</span>.<span class="ident">len</span>(), <span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">filtered</span>[<span class="number">0</span>].<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">to_string</span>(), <span class="string">"1"</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">filtered</span>[<span class="number">0</span>].<span class="ident">desc</span>.<span class="ident">ignore</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">exact_filter_match</span>() {
<span class="kw">fn</span> <span class="ident">tests</span>() <span class="op">-></span> <span class="ident">Vec</span><span class="op"><</span><span class="ident">TestDescAndFn</span><span class="op">></span> {
<span class="macro">vec</span><span class="macro">!</span>[<span class="string">"base"</span>, <span class="string">"base::test"</span>, <span class="string">"base::test1"</span>, <span class="string">"base::test2"</span>]
.<span class="ident">into_iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">name</span><span class="op">|</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="ident">name</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="kw">move</span> <span class="op">||</span> {})),
})
.<span class="ident">collect</span>()
}
<span class="kw">let</span> <span class="ident">substr</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"base"</span>.<span class="ident">into</span>()),
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">substr</span>.<span class="ident">len</span>(), <span class="number">4</span>);
<span class="kw">let</span> <span class="ident">substr</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"bas"</span>.<span class="ident">into</span>()),
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">substr</span>.<span class="ident">len</span>(), <span class="number">4</span>);
<span class="kw">let</span> <span class="ident">substr</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"::test"</span>.<span class="ident">into</span>()),
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">substr</span>.<span class="ident">len</span>(), <span class="number">3</span>);
<span class="kw">let</span> <span class="ident">substr</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"base::test"</span>.<span class="ident">into</span>()),
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">substr</span>.<span class="ident">len</span>(), <span class="number">3</span>);
<span class="kw">let</span> <span class="ident">exact</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"base"</span>.<span class="ident">into</span>()),
<span class="ident">filter_exact</span>: <span class="bool-val">true</span>,
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">exact</span>.<span class="ident">len</span>(), <span class="number">1</span>);
<span class="kw">let</span> <span class="ident">exact</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"bas"</span>.<span class="ident">into</span>()),
<span class="ident">filter_exact</span>: <span class="bool-val">true</span>,
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">exact</span>.<span class="ident">len</span>(), <span class="number">0</span>);
<span class="kw">let</span> <span class="ident">exact</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"::test"</span>.<span class="ident">into</span>()),
<span class="ident">filter_exact</span>: <span class="bool-val">true</span>,
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">exact</span>.<span class="ident">len</span>(), <span class="number">0</span>);
<span class="kw">let</span> <span class="ident">exact</span> <span class="op">=</span> <span class="ident">filter_tests</span>(
<span class="kw-2">&</span><span class="ident">TestOpts</span> {
<span class="ident">filter</span>: <span class="prelude-val">Some</span>(<span class="string">"base::test"</span>.<span class="ident">into</span>()),
<span class="ident">filter_exact</span>: <span class="bool-val">true</span>,
..<span class="ident">TestOpts</span>::<span class="ident">new</span>()
},
<span class="ident">tests</span>(),
);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">exact</span>.<span class="ident">len</span>(), <span class="number">1</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">sort_tests</span>() {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">opts</span> <span class="op">=</span> <span class="ident">TestOpts</span>::<span class="ident">new</span>();
<span class="ident">opts</span>.<span class="ident">run_tests</span> <span class="op">=</span> <span class="bool-val">true</span>;
<span class="kw">let</span> <span class="ident">names</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[
<span class="string">"sha1::test"</span>.<span class="ident">to_string</span>(),
<span class="string">"isize::test_to_str"</span>.<span class="ident">to_string</span>(),
<span class="string">"isize::test_pow"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::do_not_run_ignored_tests"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::ignored_tests_result_in_ignored"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::first_free_arg_should_be_a_filter"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::parse_ignored_flag"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::filter_for_ignored_option"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::sort_tests"</span>.<span class="ident">to_string</span>(),
];
<span class="kw">let</span> <span class="ident">tests</span> <span class="op">=</span> {
<span class="kw">fn</span> <span class="ident">testfn</span>() {}
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">tests</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">new</span>();
<span class="kw">for</span> <span class="ident">name</span> <span class="kw">in</span> <span class="kw-2">&</span><span class="ident">names</span> {
<span class="kw">let</span> <span class="ident">test</span> <span class="op">=</span> <span class="ident">TestDescAndFn</span> {
<span class="ident">desc</span>: <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">DynTestName</span>((<span class="kw-2">*</span><span class="ident">name</span>).<span class="ident">clone</span>()),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
},
<span class="ident">testfn</span>: <span class="ident">DynTestFn</span>(<span class="ident">Box</span>::<span class="ident">new</span>(<span class="ident">testfn</span>)),
};
<span class="ident">tests</span>.<span class="ident">push</span>(<span class="ident">test</span>);
}
<span class="ident">tests</span>
};
<span class="kw">let</span> <span class="ident">filtered</span> <span class="op">=</span> <span class="ident">filter_tests</span>(<span class="kw-2">&</span><span class="ident">opts</span>, <span class="ident">tests</span>);
<span class="kw">let</span> <span class="ident">expected</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[
<span class="string">"isize::test_pow"</span>.<span class="ident">to_string</span>(),
<span class="string">"isize::test_to_str"</span>.<span class="ident">to_string</span>(),
<span class="string">"sha1::test"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::do_not_run_ignored_tests"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::filter_for_ignored_option"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::first_free_arg_should_be_a_filter"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::ignored_tests_result_in_ignored"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::parse_ignored_flag"</span>.<span class="ident">to_string</span>(),
<span class="string">"test::sort_tests"</span>.<span class="ident">to_string</span>(),
];
<span class="kw">for</span> (<span class="ident">a</span>, <span class="ident">b</span>) <span class="kw">in</span> <span class="ident">expected</span>.<span class="ident">iter</span>().<span class="ident">zip</span>(<span class="ident">filtered</span>) {
<span class="macro">assert</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">a</span> <span class="op">==</span> <span class="ident">b</span>.<span class="ident">desc</span>.<span class="ident">name</span>.<span class="ident">to_string</span>());
}
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_metricmap_compare</span>() {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">m1</span> <span class="op">=</span> <span class="ident">MetricMap</span>::<span class="ident">new</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">m2</span> <span class="op">=</span> <span class="ident">MetricMap</span>::<span class="ident">new</span>();
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-noise"</span>, <span class="number">1000.0</span>, <span class="number">200.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-noise"</span>, <span class="number">1100.0</span>, <span class="number">200.0</span>);
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-first-noise"</span>, <span class="number">1000.0</span>, <span class="number">2.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-second-noise"</span>, <span class="number">1000.0</span>, <span class="number">2.0</span>);
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-downwards-but-regressed"</span>, <span class="number">1000.0</span>, <span class="number">10.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-downwards-but-regressed"</span>, <span class="number">2000.0</span>, <span class="number">10.0</span>);
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-downwards-and-improved"</span>, <span class="number">2000.0</span>, <span class="number">10.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-downwards-and-improved"</span>, <span class="number">1000.0</span>, <span class="number">10.0</span>);
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-upwards-but-regressed"</span>, <span class="number">2000.0</span>, <span class="op">-</span><span class="number">10.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-upwards-but-regressed"</span>, <span class="number">1000.0</span>, <span class="op">-</span><span class="number">10.0</span>);
<span class="ident">m1</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-upwards-and-improved"</span>, <span class="number">1000.0</span>, <span class="op">-</span><span class="number">10.0</span>);
<span class="ident">m2</span>.<span class="ident">insert_metric</span>(<span class="string">"in-both-want-upwards-and-improved"</span>, <span class="number">2000.0</span>, <span class="op">-</span><span class="number">10.0</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_bench_once_no_iter</span>() {
<span class="kw">fn</span> <span class="ident">f</span>(<span class="kw">_</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>) {}
<span class="ident">bench</span>::<span class="ident">run_once</span>(<span class="ident">f</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_bench_once_iter</span>() {
<span class="kw">fn</span> <span class="ident">f</span>(<span class="ident">b</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>) {
<span class="ident">b</span>.<span class="ident">iter</span>(<span class="op">||</span> {})
}
<span class="ident">bench</span>::<span class="ident">run_once</span>(<span class="ident">f</span>);
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_bench_no_iter</span>() {
<span class="kw">fn</span> <span class="ident">f</span>(<span class="kw">_</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>) {}
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"f"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
};
::<span class="ident">bench</span>::<span class="ident">benchmark</span>(<span class="ident">desc</span>, <span class="ident">tx</span>, <span class="bool-val">true</span>, <span class="ident">f</span>);
<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
}
<span class="attribute">#[<span class="ident">test</span>]</span>
<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">test_bench_iter</span>() {
<span class="kw">fn</span> <span class="ident">f</span>(<span class="ident">b</span>: <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">Bencher</span>) {
<span class="ident">b</span>.<span class="ident">iter</span>(<span class="op">||</span> {})
}
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">channel</span>();
<span class="kw">let</span> <span class="ident">desc</span> <span class="op">=</span> <span class="ident">TestDesc</span> {
<span class="ident">name</span>: <span class="ident">StaticTestName</span>(<span class="string">"f"</span>),
<span class="ident">ignore</span>: <span class="bool-val">false</span>,
<span class="ident">should_panic</span>: <span class="ident">ShouldPanic</span>::<span class="ident">No</span>,
<span class="ident">allow_fail</span>: <span class="bool-val">false</span>,
};
::<span class="ident">bench</span>::<span class="ident">benchmark</span>(<span class="ident">desc</span>, <span class="ident">tx</span>, <span class="bool-val">true</span>, <span class="ident">f</span>);
<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="ident">unwrap</span>();
}
}
</pre>
</section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g. <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g. <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g. <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../../";window.currentCrate = "test";</script><script src="../../aliases.js"></script><script src="../../main.js"></script><script defer src="../../search-index.js"></script></body></html>
distrib
>
Mageia
>
6
>
armv7hl
>
media
>
core-updates
>
by-pkgid
>
4e2dbb669434a7691662cb2f0ad38972
>
files
>
11936
