diff --git a/database/factories/ChampionshipSettingsFactory.php b/database/factories/ChampionshipSettingsFactory.php
index 85f4169..d487d98 100644
--- a/database/factories/ChampionshipSettingsFactory.php
+++ b/database/factories/ChampionshipSettingsFactory.php
@@ -7,7 +7,8 @@
 $factory->define(ChampionshipSettings::class, function (Faker\Generator $faker) use ($factory) {
     $tcs = Championship::all()->pluck('id')->toArray();
 
-    $fightingAreas = [1,2,4,8];
+    $fightingAreas = [1, 2, 4, 8];
+
     return [
         'championship_id'      => $faker->randomElement($tcs),
         'treeType'             => $faker->numberBetween(0, 1),
diff --git a/src/TreeController.php b/src/TreeController.php
index 1b7358a..8f114d9 100644
--- a/src/TreeController.php
+++ b/src/TreeController.php
@@ -81,16 +81,16 @@ protected function provisionObjects(Request $request, $isTeam, $numFighters)
     {
         if ($isTeam) {
             $championship = Championship::find(2);
-            factory(Team::class, (int)$numFighters)->create(['championship_id' => $championship->id]);
+            factory(Team::class, (int) $numFighters)->create(['championship_id' => $championship->id]);
         } else {
             $championship = Championship::find(1);
-            $users = factory(User::class, (int)$numFighters)->create();
+            $users = factory(User::class, (int) $numFighters)->create();
             foreach ($users as $user) {
                 factory(Competitor::class)->create(
                     ['championship_id' => $championship->id,
-                        'user_id' => $user->id,
-                        'confirmed' => 1,
-                        'short_id' => $user->id,
+                        'user_id'      => $user->id,
+                        'confirmed'    => 1,
+                        'short_id'     => $user->id,
                     ]
                 );
             }
@@ -133,11 +133,11 @@ public function update(Request $request, Championship $championship)
                 $fight->save();
             }
         }
+
         return back();
     }
 
-
-    function getWinnerId($fighters, $scores, $numFighter)
+    public function getWinnerId($fighters, $scores, $numFighter)
     {
         return $scores[$numFighter] != null ? $fighters[$numFighter] : null;
     }
diff --git a/src/TreeGen/CreateSingleEliminationTree.php b/src/TreeGen/CreateSingleEliminationTree.php
index c8e8ee4..86bd7ec 100644
--- a/src/TreeGen/CreateSingleEliminationTree.php
+++ b/src/TreeGen/CreateSingleEliminationTree.php
@@ -113,7 +113,8 @@ private function assignPositions()
     }
 
     /**
-     * returns titles depending of number of rounds
+     * returns titles depending of number of rounds.
+     *
      * @return array
      */
     public function getRoundTitles()
@@ -139,11 +140,13 @@ public function getRoundTitles()
             //The minus 3 is to ignore the final, semi final and quarter final rounds
 
             for ($i = 0; $i < $noRounds - 3; $i++) {
-                $tempRounds[] = 'Last ' . $noTeamsInFirstRound;
+                $tempRounds[] = 'Last '.$noTeamsInFirstRound;
                 $noTeamsInFirstRound /= 2;
             }
+
             return array_merge($tempRounds, $roundTitles);
         }
+
         return $roundTitle[$this->numFighters];
     }
 
@@ -159,7 +162,7 @@ public function printRoundTitles()
         foreach ($roundTitles as $key => $roundTitle) {
             $left = $key * ($this->matchWrapperWidth + $this->roundSpacing - 1);
 
-            echo '<div class="round-title" style="left: ' . $left . 'px;">' . $roundTitle . '</div>';
+            echo '<div class="round-title" style="left: '.$left.'px;">'.$roundTitle.'</div>';
         }
         echo '</div>';
     }
@@ -172,7 +175,7 @@ public function printRoundTitles()
     public function getPlayerList($selected)
     {
         $html = '<select>
-                <option' . ($selected == '' ? ' selected' : '') . '></option>';
+                <option'.($selected == '' ? ' selected' : '').'></option>';
 
         foreach ($this->championship->fighters as $fighter) {
             $html = $this->addOptionToSelect($selected, $fighter, $html);
@@ -207,7 +210,7 @@ private function assignFightersToBracket($numRound, $hasPreliminary)
                 $this->brackets[$roundNumber][$matchNumber] = [$fighter1, $fighter2, $winnerId];
             }
         }
-        
+
         if ($this->numFighters >= $this->championship->getGroupSize() * 2) {
             $lastRound = $this->noRounds;
             $lastMatch = $this->numFighters / pow(2, $roundNumber) + 1;
@@ -218,7 +221,6 @@ private function assignFightersToBracket($numRound, $hasPreliminary)
             $fighter2 = $fight->fighter2;
             $winnerId = $fight->winner_id;
             $this->brackets[$lastRound][$lastMatch + 1] = [$fighter1, $fighter2, $winnerId];
-
         }
     }
 
