'}),Yt=r({},Wt.DefaultType,{content:"(string|element|function)"}),$t={HIDE:"hide.bs.popover",HIDDEN:"hidden.bs.popover",SHOW:"show.bs.popover",SHOWN:"shown.bs.popover",INSERTED:"inserted.bs.popover",CLICK:"click.bs.popover",FOCUSIN:"focusin.bs.popover",FOCUSOUT:"focusout.bs.popover",MOUSEENTER:"mouseenter.bs.popover",MOUSELEAVE:"mouseleave.bs.popover"},Jt=function(t){var e,n;function i(){return t.apply(this,arguments)||this}n=t,(e=i).prototype=Object.create(n.prototype),e.prototype.constructor=e,u(e,n);var a=i.prototype;return a.isWithContent=function(){return this.getTitle()||this._getContent()},a.addAttachmentClass=function(t){o.default(this.getTipElement()).addClass("bs-popover-"+t)},a.getTipElement=function(){return this.tip=this.tip||o.default(this.config.template)[0],this.tip},a.setContent=function(){var t=o.default(this.getTipElement());this.setElementContent(t.find(".popover-header"),this.getTitle());var e=this._getContent();"function"==typeof e&&(e=e.call(this.element)),this.setElementContent(t.find(".popover-body"),e),t.removeClass("fade show")},a._getContent=function(){return this.element.getAttribute("data-content")||this.config.content},a._cleanTipClass=function(){var t=o.default(this.getTipElement()),e=t.attr("class").match(Kt);null!==e&&e.length>0&&t.removeClass(e.join(""))},i._jQueryInterface=function(t){return this.each((function(){var e=o.default(this).data(Vt),n="object"==typeof t?t:null;if((e||!/dispose|hide/.test(t))&&(e||(e=new i(this,n),o.default(this).data(Vt,e)),"string"==typeof t)){if("undefined"==typeof e[t])throw new TypeError('No method named "'+t+'"');e[t]()}}))},l(i,null,[{key:"VERSION",get:function(){return"4.6.1"}},{key:"Default",get:function(){return Xt}},{key:"NAME",get:function(){return"popover"}},{key:"DATA_KEY",get:function(){return Vt}},{key:"Event",get:function(){return $t}},{key:"EVENT_KEY",get:function(){return".bs.popover"}},{key:"DefaultType",get:function(){return Yt}}]),i}(Wt);o.default.fn.popover=Jt._jQueryInterface,o.default.fn.popover.Constructor=Jt,o.default.fn.popover.noConflict=function(){return o.default.fn.popover=zt,Jt._jQueryInterface};var Gt="scrollspy",Zt="bs.scrollspy",te=o.default.fn[Gt],ee="active",ne="position",ie=".nav, .list-group",oe={offset:10,method:"auto",target:""},ae={offset:"number",method:"string",target:"(string|element)"},se=function(){function t(t,e){var n=this;this._element=t,this._scrollElement="BODY"===t.tagName?window:t,this._config=this._getConfig(e),this._selector=this._config.target+" .nav-link,"+this._config.target+" .list-group-item,"+this._config.target+" .dropdown-item",this._offsets=[],this._targets=[],this._activeTarget=null,this._scrollHeight=0,o.default(this._scrollElement).on("scroll.bs.scrollspy",(function(t){return n._process(t)})),this.refresh(),this._process()}var e=t.prototype;return e.refresh=function(){var t=this,e=this._scrollElement===this._scrollElement.window?"offset":ne,n="auto"===this._config.method?e:this._config.method,i=n===ne?this._getScrollTop():0;this._offsets=[],this._targets=[],this._scrollHeight=this._getScrollHeight(),[].slice.call(document.querySelectorAll(this._selector)).map((function(t){var e,a=d.getSelectorFromElement(t);if(a&&(e=document.querySelector(a)),e){var s=e.getBoundingClientRect();if(s.width||s.height)return[o.default(e)[n]().top+i,a]}return null})).filter((function(t){return t})).sort((function(t,e){return t[0]-e[0]})).forEach((function(e){t._offsets.push(e[0]),t._targets.push(e[1])}))},e.dispose=function(){o.default.removeData(this._element,Zt),o.default(this._scrollElement).off(".bs.scrollspy"),this._element=null,this._scrollElement=null,this._config=null,this._selector=null,this._offsets=null,this._targets=null,this._activeTarget=null,this._scrollHeight=null},e._getConfig=function(t){if("string"!=typeof(t=r({},oe,"object"==typeof t&&t?t:{})).target&&d.isElement(t.target)){var e=o.default(t.target).attr("id");e||(e=d.getUID(Gt),o.default(t.target).attr("id",e)),t.target="#"+e}return d.typeCheckConfig(Gt,t,ae),t},e._getScrollTop=function(){return this._scrollElement===window?this._scrollElement.pageYOffset:this._scrollElement.scrollTop},e._getScrollHeight=function(){return this._scrollElement.scrollHeight||Math.max(document.body.scrollHeight,document.documentElement.scrollHeight)},e._getOffsetHeight=function(){return this._scrollElement===window?window.innerHeight:this._scrollElement.getBoundingClientRect().height},e._process=function(){var t=this._getScrollTop()+this._config.offset,e=this._getScrollHeight(),n=this._config.offset+e-this._getOffsetHeight();if(this._scrollHeight!==e&&this.refresh(),t>=n){var i=this._targets[this._targets.length-1];this._activeTarget!==i&&this._activate(i)}else{if(this._activeTarget&&t
| open: | "+b.yAxis.tickFormat()(c.open)+" |
| close: | "+b.yAxis.tickFormat()(c.close)+" |
| high | "+b.yAxis.tickFormat()(c.high)+" |
| low: | "+b.yAxis.tickFormat()(c.low)+" |
| open: | "+b.yAxis.tickFormat()(c.open)+" |
| close: | "+b.yAxis.tickFormat()(c.close)+" |
| high | "+b.yAxis.tickFormat()(c.high)+" |
| low: | "+b.yAxis.tickFormat()(c.low)+" |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/app/dashboard.html b/build/coverage/app/dashboard.html
new file mode 100644
index 00000000..9a69d7d0
--- /dev/null
+++ b/build/coverage/app/dashboard.html
@@ -0,0 +1,293 @@
+
+
+
+
+
+
+
+
+
+| + | Code Coverage |
+ |||||||||
| + | Lines |
+ Functions and Methods |
+ Classes and Traits |
+ |||||||
| Total | +
+
+
+ |
+ 0.00% |
+ 0 / 21 |
+
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+ CRAP | +
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| ServiceInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 21 |
+
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+ 110 | +
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| checkIfMultiple | +
+
+
+ |
+ 0.00% |
+ 0 / 5 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 20 | ++ | ||
| checkIfContainsMultiple | +
+
+
+ |
+ 0.00% |
+ 0 / 7 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 12 | ++ | ||
| verifyNumberIsInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| sumOfAllDigits | +
+
+
+ |
+ 0.00% |
+ 0 / 6 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 6 | ++ | ||
| 1 | <?php |
| 2 | namespace App; |
| 3 | |
| 4 | class ServiceInfQixFoo |
| 5 | { |
| 6 | |
| 7 | private array $infQixFoo = [ |
| 8 | 'Inf' => 8, |
| 9 | 'Qix' => 7, |
| 10 | 'Foo' => 3 |
| 11 | ]; |
| 12 | |
| 13 | private string $separator = '; '; |
| 14 | |
| 15 | |
| 16 | public function checkIfMultiple(int $number): string |
| 17 | { |
| 18 | $result = ''; |
| 19 | foreach ($this->infQixFoo as $key => $value){ |
| 20 | if($number % $value === 0){ |
| 21 | $result .= $key . $this->separator; |
| 22 | } |
| 23 | } |
| 24 | |
| 25 | return (strlen($result) === 0) ? $number : rtrim($result, '; '); |
| 26 | } |
| 27 | |
| 28 | public function checkIfContainsMultiple(int $number): string |
| 29 | { |
| 30 | $result = ''; |
| 31 | $digits = str_split($number, 1); |
| 32 | |
| 33 | foreach ($digits as $digit){ |
| 34 | if(in_array($digit, $this->infQixFoo)){ |
| 35 | $key = array_search($digit, $this->infQixFoo); |
| 36 | $result .= $key . $this->separator; |
| 37 | } |
| 38 | } |
| 39 | |
| 40 | return rtrim($result, '; '); |
| 41 | } |
| 42 | |
| 43 | public function verifyNumberIsInfQixFoo(int $number): string |
| 44 | { |
| 45 | $result = $this->checkIfMultiple($number) . '; '; |
| 46 | $result .= $this->checkIfContainsMultiple($number); |
| 47 | |
| 48 | return rtrim($result, '; '); |
| 49 | } |
| 50 | |
| 51 | public function sumOfAllDigits(int $number): string |
| 52 | { |
| 53 | $multiple = $this->infQixFoo['Inf']; |
| 54 | $digits = str_split($number, 1); |
| 55 | $sum = array_sum($digits); |
| 56 | |
| 57 | if($sum % $multiple === 0){ |
| 58 | return $this->verifyNumberIsInfQixFoo($number) . array_search($multiple, $this->infQixFoo); |
| 59 | } else{ |
| 60 | return $this->verifyNumberIsInfQixFoo($number); |
| 61 | } |
| 62 | } |
| 63 | } |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/app/index.html b/build/coverage/app/index.html
new file mode 100644
index 00000000..32c391d9
--- /dev/null
+++ b/build/coverage/app/index.html
@@ -0,0 +1,119 @@
+
+
+
+
+
+
+
+
+ Classes
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+
+ | Class | +Coverage | +
|---|---|
| App\ServiceInfQixFoo | 0% |
+
+ Project Risks
+
+
+
+
+
+ | Class | +CRAP | +
|---|---|
| App\ServiceInfQixFoo | 110 |
+
+
+
+ Methods
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+
+ | Method | +Coverage | +
|---|---|
| checkIfMultiple | 0% |
| checkIfContainsMultiple | 0% |
| verifyNumberIsInfQixFoo | 0% |
| sumOfAllDigits | 0% |
+
+ Project Risks
+
+
+
+
+
+ | Method | +CRAP | +
|---|---|
| checkIfMultiple | 20 |
| checkIfContainsMultiple | 12 |
| sumOfAllDigits | 6 |
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/dashboard.html b/build/coverage/dashboard.html
new file mode 100644
index 00000000..410ecda9
--- /dev/null
+++ b/build/coverage/dashboard.html
@@ -0,0 +1,1488 @@
+
+
+
+
+
+
+
+
+
+
+ | + | Code Coverage |
+ ||||||||
| + | Lines |
+ Functions and Methods |
+ Classes and Traits |
+ ||||||
| Total | +
+
+
+ |
+ 0.00% |
+ 0 / 21 |
+
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
 ServiceInfQixFoo.php |