@@ -233,12 +235,12 @@ private function addOptionToSelect($selected, $fighter, $html): string
     {
         if ($fighter != null) {
             $select = $selected != null && $selected->id == $fighter->id ? ' selected' : '';
-            $html .= '<option' . $select
-                . ' value='
-                . ($fighter->id ?? '')
-                . '>'
-                . $fighter->name
-                . '</option>';
+            $html .= '<option'.$select
+                .' value='
+                .($fighter->id ?? '')
+                .'>'
+                .$fighter->name
+                .'</option>';
         }
 
         return $html;
diff --git a/src/TreeGen/PlayOffCompetitorTreeGen.php b/src/TreeGen/PlayOffCompetitorTreeGen.php
index d9af7a7..2c8f9fd 100644
--- a/src/TreeGen/PlayOffCompetitorTreeGen.php
+++ b/src/TreeGen/PlayOffCompetitorTreeGen.php
@@ -62,10 +62,8 @@ protected function addFighterToGroup(FightersGroup $group, $competitor, $fighter
             ->get()
             ->get($numFighterToUpdate - 1);
 
-
         // we must update the right result
         $competitorGroup->competitor_id = $competitor->id;
         $competitorGroup->save();
     }
-
 }
diff --git a/src/TreeGen/PlayOffTeamTreeGen.php b/src/TreeGen/PlayOffTeamTreeGen.php
index 36b9699..6489a80 100644
--- a/src/TreeGen/PlayOffTeamTreeGen.php
+++ b/src/TreeGen/PlayOffTeamTreeGen.php
@@ -63,10 +63,8 @@ protected function addFighterToGroup(FightersGroup $group, $team, $fighterToUpda
             ->get()
             ->get($numFighterToUpdate - 1);
 
-
         // we must update the right result
         $competitorGroup->team_id = $team->id;
         $competitorGroup->save();
     }
-
 }
diff --git a/src/TreeGen/PlayOffTreeGen.php b/src/TreeGen/PlayOffTreeGen.php
index e5a3039..ebca9c9 100644
--- a/src/TreeGen/PlayOffTreeGen.php
+++ b/src/TreeGen/PlayOffTreeGen.php
@@ -23,8 +23,6 @@ protected function getByeGroup($fighters)
         return $this->createByeGroup($byeCount);
     }
 
-
-
     /**
      * Chunk Fighters into groups for fighting, and optionnaly shuffle.
      *
@@ -92,7 +90,7 @@ protected function generateAllTrees()
         $fighters = $this->championship->fighters;
         // This means that when playoff, we only generate 1 group
         // Could be better, for now it is ok
-        if (sizeof($fighters) > 1) {
+        if (count($fighters) > 1) {
             $this->generateGroupsForRound($fighters, 1);
         }
     }
diff --git a/src/TreeGen/SingleEliminationCompetitorTreeGen.php b/src/TreeGen/SingleEliminationCompetitorTreeGen.php
index 16cfdcd..e707c0d 100644
--- a/src/TreeGen/SingleEliminationCompetitorTreeGen.php
+++ b/src/TreeGen/SingleEliminationCompetitorTreeGen.php
@@ -58,7 +58,6 @@ protected function addFighterToGroup(FightersGroup $group, $competitor, $fighter
             ->get()
             ->get($numFighterToUpdate - 1);
 
-
         // we must update the right result
         $competitorGroup->competitor_id = $competitor->id;
         $competitorGroup->save();
diff --git a/src/TreeGen/SingleEliminationTeamTreeGen.php b/src/TreeGen/SingleEliminationTeamTreeGen.php
index a3bee61..4c56b6c 100644
--- a/src/TreeGen/SingleEliminationTeamTreeGen.php
+++ b/src/TreeGen/SingleEliminationTeamTreeGen.php
@@ -59,7 +59,6 @@ protected function addFighterToGroup(FightersGroup $group, $team, $fighterToUpda
             ->get()
             ->get($numFighterToUpdate - 1);
 
-
         // we must update the right result
         $competitorGroup->team_id = $team->id;
         $competitorGroup->save();
diff --git a/src/TreeGen/SingleEliminationTreeGen.php b/src/TreeGen/SingleEliminationTreeGen.php
index 41388ad..e3c6dba 100644
--- a/src/TreeGen/SingleEliminationTreeGen.php
+++ b/src/TreeGen/SingleEliminationTreeGen.php
@@ -5,8 +5,8 @@
 use Illuminate\Support\Collection;
 use Xoco70\LaravelTournaments\Exceptions\TreeGenerationException;
 use Xoco70\LaravelTournaments\Models\ChampionshipSettings;
-use Xoco70\LaravelTournaments\Models\SingleEliminationFight;
 use Xoco70\LaravelTournaments\Models\PreliminaryFight;
+use Xoco70\LaravelTournaments\Models\SingleEliminationFight;
 
 abstract class SingleEliminationTreeGen extends TreeGen
 {
@@ -23,6 +23,7 @@ protected function getByeGroup($fighters)
         $firstRoundGroupSize = $this->firstRoundGroupSize();
         $treeSize = $this->getTreeSize($fighterCount, $firstRoundGroupSize);
         $byeCount = $treeSize - $fighterCount;
+
         return $this->createByeGroup($byeCount);
     }
 
@@ -54,7 +55,7 @@ protected function pushGroups($numRounds, $numFighters)
     }
 
     /**
-     * Create empty groups after round 1
+     * Create empty groups after round 1.
      *
      * @param $numFighters
      */
@@ -150,7 +151,6 @@ protected function generateAllTrees()
         $this->generateGroupsForRound($usersByArea, 1);
         $this->pushEmptyGroupsToTree($numFighters); // Abstract
         $this->addParentToChildren($numFighters);
-
     }
 
     /**
@@ -176,7 +176,8 @@ public function generateGroupsForRound(Collection $usersByArea, $round)
     }
 
     /**
-     * Check if there is enough fighters, throw exception otherwise
+     * Check if there is enough fighters, throw exception otherwise.
+     *
      * @throws TreeGenerationException
      */
     private function minFightersCheck()
@@ -189,18 +190,17 @@ private function minFightersCheck()
 
         $minFighterCount = $fighters->count() / $areas;
 
-
         if ($this->settings->hasPreliminary && $fighters->count() / ($this->settings->preliminaryGroupSize * $areas) < 1) {
             throw new TreeGenerationException(trans('laravel-tournaments::core.min_competitor_required', [
-                'number' => $this->settings->preliminaryGroupSize * $areas,
-                'fighter_type' => $fighterType
+                'number'       => $this->settings->preliminaryGroupSize * $areas,
+                'fighter_type' => $fighterType,
             ]));
         }
 
         if ($minFighterCount < ChampionshipSettings::MIN_COMPETITORS_BY_AREA) {
             throw new TreeGenerationException(trans('laravel-tournaments::core.min_competitor_required', [
-                'number' => ChampionshipSettings::MIN_COMPETITORS_BY_AREA,
-                'fighter_type' => $fighterType
+                'number'       => ChampionshipSettings::MIN_COMPETITORS_BY_AREA,
+                'fighter_type' => $fighterType,
             ]));
         }
     }
diff --git a/src/TreeGen/TreeGen.php b/src/TreeGen/TreeGen.php
index f273ae1..be3211f 100644
--- a/src/TreeGen/TreeGen.php
+++ b/src/TreeGen/TreeGen.php
@@ -23,7 +23,7 @@ abstract protected function generateFights();
 
     abstract protected function createByeFighter();
 
-    abstract protected function addFighterToGroup(FightersGroup $group, $fighter,$fighterToUpdate);
+    abstract protected function addFighterToGroup(FightersGroup $group, $fighter, $fighterToUpdate);
 
     abstract protected function getByeGroup($fighters);
 
@@ -31,8 +31,6 @@ abstract protected function getFighters();
 
     abstract protected function getNumRounds($fightersCount);
 
-
-
     abstract protected function chunkAndShuffle(Collection $fightersByEntity);
 
     abstract protected function syncGroup(FightersGroup $group, $fighters);
@@ -99,6 +97,7 @@ private function getFightersByEntity($fighters): Collection
         if (($this->groupBy) != null) {
             return $fighters->groupBy($this->groupBy); // Collection of Collection
         }
+
         return $fighters->chunk(1); // Collection of Collection
     }
 
@@ -171,14 +170,13 @@ private function insertByes(Collection $fighters, Collection $byeGroup)
         $sizeGroupBy = count($byeGroup);
 
         $frequency = $sizeGroupBy != 0
-            ? (int)floor($sizeFighters / $sizeGroupBy)
+            ? (int) floor($sizeFighters / $sizeGroupBy)
             : -1;
 
         // Create Copy of $competitors
         return $this->getFullFighterList($fighters, $frequency, $sizeGroupBy, $bye);
     }
 