+
+
+
+ |
+ 0.00% |
+ 0 / 21 |
+
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/index.html b/build/coverage/index.html
new file mode 100644
index 00000000..512257bd
--- /dev/null
+++ b/build/coverage/index.html
@@ -0,0 +1,174 @@
+
+
+
+
+
+
+
+
+ Classes
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+ Project Risks
+
+
+
+
+
+
+ Methods
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+ Project Risks
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/tests/ServiceInfQixFooTest.php.html b/build/coverage/tests/ServiceInfQixFooTest.php.html
new file mode 100644
index 00000000..b2320000
--- /dev/null
+++ b/build/coverage/tests/ServiceInfQixFooTest.php.html
@@ -0,0 +1,2112 @@
+
+
+
+
+
+
+
+
+
+
+ | + | Code Coverage |
+ ||||||||
| + | Lines |
+ Functions and Methods |
+ Classes and Traits |
+ ||||||
| Total | +
+
+
+ |
+ 0.20% |
+ 10 / 4926 |
+
+
+
+ |
+ 1.15% |
+ 12 / 1043 |
+
+
+
+ |
+ 0.00% |
+ 0 / 32 |
+
 app |
+
+
+
+ |
+ 0.00% |
+ 0 / 21 |
+
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| tests |
+
+
+
+ |
+ 0.45% |
+ 1 / 222 |
+
+
+
+ |
+ 0.00% |
+ 0 / 65 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| vendor |
+
+
+
+ |
+ 0.19% |
+ 9 / 4683 |
+
+
+
+ |
+ 1.23% |
+ 12 / 974 |
+
+
+
+ |
+ 0.00% |
+ 0 / 30 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/tests/dashboard.html b/build/coverage/tests/dashboard.html
new file mode 100644
index 00000000..af93d013
--- /dev/null
+++ b/build/coverage/tests/dashboard.html
@@ -0,0 +1,350 @@
+
+
+
+
+
+
+
+
+
+| + | Code Coverage |
+ |||||||||
| + | Lines |
+ Functions and Methods |
+ Classes and Traits |
+ |||||||
| Total | +
+
+
+ |
+ 0.45% |
+ 1 / 222 |
+
+
+
+ |
+ 0.00% |
+ 0 / 65 |
+ CRAP | +
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| ServiceInfQixFooTest | +
+
+
+ |
+ 0.00% |
+ 0 / 221 |
+
+
+
+ |
+ 0.00% |
+ 0 / 65 |
+ 4290 | +
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| testMultipleOfEightShouldReturnInf | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenShouldReturnQix | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeShouldReturnFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenShouldReturnInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeShouldReturnInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeShouldReturnQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeShouldReturnInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleShouldReturnNumber | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsEightShouldReturnInf | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsSevenShouldReturnQix | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsThreeShouldReturnFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 4 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsEightAndSevenShouldReturnInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 5 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsEightAndThreeShouldReturnInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 5 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsSevenAndThreeShouldReturnQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 5 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testNumberContainsThreeEightAndSevenShouldReturnFooInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 10 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsThreeShouldReturnInfAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsSevenShouldReturnInfAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsEightShouldReturnInfAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsEightAndSevenShouldReturnInfAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsEightAndThreeShouldReturnInfAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsSevenAndThreeShouldReturnInfAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightContainsEightSevenAndThreeShouldReturnInfAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 7 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsEightShouldReturnQixAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsSevenShouldReturnQixAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsThreeShouldReturnQixAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsEightAndSevenShouldReturnQixAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsEightAndThreeShouldReturnQixAppendFooInf | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsSevenAndThreeShouldReturnQixAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenContainsThreeEightAndSevenShouldReturnQixAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 7 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsEightShouldReturnFooAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsSevenShouldReturnFooAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsTreeShouldReturnFooAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsEightAndSevenShouldReturnFooAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsEightAndTreeShouldReturnFooAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsSevenAndThreeShouldReturnFooAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfThreeContainsEightSevenAndThreeShouldReturnFooAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 7 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsEightShouldReturnInfQixAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsEightShouldReturnInfFooAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsEightShouldReturnQixFooAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsEightShouldReturnInfQixFooAppendInf | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsSevenShouldReturnInfQixAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsSevenShouldReturnInfFooAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsSevenShouldReturnQixFooAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsSevenShouldReturnInfQixFooAppendQix | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsThreeShouldReturnInfQixAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsThreeShouldReturnInfFooAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsThreeShouldReturnQixFooAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsThreeShouldReturnInfQixFooAppendFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 2 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsEightAndSevenShouldReturnInfQixAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsEightAndThreeShouldReturnInfQixAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsSevenAndThreeShouldReturnInfQixAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndSevenContainsEightSevenAndThreeShouldReturnInfQixAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsEightAndSevenShouldReturnInfFooAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsEightAndThreeShouldReturnInfFooAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsSevenAndThreeShouldReturnInfFooAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightAndThreeContainsEightSevenAndTreeShouldReturnInfFooAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsEightAndSevenShouldReturnQixFooAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsEightAndThreeShouldReturnQixFooAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsSevenAndThreeShouldReturnQixFooAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfSevenAndThreeContainsEightSevenAndThreeShouldReturnQixFooAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsEightAndSevenShouldReturnInfQixFooAppendInfQix | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsEightAndThreeShouldReturnInfQixFooAppendInfFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsSevenAndThreeShouldReturnInfQixFooAppendQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testMultipleOfEightSevenAndThreeContainsEightSevenAndThreeShouldReturnInfQixFooAppendInfQixFoo | +
+
+
+ |
+ 0.00% |
+ 0 / 3 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| testSumOfAllDigitsIsMultipleOfEight | +
+
+
+ |
+ 0.00% |
+ 0 / 5 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+ 2 | ++ | ||
| 1 | <?php |
| 2 | |
| 3 | namespace Tests; |
| 4 | |
| 5 | /** Following part until the Class and after the class, is implemented for the Code coverage report. |
| 6 | * For testing purposes, the code outside the Class should be commented out. |
| 7 | */ |
| 8 | require '../vendor/autoload.php'; |
| 9 | require '../app/ServiceInfQixFoo.php'; |
| 10 | |
| 11 | use App\ServiceInfQixFoo; |
| 12 | use PHPUnit\Framework\TestCase; |
| 13 | use SebastianBergmann\CodeCoverage\Filter; |
| 14 | use SebastianBergmann\CodeCoverage\Driver\Selector; |
| 15 | use SebastianBergmann\CodeCoverage\CodeCoverage; |
| 16 | use SebastianBergmann\CodeCoverage\Report\Html\Facade as HtmlReport; |
| 17 | |
| 18 | $filter = new Filter; |
| 19 | $filter->includeFile('app/ServiceInfQixFoo.php'); |
| 20 | |
| 21 | $coverage = new CodeCoverage( |
| 22 | (new Selector)->forLineCoverage($filter), |
| 23 | $filter |
| 24 | ); |
| 25 | |
| 26 | $coverage->start('ServiceInfQixFoo'); |
| 27 | |
| 28 | class ServiceInfQixFooTest extends TestCase |
| 29 | { |
| 30 | /** |
| 31 | * STEP 4: CHECKING MULTIPLES OF 8 (INF), 7 (QIX) AND 3 (FOO) |
| 32 | */ |
| 33 | /* multiple 8 */ |
| 34 | public function testMultipleOfEightShouldReturnInf() |
| 35 | { |
| 36 | $stepFour = new ServiceInfQixFoo(); |
| 37 | $this->assertSame('Inf', $stepFour->checkIfMultiple(8)); |
| 38 | $this->assertSame('Inf', $stepFour->checkIfMultiple(16)); |
| 39 | $this->assertSame('Inf', $stepFour->checkIfMultiple(88)); |
| 40 | } |
| 41 | /* multiple 7 */ |
| 42 | public function testMultipleOfSevenShouldReturnQix() |
| 43 | { |
| 44 | $stepFour = new ServiceInfQixFoo(); |
| 45 | $this->assertSame('Qix', $stepFour->checkIfMultiple(7)); |
| 46 | $this->assertSame('Qix', $stepFour->checkIfMultiple(77)); |
| 47 | $this->assertSame('Qix', $stepFour->checkIfMultiple(539)); |
| 48 | } |
| 49 | /* multiple 3 */ |
| 50 | public function testMultipleOfThreeShouldReturnFoo() |
| 51 | { |
| 52 | $stepFour = new ServiceInfQixFoo(); |
| 53 | $this->assertSame('Foo', $stepFour->checkIfMultiple(3)); |
| 54 | $this->assertSame('Foo', $stepFour->checkIfMultiple(99)); |
| 55 | $this->assertSame('Foo', $stepFour->checkIfMultiple(117)); |
| 56 | } |
| 57 | /* multiple 8-7 */ |
| 58 | public function testMultipleOfEightAndSevenShouldReturnInfQix() |
| 59 | { |
| 60 | $stepFour = new ServiceInfQixFoo(); |
| 61 | $this->assertSame('Inf; Qix', $stepFour->checkIfMultiple(56)); |
| 62 | $this->assertSame('Inf; Qix', $stepFour->checkIfMultiple(448)); |
| 63 | $this->assertSame('Inf; Qix', $stepFour->checkIfMultiple(1568)); |
| 64 | } |
| 65 | /* multiple 8-3 */ |
| 66 | public function testMultipleOfEightAndThreeShouldReturnInfFoo() |
| 67 | { |
| 68 | $stepFour = new ServiceInfQixFoo(); |
| 69 | $this->assertSame('Inf; Foo', $stepFour->checkIfMultiple(24)); |
| 70 | $this->assertSame('Inf; Foo', $stepFour->checkIfMultiple(192)); |
| 71 | $this->assertSame('Inf; Foo', $stepFour->checkIfMultiple(576)); |
| 72 | } |
| 73 | /* multiple 7-3 */ |
| 74 | public function testMultipleOfSevenAndThreeShouldReturnQixFoo() |
| 75 | { |
| 76 | $stepFour = new ServiceInfQixFoo(); |
| 77 | $this->assertSame('Qix; Foo', $stepFour->checkIfMultiple(21)); |
| 78 | $this->assertSame('Qix; Foo', $stepFour->checkIfMultiple(147)); |
| 79 | $this->assertSame('Qix; Foo', $stepFour->checkIfMultiple(441)); |
| 80 | } |
| 81 | /* multiple 8-7-3 */ |
| 82 | public function testMultipleOfEightSevenAndThreeShouldReturnInfQixFoo() |
| 83 | { |
| 84 | $stepFour = new ServiceInfQixFoo(); |
| 85 | $this->assertSame('Inf; Qix; Foo', $stepFour->checkIfMultiple(168)); |
| 86 | $this->assertSame('Inf; Qix; Foo', $stepFour->checkIfMultiple(1512)); |
| 87 | $this->assertSame('Inf; Qix; Foo', $stepFour->checkIfMultiple(4536)); |
| 88 | } |
| 89 | /* number */ |
| 90 | public function testMultipleShouldReturnNumber() |
| 91 | { |
| 92 | $stepFour = new ServiceInfQixFoo(); |
| 93 | $this->assertSame('4', $stepFour->checkIfMultiple(4)); |
| 94 | $this->assertSame('11', $stepFour->checkIfMultiple(11)); |
| 95 | $this->assertSame('127', $stepFour->checkIfMultiple(127)); |
| 96 | } |
| 97 | |
| 98 | |
| 99 | |
| 100 | /** |
| 101 | * NUMBERS CONTAINING 8, 7, AND/OR 3 |
| 102 | */ |
| 103 | /* contains 8 */ |
| 104 | public function testNumberContainsEightShouldReturnInf() |
| 105 | { |
| 106 | $stepFour = new ServiceInfQixFoo(); |
| 107 | $this->assertSame('Inf', $stepFour->checkIfContainsMultiple(18)); |
| 108 | $this->assertSame('Inf; Inf', $stepFour->checkIfContainsMultiple(88)); |
| 109 | $this->assertSame('Inf; Inf; Inf', $stepFour->checkIfContainsMultiple(81868)); |
| 110 | } |
| 111 | /* contains 7 */ |
| 112 | public function testNumberContainsSevenShouldReturnQix() |
| 113 | { |
| 114 | $stepFour = new ServiceInfQixFoo(); |
| 115 | $this->assertSame('Qix', $stepFour->checkIfContainsMultiple(17)); |
| 116 | $this->assertSame('Qix; Qix', $stepFour->checkIfContainsMultiple(77)); |
| 117 | $this->assertSame('Qix; Qix; Qix', $stepFour->checkIfContainsMultiple(7677)); |
| 118 | } |
| 119 | /* contains 3 */ |
| 120 | public function testNumberContainsThreeShouldReturnFoo() |
| 121 | { |
| 122 | $stepFour = new ServiceInfQixFoo(); |
| 123 | $this->assertSame('Foo', $stepFour->checkIfContainsMultiple(13)); |
| 124 | $this->assertSame('Foo; Foo', $stepFour->checkIfContainsMultiple(33)); |
| 125 | $this->assertSame('Foo; Foo; Foo', $stepFour->checkIfContainsMultiple(343663)); |
| 126 | } |
| 127 | /* contains 8-7 */ |
| 128 | public function testNumberContainsEightAndSevenShouldReturnInfQix() |
| 129 | { |
| 130 | $stepFour = new ServiceInfQixFoo(); |
| 131 | $this->assertSame('Inf; Qix', $stepFour->checkIfContainsMultiple(87)); |
| 132 | $this->assertSame('Qix; Inf', $stepFour->checkIfContainsMultiple(7008)); |
| 133 | $this->assertSame('Qix; Inf; Qix', $stepFour->checkIfContainsMultiple(708070)); |
| 134 | $this->assertSame('Qix; Inf; Inf', $stepFour->checkIfContainsMultiple(708111118)); |
| 135 | } |
| 136 | /* contains 8-3 */ |
| 137 | public function testNumberContainsEightAndThreeShouldReturnInfFoo() |
| 138 | { |
| 139 | $stepFour = new ServiceInfQixFoo(); |
| 140 | $this->assertSame('Foo; Inf', $stepFour->checkIfContainsMultiple(38)); |
| 141 | $this->assertSame('Inf; Foo', $stepFour->checkIfContainsMultiple(8036)); |
| 142 | $this->assertSame('Inf; Inf; Foo; Inf', $stepFour->checkIfContainsMultiple(883448)); |
| 143 | $this->assertSame('Inf; Foo; Foo', $stepFour->checkIfContainsMultiple(822303)); |
| 144 | } |
| 145 | /* contains 7-3 */ |
| 146 | public function testNumberContainsSevenAndThreeShouldReturnQixFoo() |
| 147 | { |
| 148 | $stepFour = new ServiceInfQixFoo(); |
| 149 | $this->assertSame('Foo; Qix', $stepFour->checkIfContainsMultiple(37)); |
| 150 | $this->assertSame('Qix; Foo', $stepFour->checkIfContainsMultiple(7003)); |
| 151 | $this->assertSame('Qix; Foo; Qix', $stepFour->checkIfContainsMultiple(703007)); |
| 152 | $this->assertSame('Qix; Foo; Foo', $stepFour->checkIfContainsMultiple(713366)); |
| 153 | } |
| 154 | |
| 155 | /* contains 8-7-3 */ |
| 156 | public function testNumberContainsThreeEightAndSevenShouldReturnFooInfQix() |
| 157 | { |
| 158 | $stepFour = new ServiceInfQixFoo(); |
| 159 | $this->assertSame('Foo; Inf; Qix', $stepFour->checkIfContainsMultiple(387)); |
| 160 | $this->assertSame('Foo; Qix; Inf', $stepFour->checkIfContainsMultiple(37008)); |
| 161 | $this->assertSame('Foo; Qix; Inf; Foo; Qix', $stepFour->checkIfContainsMultiple(370083117)); |
| 162 | $this->assertSame('Inf; Foo; Qix', $stepFour->checkIfContainsMultiple(8311700)); |
| 163 | $this->assertSame('Inf; Qix; Foo', $stepFour->checkIfContainsMultiple(8117003)); |
| 164 | $this->assertSame('Inf; Qix; Foo; Foo; Qix', $stepFour->checkIfContainsMultiple(8111703307)); |
| 165 | $this->assertSame('Qix; Foo; Inf', $stepFour->checkIfContainsMultiple(7038)); |
| 166 | $this->assertSame('Qix; Inf; Foo', $stepFour->checkIfContainsMultiple(70811113)); |
| 167 | $this->assertSame('Qix; Inf; Foo; Foo; Qix; Inf', $stepFour->checkIfContainsMultiple(708311131718)); |
| 168 | } |
| 169 | |
| 170 | /** |
| 171 | * APPENDING INF, QIX OR FOO TO MULTIPLES CONTAINING 8, 7 and 3 RESPECTIVELY |
| 172 | */ |
| 173 | /* multiple 8 contains 8 */ |
| 174 | public function testMultipleOfEightContainsThreeShouldReturnInfAppendFoo() |
| 175 | { |
| 176 | $stepFour = new ServiceInfQixFoo(); |
| 177 | $this->assertSame('Inf; Inf', $stepFour->verifyNumberIsInfQixFoo(184)); |
| 178 | $this->assertSame('Inf; Inf; Inf', $stepFour->verifyNumberIsInfQixFoo(88)); |
| 179 | } |
| 180 | /* multiple 8 contains 7 */ |
| 181 | public function testMultipleOfEightContainsSevenShouldReturnInfAppendQix() |
| 182 | { |
| 183 | $stepFour = new ServiceInfQixFoo(); |
| 184 | $this->assertSame('Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(704)); |
| 185 | $this->assertSame('Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(760)); |
| 186 | } |
| 187 | /* multiple 8 contains 3 */ |
| 188 | public function testMultipleOfEightContainsEightShouldReturnInfAppendInf() |
| 189 | { |
| 190 | $stepFour = new ServiceInfQixFoo(); |
| 191 | $this->assertSame('Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(136)); |
| 192 | $this->assertSame('Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(320)); |
| 193 | } |
| 194 | /* multiple 8 contains 8-7 */ |
| 195 | public function testMultipleOfEightContainsEightAndSevenShouldReturnInfAppendInfQix() |
| 196 | { |
| 197 | $stepFour = new ServiceInfQixFoo(); |
| 198 | $this->assertSame('Inf; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(872)); |
| 199 | $this->assertSame('Inf; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1768)); |
| 200 | } |
| 201 | /* multiple 8 contains 8-3 */ |
| 202 | public function testMultipleOfEightContainsEightAndThreeShouldReturnInfAppendInfFoo() |
| 203 | { |
| 204 | $stepFour = new ServiceInfQixFoo(); |
| 205 | $this->assertSame('Inf; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(1384)); |
| 206 | $this->assertSame('Inf; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(832)); |
| 207 | } |
| 208 | /* multiple 8 contains 7-3 */ |
| 209 | public function testMultipleOfEightContainsSevenAndThreeShouldReturnInfAppendQixFoo() |
| 210 | { |
| 211 | $stepFour = new ServiceInfQixFoo(); |
| 212 | $this->assertSame('Inf; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(376)); |
| 213 | $this->assertSame('Inf; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(736)); |
| 214 | } |
| 215 | /* multiple 8 contains 8-7-3 */ |
| 216 | public function testMultipleOfEightContainsEightSevenAndThreeShouldReturnInfAppendInfQixFoo() |
| 217 | { |
| 218 | $stepFour = new ServiceInfQixFoo(); |
| 219 | $this->assertSame('Inf; Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(3872)); |
| 220 | $this->assertSame('Inf; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(13784)); |
| 221 | $this->assertSame('Inf; Inf; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(18376)); |
| 222 | $this->assertSame('Inf; Inf; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(18736)); |
| 223 | $this->assertSame('Inf; Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(17368)); |
| 224 | $this->assertSame('Inf; Qix; Inf; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(178336)); |
| 225 | } |
| 226 | |
| 227 | ################################################################################################# |
| 228 | /* multiple 7 contains 8 */ |
| 229 | public function testMultipleOfSevenContainsEightShouldReturnQixAppendInf() |
| 230 | { |
| 231 | $stepFour = new ServiceInfQixFoo(); |
| 232 | $this->assertSame('Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1085)); |
| 233 | $this->assertSame('Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1148)); |
| 234 | } |
| 235 | /* multiple 7 contains 7 */ |
| 236 | public function testMultipleOfSevenContainsSevenShouldReturnQixAppendQix() |
| 237 | { |
| 238 | $stepFour = new ServiceInfQixFoo(); |
| 239 | $this->assertSame('Qix; Qix', $stepFour->verifyNumberIsInfQixFoo(7)); |
| 240 | $this->assertSame('Qix; Qix', $stepFour->verifyNumberIsInfQixFoo(749)); |
| 241 | } |
| 242 | /* multiple 7 contains 3 */ |
| 243 | public function testMultipleOfSevenContainsThreeShouldReturnQixAppendFoo() |
| 244 | { |
| 245 | $stepFour = new ServiceInfQixFoo(); |
| 246 | $this->assertSame('Qix; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(133)); |
| 247 | $this->assertSame('Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(301)); |
| 248 | } |
| 249 | /* multiple 7 contains 8-7 */ |
| 250 | public function testMultipleOfSevenContainsEightAndSevenShouldReturnQixAppendInfQix() |
| 251 | { |
| 252 | $stepFour = new ServiceInfQixFoo(); |
| 253 | $this->assertSame('Qix; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(287)); |
| 254 | $this->assertSame('Qix; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1078)); |
| 255 | } |
| 256 | /* multiple 7 contains 8-3 */ |
| 257 | public function testMultipleOfSevenContainsEightAndThreeShouldReturnQixAppendFooInf() |
| 258 | { |
| 259 | $stepFour = new ServiceInfQixFoo(); |
| 260 | $this->assertSame('Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(308)); |
| 261 | $this->assertSame('Qix; Inf; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(833)); |
| 262 | } |
| 263 | /* multiple 7 contains 7-3 */ |
| 264 | public function testMultipleOfSevenContainsSevenAndThreeShouldReturnQixAppendQixFoo() |
| 265 | { |
| 266 | $stepFour = new ServiceInfQixFoo(); |
| 267 | $this->assertSame('Qix; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(637)); |
| 268 | $this->assertSame('Qix; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(763)); |
| 269 | } |
| 270 | /* multiple 7 contains 8-7-3 */ |
| 271 | public function testMultipleOfSevenContainsThreeEightAndSevenShouldReturnQixAppendInfQixFoo() |
| 272 | { |
| 273 | $stepFour = new ServiceInfQixFoo(); |
| 274 | $this->assertSame('Qix; Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(35287)); |
| 275 | $this->assertSame('Qix; Foo; Qix; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(13783)); |
| 276 | $this->assertSame('Qix; Inf; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(8372)); |
| 277 | $this->assertSame('Qix; Inf; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(5873)); |
| 278 | $this->assertSame('Qix; Qix; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(7378)); |
| 279 | $this->assertSame('Qix; Qix; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(17843)); |
| 280 | } |
| 281 | |
| 282 | ################################################################################################# |
| 283 | /* multiple 3 contains 8 */ |
| 284 | public function testMultipleOfThreeContainsEightShouldReturnFooAppendInf() |
| 285 | { |
| 286 | $stepFour = new ServiceInfQixFoo(); |
| 287 | $this->assertSame('Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(18)); |
| 288 | $this->assertSame('Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(81)); |
| 289 | } |
| 290 | /* multiple 3 contains 7 */ |
| 291 | public function testMultipleOfThreeContainsSevenShouldReturnFooAppendQix() |
| 292 | { |
| 293 | $stepFour = new ServiceInfQixFoo(); |
| 294 | $this->assertSame('Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(27)); |
| 295 | $this->assertSame('Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(729)); |
| 296 | } |
| 297 | /* multiple 3 contains 3 */ |
| 298 | public function testMultipleOfThreeContainsTreeShouldReturnFooAppendFoo() |
| 299 | { |
| 300 | $stepFour = new ServiceInfQixFoo(); |
| 301 | $this->assertSame('Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(3)); |
| 302 | $this->assertSame('Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(243)); |
| 303 | } |
| 304 | /* multiple 3 contains 8-7 */ |
| 305 | public function testMultipleOfThreeContainsEightAndSevenShouldReturnFooAppendInfQix() |
| 306 | { |
| 307 | $stepFour = new ServiceInfQixFoo(); |
| 308 | $this->assertSame('Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(1287)); |
| 309 | $this->assertSame('Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1278)); |
| 310 | } |
| 311 | /* multiple 3 contains 8-3 */ |
| 312 | public function testMultipleOfThreeContainsEightAndTreeShouldReturnFooAppendInfFoo() |
| 313 | { |
| 314 | $stepFour = new ServiceInfQixFoo(); |
| 315 | $this->assertSame('Foo; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(1038)); |
| 316 | $this->assertSame('Foo; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(1083)); |
| 317 | } |
| 318 | /* multiple 3 contains 7-3 */ |
| 319 | public function testMultipleOfThreeContainsSevenAndThreeShouldReturnFooAppendQixFoo() |
| 320 | { |
| 321 | $stepFour = new ServiceInfQixFoo(); |
| 322 | $this->assertSame('Foo; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(3117)); |
| 323 | $this->assertSame('Foo; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(7113)); |
| 324 | } |
| 325 | /* multiple 3 contains 8-7-3 */ |
| 326 | public function testMultipleOfThreeContainsEightSevenAndThreeShouldReturnFooAppendInfQixFoo() |
| 327 | { |
| 328 | $stepFour = new ServiceInfQixFoo(); |
| 329 | $this->assertSame('Foo; Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(13827)); |
| 330 | $this->assertSame('Foo; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(3078)); |
| 331 | $this->assertSame('Foo; Inf; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(18327)); |
| 332 | $this->assertSame('Foo; Inf; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(18723)); |
| 333 | $this->assertSame('Foo; Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(17358)); |
| 334 | $this->assertSame('Foo; Qix; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(17835)); |
| 335 | } |
| 336 | |
| 337 | ############################################################################################# |
| 338 | /* multiple 8-7 contains 8 */ |
| 339 | public function testMultipleOfEightAndSevenContainsEightShouldReturnInfQixAppendInf() |
| 340 | { |
| 341 | $stepFour = new ServiceInfQixFoo(); |
| 342 | $this->assertSame('Inf; Qix; Inf; Inf', $stepFour->verifyNumberIsInfQixFoo(1288)); |
| 343 | } |
| 344 | /* multiple 8-3 contains 8 */ |
| 345 | public function testMultipleOfEightAndThreeContainsEightShouldReturnInfFooAppendInf() |
| 346 | { |
| 347 | $stepFour = new ServiceInfQixFoo(); |
| 348 | $this->assertSame('Inf; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(1248)); |
| 349 | } |
| 350 | /* multiple 7-3 contains 8 */ |
| 351 | public function testMultipleOfSevenAndThreeContainsEightShouldReturnQixFooAppendInf() |
| 352 | { |
| 353 | $stepFour = new ServiceInfQixFoo(); |
| 354 | $this->assertSame('Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(1218)); |
| 355 | } |
| 356 | /* multiple 8-7-3 contains 8 */ |
| 357 | public function testMultipleOfEightSevenAndThreeContainsEightShouldReturnInfQixFooAppendInf() |
| 358 | { |
| 359 | $stepFour = new ServiceInfQixFoo(); |
| 360 | $this->assertSame('Inf; Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(1008)); |
| 361 | } |
| 362 | |
| 363 | ############################################################################################# |
| 364 | /* multiple 8-7 contains 7 */ |
| 365 | public function testMultipleOfEightAndSevenContainsSevenShouldReturnInfQixAppendQix() |
| 366 | { |
| 367 | $stepFour = new ServiceInfQixFoo(); |
| 368 | $this->assertSame('Inf; Qix; Qix', $stepFour->verifyNumberIsInfQixFoo(2744)); |
| 369 | } |
| 370 | /* multiple 8-3 contains 7 */ |
| 371 | public function testMultipleOfEightAndThreeContainsSevenShouldReturnInfFooAppendQix() |
| 372 | { |
| 373 | $stepFour = new ServiceInfQixFoo(); |
| 374 | $this->assertSame('Inf; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(7152)); |
| 375 | } |
| 376 | /* multiple 7-3 contains 7 */ |
| 377 | public function testMultipleOfSevenAndThreeContainsSevenShouldReturnQixFooAppendQix() |
| 378 | { |
| 379 | $stepFour = new ServiceInfQixFoo(); |
| 380 | $this->assertSame('Qix; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(714)); |
| 381 | } |
| 382 | /* multiple 8-7-3 contains 7 */ |
| 383 | public function testMultipleOfEightSevenAndThreeContainsSevenShouldReturnInfQixFooAppendQix() |
| 384 | { |
| 385 | $stepFour = new ServiceInfQixFoo(); |
| 386 | $this->assertSame('Inf; Qix; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(1176)); |
| 387 | } |
| 388 | |
| 389 | ########################################################################################## |
| 390 | /* multiple 8-7 contains 3 */ |
| 391 | public function testMultipleOfEightAndSevenContainsThreeShouldReturnInfQixAppendFoo() |
| 392 | { |
| 393 | $stepFour = new ServiceInfQixFoo(); |
| 394 | $this->assertSame('Inf; Qix; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(3136)); |
| 395 | } |
| 396 | /* multiple 8-3 contains 3 */ |
| 397 | public function testMultipleOfEightAndThreeContainsThreeShouldReturnInfFooAppendFoo() |
| 398 | { |
| 399 | $stepFour = new ServiceInfQixFoo(); |
| 400 | $this->assertSame('Inf; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(360)); |
| 401 | } |
| 402 | /* multiple 7-3 contains 3 */ |
| 403 | public function testMultipleOfSevenAndThreeContainsThreeShouldReturnQixFooAppendFoo() |
| 404 | { |
| 405 | $stepFour = new ServiceInfQixFoo(); |
| 406 | $this->assertSame('Qix; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(231)); |
| 407 | } |
| 408 | /* multiple 8-7-3 contains 3 */ |
| 409 | public function testMultipleOfEightSevenAndThreeContainsThreeShouldReturnInfQixFooAppendFoo() |
| 410 | { |
| 411 | $stepFour = new ServiceInfQixFoo(); |
| 412 | $this->assertSame('Inf; Qix; Foo; Foo', $stepFour->verifyNumberIsInfQixFoo(3024)); |
| 413 | } |
| 414 | |
| 415 | ############################################################################################### |
| 416 | /* multiple 8-7 contains 8-7 */ |
| 417 | public function testMultipleOfEightAndSevenContainsEightAndSevenShouldReturnInfQixAppendInfQix() |
| 418 | { |
| 419 | $stepFour = new ServiceInfQixFoo(); |
| 420 | $this->assertSame('Inf; Qix; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(728)); |
| 421 | $this->assertSame('Inf; Qix; Inf; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(87248)); |
| 422 | } |
| 423 | /* multiple 8-7 contains 8-3 */ |
| 424 | public function testMultipleOfEightAndSevenContainsEightAndThreeShouldReturnInfQixAppendInfFoo() |
| 425 | { |
| 426 | $stepFour = new ServiceInfQixFoo(); |
| 427 | $this->assertSame('Inf; Qix; Foo; Inf; Inf', $stepFour->verifyNumberIsInfQixFoo(38248)); |
| 428 | $this->assertSame('Inf; Qix; Inf; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(83048)); |
| 429 | } |
| 430 | /* multiple 8-7 contains 7-3 */ |
| 431 | public function testMultipleOfEightAndSevenContainsSevenAndThreeShouldReturnInfQixAppendQixFoo() |
| 432 | { |
| 433 | $stepFour = new ServiceInfQixFoo(); |
| 434 | $this->assertSame('Inf; Qix; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(229376)); |
| 435 | $this->assertSame('Inf; Qix; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(57344)); |
| 436 | } |
| 437 | /* multiple 8-7 contains 8-7-3 */ |
| 438 | public function testMultipleOfEightAndSevenContainsEightSevenAndThreeShouldReturnInfQixAppendInfQixFoo() |
| 439 | { |
| 440 | $stepFour = new ServiceInfQixFoo(); |
| 441 | $this->assertSame('Inf; Qix; Inf; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(87304)); |
| 442 | $this->assertSame('Inf; Qix; Qix; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(178136)); |
| 443 | } |
| 444 | |
| 445 | ############################################################################################ |
| 446 | /* multiple 8-3 contains 8-7 */ |
| 447 | public function testMultipleOfEightAndThreeContainsEightAndSevenShouldReturnInfFooAppendInfQix() |
| 448 | { |
| 449 | $stepFour = new ServiceInfQixFoo(); |
| 450 | $this->assertSame('Inf; Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(8712)); |
| 451 | $this->assertSame('Inf; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(768)); |
| 452 | } |
| 453 | /* multiple 8-3 contains 8-3 */ |
| 454 | public function testMultipleOfEightAndThreeContainsEightAndThreeShouldReturnInfFooAppendInfFoo() |
| 455 | { |
| 456 | $stepFour = new ServiceInfQixFoo(); |
| 457 | $this->assertSame('Inf; Foo; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(13824)); |
| 458 | $this->assertSame('Inf; Foo; Inf; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(8328)); |
| 459 | } |
| 460 | /* multiple 8-3 contains 7-3 */ |
| 461 | public function testMultipleOfEightAndThreeContainsSevenAndThreeShouldReturnInfFooAppendQixFoo() |
| 462 | { |
| 463 | $stepFour = new ServiceInfQixFoo(); |
| 464 | $this->assertSame('Inf; Foo; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(3720)); |
| 465 | $this->assertSame('Inf; Foo; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(7320)); |
| 466 | } |
| 467 | /* multiple 8-3 contains 8-7-3 */ |
| 468 | public function testMultipleOfEightAndThreeContainsEightSevenAndTreeShouldReturnInfFooAppendInfQixFoo() |
| 469 | { |
| 470 | $stepFour = new ServiceInfQixFoo(); |
| 471 | $this->assertSame('Inf; Foo; Qix; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(17832)); |
| 472 | $this->assertSame('Inf; Foo; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(3768)); |
| 473 | |
| 474 | } |
| 475 | |
| 476 | ############################################################################################### |
| 477 | /* multiple 7-3 contains 8-7 */ |
| 478 | public function testMultipleOfSevenAndThreeContainsEightAndSevenShouldReturnQixFooAppendInfQix() |
| 479 | { |
| 480 | $stepFour = new ServiceInfQixFoo(); |
| 481 | $this->assertSame('Qix; Foo; Inf; Qix; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(8778)); |
| 482 | $this->assertSame('Qix; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(798)); |
| 483 | } |
| 484 | /* multiple 7-3 contains 8-3 */ |
| 485 | public function testMultipleOfSevenAndThreeContainsEightAndThreeShouldReturnQixFooAppendInfFoo() |
| 486 | { |
| 487 | $stepFour = new ServiceInfQixFoo(); |
| 488 | $this->assertSame('Qix; Foo; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(23814)); |
| 489 | $this->assertSame('Qix; Foo; Inf; Foo', $stepFour->verifyNumberIsInfQixFoo(8316)); |
| 490 | } |
| 491 | /* multiple 7-3 contains 7-3 */ |
| 492 | public function testMultipleOfSevenAndThreeContainsSevenAndThreeShouldReturnQixFooAppendQixFoo() |
| 493 | { |
| 494 | $stepFour = new ServiceInfQixFoo(); |
| 495 | $this->assertSame('Qix; Foo; Foo; Qix; Qix', $stepFour->verifyNumberIsInfQixFoo(3717)); |
| 496 | $this->assertSame('Qix; Foo; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(273)); |
| 497 | } |
| 498 | /* multiple 7-3 contains 8-7-3 */ |
| 499 | public function testMultipleOfSevenAndThreeContainsEightSevenAndThreeShouldReturnQixFooAppendInfQixFoo() |
| 500 | { |
| 501 | $stepFour = new ServiceInfQixFoo(); |
| 502 | $this->assertSame('Qix; Foo; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(378)); |
| 503 | $this->assertSame('Qix; Foo; Qix; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(7308)); |
| 504 | } |
| 505 | |
| 506 | ############################################################################################### |
| 507 | /* multiple 8-7-3 contains 8-7 */ |
| 508 | public function testMultipleOfEightSevenAndThreeContainsEightAndSevenShouldReturnInfQixFooAppendInfQix() |
| 509 | { |
| 510 | $stepFour = new ServiceInfQixFoo(); |
| 511 | $this->assertSame('Inf; Qix; Foo; Inf; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(852768)); |
| 512 | $this->assertSame('Inf; Qix; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(1741824)); |
| 513 | } |
| 514 | /* multiple 8-7-3 contains 8-3 */ |
| 515 | public function testMultipleOfEightSevenAndThreeContainsEightAndThreeShouldReturnInfQixFooAppendInfFoo() |
| 516 | { |
| 517 | $stepFour = new ServiceInfQixFoo(); |
| 518 | $this->assertSame('Inf; Qix; Foo; Foo; Inf; Inf', $stepFour->verifyNumberIsInfQixFoo(36288)); |
| 519 | $this->assertSame('Inf; Qix; Foo; Foo; Inf', $stepFour->verifyNumberIsInfQixFoo(399168)); |
| 520 | } |
| 521 | /* multiple 8-7-3 contains 7-3 */ |
| 522 | public function testMultipleOfEightSevenAndThreeContainsSevenAndThreeShouldReturnInfQixFooAppendQixFoo() |
| 523 | { |
| 524 | $stepFour = new ServiceInfQixFoo(); |
| 525 | $this->assertSame('Inf; Qix; Foo; Foo; Qix', $stepFour->verifyNumberIsInfQixFoo(5376)); |
| 526 | $this->assertSame('Inf; Qix; Foo; Qix; Foo', $stepFour->verifyNumberIsInfQixFoo(7392)); |
| 527 | } |
| 528 | /* multiple 8-7-3 contains 8-7-3 */ |
| 529 | public function testMultipleOfEightSevenAndThreeContainsEightSevenAndThreeShouldReturnInfQixFooAppendInfQixFoo() |
| 530 | { |
| 531 | $stepFour = new ServiceInfQixFoo(); |
| 532 | $this->assertSame('Inf; Qix; Foo; Foo; Qix; Inf', $stepFour->verifyNumberIsInfQixFoo(37968)); |
| 533 | $this->assertSame('Inf; Qix; Foo; Foo; Inf; Qix', $stepFour->verifyNumberIsInfQixFoo(38472)); |
| 534 | } |
| 535 | |
| 536 | /** |
| 537 | * STEP 5: CHECK IF SUM OF ALL DIGITS IS MULTIPLE OF 8 (INF) |
| 538 | */ |
| 539 | public function testSumOfAllDigitsIsMultipleOfEight() |
| 540 | { |
| 541 | $stepFive = new ServiceInfQixFoo(); |
| 542 | $this->assertSame('Inf; Qix; Foo; Foo; Inf; QixInf', $stepFive->sumOfAllDigits(38472)); |
| 543 | $this->assertSame('Inf; Qix; Foo; Foo; Qix', $stepFive->sumOfAllDigits(5376)); |
| 544 | $this->assertSame('Inf; InfInf', $stepFive->sumOfAllDigits(8)); |
| 545 | $this->assertSame('112106', $stepFive->sumOfAllDigits(112106)); |
| 546 | } |
| 547 | |
| 548 | } |
| 549 | |
| 550 | $coverage->stop(); |
| 551 | (new HtmlReport)->process($coverage, '../build/coverage'); |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/build/coverage/tests/index.html b/build/coverage/tests/index.html
new file mode 100644
index 00000000..76e7ed46
--- /dev/null
+++ b/build/coverage/tests/index.html
@@ -0,0 +1,119 @@
+
+
+
+
+
+
+
+
+ Classes
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+
+ | Class | +Coverage | +
|---|---|
| Tests\ServiceInfQixFooTest | 0% |
+
+ Project Risks
+
+
+
+
+
+ | Class | +CRAP | +
|---|
+
+
+
+ Methods
+
+
+
+
+ Coverage Distribution
+
+
+
+
+
+ Complexity
+
+
+
+
+
+
+
+
+ Insufficient Coverage
+
+
+
+
+ Project Risks
+
+
+
+
+
+ | Method | +CRAP | +
|---|
+
+
+
+
+
+
+
+
+
+
diff --git a/build/logs/junit.xml b/build/logs/junit.xml
new file mode 100644
index 00000000..41b313fc
--- /dev/null
+++ b/build/logs/junit.xml
@@ -0,0 +1,70 @@
+
+
+
+
+
+
+
+ | + | Code Coverage |
+ ||||||||
| + | Lines |
+ Functions and Methods |
+ Classes and Traits |
+ ||||||
| Total | +
+
+
+ |
+ 0.45% |
+ 1 / 222 |
+
+
+
+ |
+ 0.00% |
+ 0 / 65 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
| ServiceInfQixFooTest.php |
+
+
+
+ |
+ 0.45% |
+ 1 / 222 |
+
+
+
+ |
+ 0.00% |
+ 0 / 65 |
+
+
+
+ |
+ 0.00% |
+ 0 / 1 |
+
Service Inf Qix Foo (Tests\ServiceInfQixFoo)
+-
+
- ✓ Multiple of eight should return inf +
- ✓ Multiple of seven should return qix +
- ✓ Multiple of three should return foo +
- ✓ Multiple of eight and seven should return inf qix +
- ✓ Multiple of eight and three should return inf foo +
- ✓ Multiple of seven and three should return qix foo +
- ✓ Multiple of eight seven and three should return inf qix foo +
- ✓ Multiple should return number +
- ✓ Number contains eight should return inf +
- ✓ Number contains seven should return qix +
- ✓ Number contains three should return foo +
- ✓ Number contains eight and seven should return inf qix +
- ✓ Number contains eight and three should return inf foo +
- ✓ Number contains seven and three should return qix foo +
- ✓ Number contains three eight and seven should return foo inf qix +
- ✓ Multiple of eight contains three should return inf append foo +
- ✓ Multiple of eight contains seven should return inf append qix +
- ✓ Multiple of eight contains eight should return inf append inf +
- ✓ Multiple of eight contains eight and seven should return inf append inf qix +
- ✓ Multiple of eight contains eight and three should return inf append inf foo +
- ✓ Multiple of eight contains seven and three should return inf append qix foo +
- ✓ Multiple of eight contains eight seven and three should return inf append inf qix foo +
- ✓ Multiple of seven contains eight should return qix append inf +
- ✓ Multiple of seven contains seven should return qix append qix +
- ✓ Multiple of seven contains three should return qix append foo +
- ✓ Multiple of seven contains eight and seven should return qix append inf qix +
- ✓ Multiple of seven contains eight and three should return qix append foo inf +
- ✓ Multiple of seven contains seven and three should return qix append qix foo +
- ✓ Multiple of seven contains three eight and seven should return qix append inf qix foo +
- ✓ Multiple of three contains eight should return foo append inf +
- ✓ Multiple of three contains seven should return foo append qix +
- ✓ Multiple of three contains tree should return foo append foo +
- ✓ Multiple of three contains eight and seven should return foo append inf qix +
- ✓ Multiple of three contains eight and tree should return foo append inf foo +
- ✓ Multiple of three contains seven and three should return foo append qix foo +
- ✓ Multiple of three contains eight seven and three should return foo append inf qix foo +
- ✓ Multiple of eight and seven contains eight should return inf qix append inf +
- ✓ Multiple of eight and three contains eight should return inf foo append inf +
- ✓ Multiple of seven and three contains eight should return qix foo append inf +
- ✓ Multiple of eight seven and three contains eight should return inf qix foo append inf +
- ✓ Multiple of eight and seven contains seven should return inf qix append qix +
- ✓ Multiple of eight and three contains seven should return inf foo append qix +
- ✓ Multiple of seven and three contains seven should return qix foo append qix +
- ✓ Multiple of eight seven and three contains seven should return inf qix foo append qix +
- ✓ Multiple of eight and seven contains three should return inf qix append foo +
- ✓ Multiple of eight and three contains three should return inf foo append foo +
- ✓ Multiple of seven and three contains three should return qix foo append foo +
- ✓ Multiple of eight seven and three contains three should return inf qix foo append foo +
- ✓ Multiple of eight and seven contains eight and seven should return inf qix append inf qix +
- ✓ Multiple of eight and seven contains eight and three should return inf qix append inf foo +
- ✓ Multiple of eight and seven contains seven and three should return inf qix append qix foo +
- ✓ Multiple of eight and seven contains eight seven and three should return inf qix append inf qix foo +
- ✓ Multiple of eight and three contains eight and seven should return inf foo append inf qix +
- ✓ Multiple of eight and three contains eight and three should return inf foo append inf foo +
- ✓ Multiple of eight and three contains seven and three should return inf foo append qix foo +
- ✓ Multiple of eight and three contains eight seven and tree should return inf foo append inf qix foo +
- ✓ Multiple of seven and three contains eight and seven should return qix foo append inf qix +
- ✓ Multiple of seven and three contains eight and three should return qix foo append inf foo +
- ✓ Multiple of seven and three contains seven and three should return qix foo append qix foo +
- ✓ Multiple of seven and three contains eight seven and three should return qix foo append inf qix foo +
- ✓ Multiple of eight seven and three contains eight and seven should return inf qix foo append inf qix +
- ✓ Multiple of eight seven and three contains eight and three should return inf qix foo append inf foo +
- ✓ Multiple of eight seven and three contains seven and three should return inf qix foo append qix foo +
- ✓ Multiple of eight seven and three contains eight seven and three should return inf qix foo append inf qix foo +
- ✓ Sum of all digits is multiple of eight +