-
     /**
      * @param $order
      * @param $round
@@ -193,7 +191,6 @@ protected function saveGroup($order, $round, $parent): FightersGroup
             ? $group->area = $this->getNumArea($round, $order)
             : $group->area = 1; // Area limited to 1 in playoff
 
-
         $group->order = $order;
         $group->round = $round;
         $group->championship_id = $this->championship->id;
@@ -438,7 +435,6 @@ protected function getNumArea($round, $order)
         return $numArea;
     }
 
-
     protected function generateAllFights()
     {
         $this->generateFights(); // Abstract
diff --git a/src/models/Championship.php b/src/models/Championship.php
index 50f5034..948c48e 100644
--- a/src/models/Championship.php
+++ b/src/models/Championship.php
@@ -7,10 +7,10 @@
 use Illuminate\Database\Eloquent\SoftDeletes;
 use Illuminate\Foundation\Auth\User;
 use Xoco70\LaravelTournaments\Contracts\TreeGenerable;
-use Xoco70\LaravelTournaments\TreeGen\SingleEliminationCompetitorTreeGen;
-use Xoco70\LaravelTournaments\TreeGen\SingleEliminationTeamTreeGen;
 use Xoco70\LaravelTournaments\TreeGen\PlayOffCompetitorTreeGen;
 use Xoco70\LaravelTournaments\TreeGen\PlayOffTeamTreeGen;
+use Xoco70\LaravelTournaments\TreeGen\SingleEliminationCompetitorTreeGen;
+use Xoco70\LaravelTournaments\TreeGen\SingleEliminationTeamTreeGen;
 
 class Championship extends Model
 {
@@ -156,7 +156,7 @@ public function fightersGroups()
      */
     public function fights()
     {
-        return $this->hasManyThrough(Fight::class, FightersGroup::class)->orderBy('id','asc');
+        return $this->hasManyThrough(Fight::class, FightersGroup::class)->orderBy('id', 'asc');
     }
 
     /**
diff --git a/src/models/Fight.php b/src/models/Fight.php
index c4f3215..2cddb20 100644
--- a/src/models/Fight.php
+++ b/src/models/Fight.php
@@ -48,7 +48,7 @@ public function group()
     protected static function getFightersWithByes(FightersGroup $group)
     {
         if ($group == null) {
-            return null;
+            return;
         }
         $fighters = $group->getFightersWithBye();
         $fighterType = $group->getFighterType();
@@ -92,7 +92,6 @@ public function team1()
         return $this->belongsTo(Team::class, 'c1', 'id');
     }
 
-
     /**
      * Get Second Fighter.
      *
@@ -137,19 +136,18 @@ public function getFighterAttr($numFighter, $attr)
     {
         $isTeam = $this->group->championship->category->isTeam;
         if ($isTeam) {
-            $teamToUpdate = 'team' . $numFighter;
+            $teamToUpdate = 'team'.$numFighter;
 
             return optional($this->$teamToUpdate)->$attr;
         }
-        $competitorToUpdate = 'competitor' . $numFighter;
+        $competitorToUpdate = 'competitor'.$numFighter;
         if ($attr == 'name') {
             return $this->$competitorToUpdate == null
                 ? ''
-                : $this->$competitorToUpdate->user->firstname . ' ' . $this->$competitorToUpdate->user->lastname;
+                : $this->$competitorToUpdate->user->firstname.' '.$this->$competitorToUpdate->user->lastname;
         } elseif ($attr == 'short_id') {
             return optional($this->$competitorToUpdate)->short_id;
         }
-        return null;
     }
 
     /**
diff --git a/src/models/FightersGroup.php b/src/models/FightersGroup.php
index 2347ed7..3ecb0cb 100644
--- a/src/models/FightersGroup.php
+++ b/src/models/FightersGroup.php
@@ -9,7 +9,6 @@
 use Illuminate\Support\Facades\DB;
 use Kalnoy\Nestedset\NodeTrait;
 
-
 class FightersGroup extends Model
 {
     protected $table = 'fighters_groups';
@@ -195,17 +194,15 @@ public function hasDeterminedParent()
      */
     public function getValueToUpdate()
     {
-        try{
+        try {
             if ($this->championship->category->isTeam()) {
                 return $this->teams->map->id[0];
             }
 
             return $this->competitors->map->id[0];
-
-        }catch (ErrorException $e){
-            return null;
+        } catch (ErrorException $e) {
+            return;
         }
-
     }
 
     /**
diff --git a/tests/PlayOffTest.php b/tests/PlayOffTest.php
index 7ffd319..0a4e2c1 100644
--- a/tests/PlayOffTest.php
+++ b/tests/PlayOffTest.php
@@ -12,11 +12,11 @@ public function check_number_of_row_when_generating_playoff_tree()
     {
         $setting = factory(ChampionshipSettings::class)->make([
             'championship_id' => $this->getChampionship(0)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::PLAY_OFF,
-            'hasPreliminary' => 0,
-            'isTeam' => 0,
-            'numFighters' => rand(3, 10)
+            'fightingAreas'   => 1,
+            'treeType'        => ChampionshipSettings::PLAY_OFF,
+            'hasPreliminary'  => 0,
+            'isTeam'          => 0,
+            'numFighters'     => rand(3, 10),
         ]);
         $this->generateTreeWithUI($setting);
         $count = FightersGroup::where('championship_id', $setting->championship->id)
@@ -30,15 +30,15 @@ public function check_number_of_fights_when_generating_playoff_tree()
     {
         $fightersInTree = [1, 2, 3, 4, 5, 6, 7, 8];
         // When none, we add a dummy player that will never display
-        $numFightsExpected = [1 => 0, 2 => 1, 3 => 6, 4 => 6, 5 => 15, 6 => 15, 7 => 28, 8 => 28, ];
+        $numFightsExpected = [1 => 0, 2 => 1, 3 => 6, 4 => 6, 5 => 15, 6 => 15, 7 => 28, 8 => 28];
         foreach ($fightersInTree as $numFighters) {
             $setting = factory(ChampionshipSettings::class)->make([
                 'championship_id' => $this->getChampionship(0)->id,
-                'fightingAreas' => 1,
-                'treeType' => ChampionshipSettings::PLAY_OFF,
-                'hasPreliminary' => 0,
-                'isTeam' => 0,
-                'numFighters' => $numFighters
+                'fightingAreas'   => 1,
+                'treeType'        => ChampionshipSettings::PLAY_OFF,
+                'hasPreliminary'  => 0,
+                'isTeam'          => 0,
+                'numFighters'     => $numFighters,
             ]);
             $this->generateTreeWithUI($setting);
             parent::checkFightsNumber($setting, $numFightsExpected[$numFighters], __METHOD__);
diff --git a/tests/SingleEliminationTest.php b/tests/SingleEliminationTest.php
index 94f4932..69af8d0 100644
--- a/tests/SingleEliminationTest.php
+++ b/tests/SingleEliminationTest.php
@@ -3,7 +3,6 @@
 namespace Xoco70\LaravelTournaments\Tests;
 
 use Xoco70\LaravelTournaments\Models\ChampionshipSettings;
-use Xoco70\LaravelTournaments\Models\Fight;
 
 class SingleEliminationTest extends TestCase
 {
@@ -17,11 +16,11 @@ public function check_number_of_row_when_generating_single_elimination_tree()
             foreach ($fightersInTree as $numFighters) {
                 $setting = factory(ChampionshipSettings::class)->make([
                     'championship_id' => $this->getChampionship(0)->id,
-                    'fightingAreas' => $numArea,
-                    'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-                    'hasPreliminary' => 0,
-                    'isTeam' => 0,
-                    'numFighters' => $numFighters
+                    'fightingAreas'   => $numArea,
+                    'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+                    'hasPreliminary'  => 0,
+                    'isTeam'          => 0,
+                    'numFighters'     => $numFighters,
                 ]);
                 $this->generateTreeWithUI($setting);
                 parent::checkGroupsNumber($setting, $numGroupsExpected, __METHOD__);
@@ -34,9 +33,9 @@ public function check_number_of_fights_when_single_elimination_tree()
     {
         $isTeams = [0, 1];
         $numFights = [
-            1 => [1 => 0, 2 => 1, 3 => 2, 4 => 2, 5 => 4, 6 => 4, 7 => 4, 8 => 4,],
-            2 => [1 => 0, 2 => 0, 3 => 0, 4 => 2, 5 => 4, 6 => 4, 7 => 4, 8 => 4,],
-            4 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 4,],
+            1 => [1 => 0, 2 => 1, 3 => 2, 4 => 2, 5 => 4, 6 => 4, 7 => 4, 8 => 4],
+            2 => [1 => 0, 2 => 0, 3 => 0, 4 => 2, 5 => 4, 6 => 4, 7 => 4, 8 => 4],
+            4 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 4],
         ];
         foreach ($isTeams as $isTeam) {
             $championship = $this->getChampionship($isTeam);
@@ -44,17 +43,16 @@ public function check_number_of_fights_when_single_elimination_tree()
                 foreach ($numFightPerArea as $numFighters => $numFightsExpected) {
                     $setting = factory(ChampionshipSettings::class)->make([
                         'championship_id' => $this->getChampionship($isTeam)->id,
-                        'fightingAreas' => $numArea,
-                        'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-                        'hasPreliminary' => 0,
-                        'isTeam' => $isTeam,
-                        'numFighters' => $numFighters
+                        'fightingAreas'   => $numArea,
+                        'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+                        'hasPreliminary'  => 0,
+                        'isTeam'          => $isTeam,
+                        'numFighters'     => $numFighters,
                     ]);
                     $this->generateTreeWithUI($setting);
                     parent::checkFightsNumber($setting, $numFightsExpected, __METHOD__);
                 }
             }
-
         }
     }
 
@@ -64,11 +62,11 @@ public function it_saves_fight_to_next_round_when_possible()
         $isTeam = 0;
         $setting = factory(ChampionshipSettings::class)->make([
             'championship_id' => $this->getChampionship($isTeam)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-            'hasPreliminary' => 0,
-            'isTeam' => $isTeam,
-            'numFighters' => 5
+            'fightingAreas'   => 1,
+            'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+            'hasPreliminary'  => 0,
+            'isTeam'          => $isTeam,
+            'numFighters'     => 5,
         ]);
         $this->generateTreeWithUI($setting);
 
@@ -111,11 +109,11 @@ public function you_can_update_manually_single_elimination_tree_fighters()
     {
         $setting = factory(ChampionshipSettings::class)->make([
             'championship_id' => $this->getChampionship(0)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-            'hasPreliminary' => 0,
-            'isTeam' => 0,
-            'numFighters' => 5
+            'fightingAreas'   => 1,
+            'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+            'hasPreliminary'  => 0,
+            'isTeam'          => 0,
+            'numFighters'     => 5,
         ]);
         $this->generateTreeWithUI($setting);
         $competitors = $this->championshipWithComp->competitors; // 5 comp
@@ -135,7 +133,6 @@ public function you_can_update_manually_single_elimination_tree_fighters()
         $this->assertEquals($competitors->get(2)->id, $fights->get(1)->c1);
         $this->assertEquals($competitors->get(3)->id, $fights->get(1)->c2);
         $this->assertEquals($competitors->get(4)->id, $fights->get(2)->c1);
-
     }
 
     /** @test */
@@ -143,11 +140,11 @@ public function you_can_update_manually_single_elimination_tree_winner_id()
     {
         $setting = factory(ChampionshipSettings::class)->make([
             'championship_id' => $this->getChampionship(0)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-            'hasPreliminary' => 0,
-            'isTeam' => 0,
-            'numFighters' => 5
+            'fightingAreas'   => 1,
+            'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+            'hasPreliminary'  => 0,
+            'isTeam'          => 0,
+            'numFighters'     => 5,
         ]);
         $this->generateTreeWithUI($setting);
         $fight = $this->championshipWithComp->fights->get(0);
@@ -157,7 +154,7 @@ public function you_can_update_manually_single_elimination_tree_winner_id()
             ->press('update');
         if ($fight->c1 != null && $fight->c2 != null) {
             $this->assertNotNull($fight->winner_id);
-        }else{
+        } else {
             $this->assertNull($fight->winner_id);
         }
     }
@@ -168,11 +165,11 @@ public function it_can_generate_single_elim_tree_with_16_fighters()
         // This test is a regression test, used to fail
         $setting = factory(ChampionshipSettings::class)->make([
             'championship_id' => $this->getChampionship(0)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-            'hasPreliminary' => 1,
-            'isTeam' => 0,
-            'numFighters' => 16,
+            'fightingAreas'   => 1,
+            'treeType'        => ChampionshipSettings::SINGLE_ELIMINATION,
+            'hasPreliminary'  => 1,
+            'isTeam'          => 0,
+            'numFighters'     => 16,
         ]);
         $this->generateTreeWithUI($setting)
             ->assertResponseOk();
diff --git a/tests/SingleEliminationWPrelimTest.php b/tests/SingleEliminationWPrelimTest.php
index 21c540f..a78bff2 100644
--- a/tests/SingleEliminationWPrelimTest.php
+++ b/tests/SingleEliminationWPrelimTest.php
@@ -5,7 +5,6 @@
 use Illuminate\Foundation\Testing\DatabaseTransactions;
 use Xoco70\LaravelTournaments\Models\Championship;
 use Xoco70\LaravelTournaments\Models\ChampionshipSettings;
-use Xoco70\LaravelTournaments\Models\FightersGroup;
 
 class SingleEliminationWPrelimTest extends TestCase
 {
@@ -36,13 +35,13 @@ public function check_number_of_groups_when_generating_preliminary_tree()
             foreach ($prelimGroupsByArea as $preliminaryGroupSize => $numPreliminaryGroup) {
                 foreach ($fightersInTree as $numFighters) {
                     $setting = factory(ChampionshipSettings::class)->make([
-                        'championship_id' => $this->championshipWithComp->fresh()->id,
-                        'fightingAreas' => $numArea,
-                        'numFighters' => $numFighters,
-                        'isTeam' => 0,
-                        'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-                        'hasPreliminary' => 1,
-                        'preliminaryGroupSize' => $preliminaryGroupSize
+                        'championship_id'      => $this->championshipWithComp->fresh()->id,
+                        'fightingAreas'        => $numArea,
+                        'numFighters'          => $numFighters,
+                        'isTeam'               => 0,
+                        'treeType'             => ChampionshipSettings::SINGLE_ELIMINATION,
+                        'hasPreliminary'       => 1,
+                        'preliminaryGroupSize' => $preliminaryGroupSize,
                     ]);
                     $this->generateTreeWithUI($setting);
                     parent::checkGroupsNumber($setting, $numPreliminaryGroup, __METHOD__);
@@ -58,23 +57,22 @@ public function check_number_of_fights_when_preliminary_tree()
 
         $numFights = [
             $groupsSize = 3 => [
-                $numArea = 1 => [1 => 0, 2 => 0, 3 => 3, 4 => 6, 5 => 6, 6 => 6, 7 => 12, 8 => 12,],
-                $numArea = 2 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 6, 7 => 12, 8 => 12,],
+                $numArea = 1 => [1 => 0, 2 => 0, 3 => 3, 4 => 6, 5 => 6, 6 => 6, 7 => 12, 8 => 12],
+                $numArea = 2 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 6, 7 => 12, 8 => 12],
 //                $numArea = 4 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 0,],
             ],
             $groupsSize = 4 => [
-                $numArea = 1 => [1 => 0, 2 => 0, 3 => 0, 4 => 6, 5 => 12, 6 => 12, 7 => 12, 8 => 12,],
-                $numArea = 2 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 12,],
+                $numArea = 1 => [1 => 0, 2 => 0, 3 => 0, 4 => 6, 5 => 12, 6 => 12, 7 => 12, 8 => 12],
+                $numArea = 2 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 12],
 //                $numArea = 4 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 0,],
             ],
             $groupsSize = 5 => [
-                $numArea = 1 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 15, 6 => 30, 7 => 30, 8 => 30,], // Some fights are removed from the list
+                $numArea = 1 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 15, 6 => 30, 7 => 30, 8 => 30], // Some fights are removed from the list
 //                $numArea = 2 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 0,],
 //                $numArea = 4 => [1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0, 7 => 0, 8 => 0,],
-            ]
+            ],
         ];
 
-
         foreach ($isTeams as $isTeam) {
             $isTeam
                 ? $championship = $this->championshipWithTeam
@@ -84,13 +82,13 @@ public function check_number_of_fights_when_preliminary_tree()
                 foreach ($numFightGroupSize as $numArea => $numFightPerArea) {
                     foreach ($numFightPerArea as $numFighters => $numFightsExpected) {
                         $setting = factory(ChampionshipSettings::class)->make([
-                            'championship_id' => $championship->id,
-                            'fightingAreas' => $numArea,
-                            'numFighters' => $numFighters,
-                            'isTeam' => $isTeam,
-                            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-                            'hasPreliminary' => 1,
-                            'preliminaryGroupSize' => $numGroup
+                            'championship_id'      => $championship->id,
+                            'fightingAreas'        => $numArea,
+                            'numFighters'          => $numFighters,
+                            'isTeam'               => $isTeam,
+                            'treeType'             => ChampionshipSettings::SINGLE_ELIMINATION,
+                            'hasPreliminary'       => 1,
+                            'preliminaryGroupSize' => $numGroup,
                         ]);
 
                         $this->generateTreeWithUI($setting);
@@ -105,20 +103,19 @@ public function check_number_of_fights_when_preliminary_tree()
     public function it_can_generate_prelim_tree_with_12_fighters()
     {
         $setting = factory(ChampionshipSettings::class)->make([
-            'championship_id' => $this->getChampionship(0)->id,
-            'fightingAreas' => 1,
-            'treeType' => ChampionshipSettings::SINGLE_ELIMINATION,
-            'hasPreliminary' => 1,
-            'isTeam' => 0,
-            'numFighters' => 12,
-            'preliminaryGroupSize' => 3
+            'championship_id'      => $this->getChampionship(0)->id,
+            'fightingAreas'        => 1,
+            'treeType'             => ChampionshipSettings::SINGLE_ELIMINATION,
+            'hasPreliminary'       => 1,
+            'isTeam'               => 0,
+            'numFighters'          => 12,
+            'preliminaryGroupSize' => 3,
         ]);
         $this->generateTreeWithUI($setting);
 
         // Check fights orders
         $championship = Championship::find(1);
 
-
         foreach ($championship->fightersGroups as $group) {
             $competitorsGroup = $group->competitors;
             $fights = $group->fights;
@@ -131,6 +128,5 @@ public function it_can_generate_prelim_tree_with_12_fighters()
             $this->assertEquals(optional($fights->get(2))->c1, optional($competitorsGroup->get(2))->id);
             $this->assertEquals(optional($fights->get(2))->c2, optional($competitorsGroup->get(0))->id);
         }
-
     }
 }
diff --git a/tests/TestCase.php b/tests/TestCase.php
index 1a34fbb..8065a0e 100644
--- a/tests/TestCase.php
+++ b/tests/TestCase.php
@@ -34,13 +34,15 @@ abstract class TestCase extends BaseTestCase
     protected function getPackageProviders($app)
     {
         return [TournamentsServiceProvider::class,
-            ConsoleServiceProvider::class,];
+            ConsoleServiceProvider::class, ];
     }
 
-    protected function getChampionship($isTeam){
+    protected function getChampionship($isTeam)
+    {
         $isTeam
             ? $championship = $this->championshipWithTeam
             : $championship = $this->championshipWithComp;
+
         return $championship;
     }
 
@@ -53,7 +55,7 @@ public function setUp()
         $this->makeSureDatabaseExists();
         parent::setUp();
         $this->artisan('migrate', ['--database' => 'testbench']);
-        $this->withFactories(__DIR__ . '/../database/factories');
+        $this->withFactories(__DIR__.'/../database/factories');
         $this->initialSeed();
         $this->tournament = Tournament::with(
             'competitors',
@@ -73,7 +75,7 @@ public function setUp()
 
     private function makeSureDatabaseExists()
     {
-        $this->runQuery('CREATE DATABASE IF NOT EXISTS ' . static::DB_NAME);
+        $this->runQuery('CREATE DATABASE IF NOT EXISTS '.static::DB_NAME);
     }
 
     /**
@@ -87,9 +89,9 @@ protected function getEnvironmentSetUp($app)
     {
         $app['config']->set('database.default', 'testbench');
         $app['config']->set('database.connections.testbench', [
-            'driver' => 'sqlite',
+            'driver'   => 'sqlite',
             'database' => ':memory:',
-            'prefix' => '',
+            'prefix'   => '',
         ]);
     }
 
@@ -104,7 +106,7 @@ private function runQuery($query)
         $command = "mysql -u $dbUsername ";
         $command .= $dbPassword ? " -p$dbPassword" : '';
         $command .= " -e '$query'";
-        exec($command . ' 2>/dev/null');
+        exec($command.' 2>/dev/null');
     }
 
     /**
@@ -115,9 +117,9 @@ public function makeCompetitors($championship, $users)
         foreach ($users as $user) {
             factory(Competitor::class)->create(
                 [
-                    'user_id' => $user->id,
+                    'user_id'         => $user->id,
                     'championship_id' => $championship->id,
-                    'confirmed' => 1,
+                    'confirmed'       => 1,
                 ]
             );
         }
@@ -138,6 +140,7 @@ public function generateTreeWithUI($setting)
             ->select($setting->numFighters, 'numFighters');
 
         $this->press('save');
+
         return $this;
     }
 
@@ -151,7 +154,7 @@ protected function checkGroupsNumber($setting, $numGroupsExpected, $currentTest)
             ->where('round', 1)
             ->count();
 
-        if ((int)($setting->numFighters / $setting->fightingAreas) <= 1) {
+        if ((int) ($setting->numFighters / $setting->fightingAreas) <= 1) {
             $this->assertTrue($count == 0);
 
             return;
@@ -159,15 +162,15 @@ protected function checkGroupsNumber($setting, $numGroupsExpected, $currentTest)
         $expected = $numGroupsExpected[$setting->numFighters - 1];
         if ($count != $expected) {
             dd(
-                ['Method' => $currentTest,
-                    'championship' => $setting->championship->id,
-                    'NumCompetitors' => $setting->numFighters,
-                    'preliminaryGroupSize' => $setting->preliminaryGroupSize,
-                    'NumArea' => $setting->fightingAreas,
-                    'isTeam' => $setting->isTeam,
-                    'Real' => $count,
-                    'Excepted' => $expected,
-                    'numGroupsExpected[' . ($setting->numFighters - 1) . ']' => $numGroupsExpected[$setting->numFighters - 1] . ' / ' . $setting->fightingAreas,
+                ['Method'                                                    => $currentTest,
+                    'championship'                                           => $setting->championship->id,
+                    'NumCompetitors'                                         => $setting->numFighters,
+                    'preliminaryGroupSize'                                   => $setting->preliminaryGroupSize,
+                    'NumArea'                                                => $setting->fightingAreas,
+                    'isTeam'                                                 => $setting->isTeam,
+                    'Real'                                                   => $count,
+                    'Excepted'                                               => $expected,
+                    'numGroupsExpected['.($setting->numFighters - 1).']' => $numGroupsExpected[$setting->numFighters - 1].' / '.$setting->fightingAreas,
                 ]
             );
         }
@@ -184,22 +187,21 @@ protected function checkFightsNumber($setting, $numFightsExpected, $methodName)
         $groupSize = $setting->hasPreliminary ? $setting->preliminaryGroupSize : 2;
         $count = $this->getFightsCount($setting->championship_id); // For round 1
 
-
-
-        if ((int)($setting->numFighters / $setting->fightingAreas) <= 1
+        if ((int) ($setting->numFighters / $setting->fightingAreas) <= 1
             || $setting->numFighters / ($groupSize * $setting->fightingAreas) < 1) {
             $this->assertTrue($count == 0);
+
             return;
         }
 
         if ($count != $numFightsExpected) {
-            dd(['Method' => $methodName,
+            dd(['Method'      => $methodName,
                 'numFighters' => $setting->numFighters,
-                'NumArea' => $setting->fightingAreas,
-                'groupSize' => $groupSize,
-                'Real' => $count,
-                'isTeam' => $setting->isTeam,
-                'Excepted' => $numFightsExpected,
+                'NumArea'     => $setting->fightingAreas,
+                'groupSize'   => $groupSize,
+                'Real'        => $count,
+                'isTeam'      => $setting->isTeam,
+                'Excepted'    => $numFightsExpected,
             ]);
         }
         $this->assertTrue($count == $numFightsExpected);
@@ -207,6 +209,7 @@ protected function checkFightsNumber($setting, $numFightsExpected, $methodName)
 
     /**
      * @param $championshipId
+     *
      * @return int
      */
     protected function getFightsCount($championshipId)
@@ -238,17 +241,17 @@ public function initialSeed()
         $dateIni = $faker->dateTimeBetween('now', '+2 weeks')->format('Y-m-d');
         $user = factory(User::class)->create(['name' => 'user']);
         Tournament::create([
-            'id' => 1,
-            'slug' => md5(uniqid(rand(), true)),
-            'user_id' => $user->id,
-            'name' => 'Test Tournament',
-            'dateIni' => $dateIni,
-            'dateFin' => $dateIni,
+            'id'                => 1,
+            'slug'              => md5(uniqid(rand(), true)),
+            'user_id'           => $user->id,
+            'name'              => 'Test Tournament',
+            'dateIni'           => $dateIni,
+            'dateFin'           => $dateIni,
             'registerDateLimit' => $dateIni,
-            'sport' => 1,
-            'type' => 0,
-            'level_id' => 7,
-            'venue_id' => $faker->randomElement($venues),
+            'sport'             => 1,
+            'type'              => 0,
+            'level_id'          => 7,
+            'venue_id'          => $faker->randomElement($venues),
 
         ]);
 
@@ -268,8 +271,8 @@ public function initialSeed()
         foreach ($users as $user) {
             factory(Competitor::class)->create([
                 'championship_id' => $championship->id,
-                'user_id' => $user->id,
-                'confirmed' => 1,
+                'user_id'         => $user->id,
+                'confirmed'       => 1,
             ]);
         }
     }
diff --git a/translations/en/core.php b/translations/en/core.php
index 5ed09c7..469877e 100644
--- a/translations/en/core.php
+++ b/translations/en/core.php
@@ -3,17 +3,17 @@
 return [
 
     // CategorySetting
-    'treeType'             => 'Tree Type',
-    'playoff'              => 'Playoff',
-    'single_elimination'   => 'Single Elimination',
-    'teamSize'             => 'Team size',
-    'teamSizeReserve'      => 'Team Reserve',
-    'fightingArea'         => 'Area|Areas',
-    'hasPreliminary'       => 'Preliminary',
-    'preliminaryWinner'    => 'Winners x Group',
-    'isTeam'               => 'Team?',
-    'preliminaryGroupSize' => 'Group size',
+    'treeType'                => 'Tree Type',
+    'playoff'                 => 'Playoff',
+    'single_elimination'      => 'Single Elimination',
+    'teamSize'                => 'Team size',
+    'teamSizeReserve'         => 'Team Reserve',
+    'fightingArea'            => 'Area|Areas',
+    'hasPreliminary'          => 'Preliminary',
+    'preliminaryWinner'       => 'Winners x Group',
+    'isTeam'                  => 'Team?',
+    'preliminaryGroupSize'    => 'Group size',
     'min_competitor_required' => 'With this configuration, you must have at least :number :fighter_type',
-    'competitor' => 'competitor|competitors',
-    'team' => 'team|teams'
+    'competitor'              => 'competitor|competitors',
+    'team'                    => 'team|teams',
 ];