Merge branch 'master' into url-parsing-support

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -70,6 +70,7 @@ namespace osu.Game.Tests.Visual
 
             testRemoveAll();
             testEmptyTraversal();
+            testHiding();
         }
 
         private void ensureRandomFetchSuccess() =>
@@ -295,6 +296,40 @@ namespace osu.Game.Tests.Visual
             checkNoSelection();
         }
 
+        private void testHiding()
+        {
+            var hidingSet = createTestBeatmapSet(1);
+            hidingSet.Beatmaps[1].Hidden = true;
+            AddStep("Add set with diff 2 hidden", () => carousel.UpdateBeatmapSet(hidingSet));
+            setSelected(1, 1);
+
+            checkVisibleItemCount(true, 2);
+            advanceSelection(true);
+            checkSelected(1, 3);
+
+            setHidden(3);
+            checkSelected(1, 1);
+
+            setHidden(2, false);
+            advanceSelection(true);
+            checkSelected(1, 2);
+
+            setHidden(1);
+            checkSelected(1, 2);
+
+            setHidden(2);
+            checkNoSelection();
+
+            void setHidden(int diff, bool hidden = true)
+            {
+                AddStep((hidden ? "" : "un") + $"hide diff {diff}", () =>
+                {
+                    hidingSet.Beatmaps[diff - 1].Hidden = hidden;
+                    carousel.UpdateBeatmapSet(hidingSet);
+                });
+            }
+        }
+
         private BeatmapSetInfo createTestBeatmapSet(int i)
         {
             return new BeatmapSetInfo

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -1,69 +1,161 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
+using System.Collections.Generic;
+using System.Linq;
 using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Select;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual
 {
     public class TestCaseBeatmapInfoWedge : OsuTestCase
     {
-        private BeatmapManager beatmaps;
-        private readonly Random random;
-        private readonly BeatmapInfoWedge infoWedge;
+        private RulesetStore rulesets;
+        private TestBeatmapInfoWedge infoWedge;
+        private readonly List<Beatmap> beatmaps = new List<Beatmap>();
         private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
-        public TestCaseBeatmapInfoWedge()
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, RulesetStore rulesets)
         {
-            random = new Random(0123);
+            this.rulesets = rulesets;
 
-            Add(infoWedge = new BeatmapInfoWedge
+            beatmap.BindTo(game.Beatmap);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Add(infoWedge = new TestBeatmapInfoWedge
             {
                 Size = new Vector2(0.5f, 245),
                 RelativeSizeAxes = Axes.X,
-                Margin = new MarginPadding
-                {
-                    Top = 20,
-                },
+                Margin = new MarginPadding { Top = 20 }
             });
 
             AddStep("show", () =>
             {
-                Content.FadeInFromZero(250);
                 infoWedge.State = Visibility.Visible;
                 infoWedge.UpdateBeatmap(beatmap);
             });
-            AddStep("hide", () =>
+
+            AddWaitStep(3);
+
+            AddStep("hide", () => { infoWedge.State = Visibility.Hidden; });
+
+            AddWaitStep(3);
+
+            AddStep("show", () => { infoWedge.State = Visibility.Visible; });
+
+            foreach (var rulesetInfo in rulesets.AvailableRulesets)
             {
-                infoWedge.State = Visibility.Hidden;
-                Content.FadeOut(100);
+                var ruleset = rulesetInfo.CreateInstance();
+                beatmaps.Add(createTestBeatmap(rulesetInfo));
+
+                var name = rulesetInfo.ShortName;
+                selectBeatmap(name);
+
+                // TODO: adjust cases once more info is shown for other gamemodes
+                switch (ruleset)
+                {
+                    case OsuRuleset osu:
+                        testOsuBeatmap(osu);
+                        testInfoLabels(5);
+                        break;
+                    default:
+                        testInfoLabels(2);
+                        break;
+                }
+            }
+
+            testNullBeatmap();
+        }
+
+        private void testOsuBeatmap(OsuRuleset ruleset)
+        {
+            AddAssert("check version", () => infoWedge.Info.VersionLabel.Text == $"{ruleset.ShortName}Version");
+            AddAssert("check title", () => infoWedge.Info.TitleLabel.Text == $"{ruleset.ShortName}Source — {ruleset.ShortName}Title");
+            AddAssert("check artist", () => infoWedge.Info.ArtistLabel.Text == $"{ruleset.ShortName}Artist");
+            AddAssert("check author", () => infoWedge.Info.MapperContainer.Children.OfType<OsuSpriteText>().Any(s => s.Text == $"{ruleset.ShortName}Author"));
+        }
+
+        private void testInfoLabels(int expectedCount)
+        {
+            AddAssert("check infolabels exists", () => infoWedge.Info.InfoLabelContainer.Children.Any());
+            AddAssert("check infolabels count", () => infoWedge.Info.InfoLabelContainer.Children.Count == expectedCount);
+        }
+
+        private void testNullBeatmap()
+        {
+            selectNullBeatmap();
+            AddAssert("check empty version", () => string.IsNullOrEmpty(infoWedge.Info.VersionLabel.Text));
+            AddAssert("check default title", () => infoWedge.Info.TitleLabel.Text == beatmap.Default.BeatmapInfo.Metadata.Title);
+            AddAssert("check default artist", () => infoWedge.Info.ArtistLabel.Text == beatmap.Default.BeatmapInfo.Metadata.Artist);
+            AddAssert("check empty author", () => !infoWedge.Info.MapperContainer.Children.Any());
+            AddAssert("check no infolabels", () => !infoWedge.Info.InfoLabelContainer.Children.Any());
+        }
+
+        private void selectBeatmap(string name)
+        {
+            var infoBefore = infoWedge.Info;
+
+            AddStep($"select {name} beatmap", () =>
+            {
+                beatmap.Value = new TestWorkingBeatmap(beatmaps.First(b => b.BeatmapInfo.Ruleset.ShortName == name));
+                infoWedge.UpdateBeatmap(beatmap);
             });
-            AddStep("random beatmap", randomBeatmap);
-            AddStep("null beatmap", () => infoWedge.UpdateBeatmap(beatmap.Default));
+
+            AddUntilStep(() => infoWedge.Info != infoBefore, "wait for async load");
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuGameBase game, BeatmapManager beatmaps)
+        private void selectNullBeatmap()
         {
-            this.beatmaps = beatmaps;
-            beatmap.BindTo(game.Beatmap);
+            AddStep("select null beatmap", () =>
+            {
+                beatmap.Value = beatmap.Default;
+                infoWedge.UpdateBeatmap(beatmap);
+            });
         }
 
-        private void randomBeatmap()
+        private Beatmap createTestBeatmap(RulesetInfo ruleset)
         {
-            var sets = beatmaps.GetAllUsableBeatmapSets();
-            if (sets.Count == 0)
-                return;
+            List<HitObject> objects = new List<HitObject>();
+            for (double i = 0; i < 50000; i += 1000)
+                objects.Add(new HitObject { StartTime = i });
 
-            var b = sets[random.Next(0, sets.Count)].Beatmaps[0];
-            beatmap.Value = beatmaps.GetWorkingBeatmap(b);
-            infoWedge.UpdateBeatmap(beatmap);
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        AuthorString = $"{ruleset.ShortName}Author",
+                        Artist = $"{ruleset.ShortName}Artist",
+                        Source = $"{ruleset.ShortName}Source",
+                        Title = $"{ruleset.ShortName}Title"
+                    },
+                    Ruleset = ruleset,
+                    StarDifficulty = 6,
+                    Version = $"{ruleset.ShortName}Version"
+                },
+                HitObjects = objects
+            };
+        }
+
+        private class TestBeatmapInfoWedge : BeatmapInfoWedge
+        {
+            public new BufferedWedgeInfo Info => base.Info;
         }
     }
 }

osu.Game.Tests/Visual/TestCaseBeatmapScoresContainer.cs

@@ -160,9 +160,9 @@ namespace osu.Game.Tests.Visual
             };
             foreach(var s in scores)
             {
-                s.Statistics.Add("300", RNG.Next(2000));
-                s.Statistics.Add("100", RNG.Next(2000));
-                s.Statistics.Add("50", RNG.Next(2000));
+                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
             }
 
             anotherScores = new[]
@@ -272,9 +272,9 @@ namespace osu.Game.Tests.Visual
             };
             foreach (var s in anotherScores)
             {
-                s.Statistics.Add("300", RNG.Next(2000));
-                s.Statistics.Add("100", RNG.Next(2000));
-                s.Statistics.Add("50", RNG.Next(2000));
+                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
             }
 
             topScore = new OnlineScore
@@ -299,9 +299,9 @@ namespace osu.Game.Tests.Visual
                 TotalScore = 987654321,
                 Accuracy = 0.8487,
             };
-            topScore.Statistics.Add("300", RNG.Next(2000));
-            topScore.Statistics.Add("100", RNG.Next(2000));
-            topScore.Statistics.Add("50", RNG.Next(2000));
+            topScore.Statistics.Add(HitResult.Great, RNG.Next(2000));
+            topScore.Statistics.Add(HitResult.Good, RNG.Next(2000));
+            topScore.Statistics.Add(HitResult.Meh, RNG.Next(2000));
         }
 
         [BackgroundDependencyLoader]

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Hover first button", () => failOverlay.Buttons.First().TriggerOnHover(null));
+            AddStep("Hover first button", () => failOverlay.Buttons.First().TriggerOnMouseMove(null));
             AddStep("Hide overlay", () => failOverlay.Hide());
 
             AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected));
@@ -162,7 +162,7 @@ namespace osu.Game.Tests.Visual
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
             AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
-            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
             AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected);
             AddAssert("Second button selected", () => secondButton.Selected);
 
@@ -178,7 +178,7 @@ namespace osu.Game.Tests.Visual
 
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
-            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
             AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
             AddAssert("Second button not selected", () => !secondButton.Selected);
             AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
@@ -195,7 +195,7 @@ namespace osu.Game.Tests.Visual
 
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
-            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
             AddStep("Unhover second button", () => secondButton.TriggerOnHoverLost(null));
             AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
             AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected); // Initial state condition

osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -1,9 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
@@ -15,6 +18,16 @@ namespace osu.Game.Tests.Visual
         private readonly NotificationOverlay manager;
         private readonly List<ProgressNotification> progressingNotifications = new List<ProgressNotification>();
 
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(NotificationSection),
+            typeof(SimpleNotification),
+            typeof(ProgressNotification),
+            typeof(ProgressCompletionNotification),
+            typeof(IHasCompletionTarget),
+            typeof(Notification)
+        };
+
         public TestCaseNotificationOverlay()
         {
             progressingNotifications.Clear();
@@ -25,15 +38,48 @@ namespace osu.Game.Tests.Visual
                 Origin = Anchor.TopRight
             });
 
-            AddStep(@"toggle", manager.ToggleVisibility);
+            SpriteText displayedCount = new SpriteText();
+
+            Content.Add(displayedCount);
+
+            void setState(Visibility state) => AddStep(state.ToString(), () => manager.State = state);
+            void checkProgressingCount(int expected) => AddAssert($"progressing count is {expected}", () => progressingNotifications.Count == expected);
+
+            manager.UnreadCount.ValueChanged += count => { displayedCount.Text = $"displayed count: {count}"; };
+
+
+            setState(Visibility.Visible);
             AddStep(@"simple #1", sendHelloNotification);
             AddStep(@"simple #2", sendAmazingNotification);
             AddStep(@"progress #1", sendUploadProgress);
             AddStep(@"progress #2", sendDownloadProgress);
-            AddStep(@"barrage", () => sendBarrage());
+
+            checkProgressingCount(2);
+
+            setState(Visibility.Hidden);
+
+            AddRepeatStep(@"add many simple", sendManyNotifications, 3);
+            AddWaitStep(5);
+
+            checkProgressingCount(0);
+
+            AddStep(@"progress #3", sendUploadProgress);
+
+            checkProgressingCount(1);
+
+            AddAssert("Displayed count is 33", () => manager.UnreadCount.Value == 33);
+
+            AddWaitStep(10);
+
+            checkProgressingCount(0);
+
+
+            setState(Visibility.Visible);
+
+            //AddStep(@"barrage", () => sendBarrage());
         }
 
-        private void sendBarrage(int remaining = 100)
+        private void sendBarrage(int remaining = 10)
         {
             switch (RNG.Next(0, 4))
             {
@@ -63,7 +109,7 @@ namespace osu.Game.Tests.Visual
 
             if (progressingNotifications.Count(n => n.State == ProgressNotificationState.Active) < 3)
             {
-                var p = progressingNotifications.FirstOrDefault(n => n.IsAlive && n.State == ProgressNotificationState.Queued);
+                var p = progressingNotifications.FirstOrDefault(n => n.State == ProgressNotificationState.Queued);
                 if (p != null)
                     p.State = ProgressNotificationState.Active;
             }
@@ -71,7 +117,7 @@ namespace osu.Game.Tests.Visual
             foreach (var n in progressingNotifications.FindAll(n => n.State == ProgressNotificationState.Active))
             {
                 if (n.Progress < 1)
-                    n.Progress += (float)(Time.Elapsed / 2000) * RNG.NextSingle();
+                    n.Progress += (float)(Time.Elapsed / 400) * RNG.NextSingle();
                 else
                     n.State = ProgressNotificationState.Completed;
             }
@@ -108,5 +154,11 @@ namespace osu.Game.Tests.Visual
         {
             manager.Post(new SimpleNotification { Text = @"Welcome to osu!. Enjoy your stay!" });
         }
+
+        private void sendManyNotifications()
+        {
+            for (int i = 0; i < 10; i++)
+                manager.Post(new SimpleNotification { Text = @"Spam incoming!!" });
+        }
     }
 }

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -26,6 +26,7 @@ namespace osu.Game.Tests.Visual
         private RulesetStore rulesets;
 
         private DependencyContainer dependencies;
+        private WorkingBeatmap defaultBeatmap;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -47,31 +48,61 @@ namespace osu.Game.Tests.Visual
 
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) => dependencies = new DependencyContainer(parent);
 
+        private class TestSongSelect : PlaySongSelect
+        {
+            public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
+            public new BeatmapCarousel Carousel => base.Carousel;
+        }
+
         [BackgroundDependencyLoader]
         private void load(BeatmapManager baseManager)
         {
-            PlaySongSelect songSelect;
+            TestSongSelect songSelect = null;
 
-            if (manager == null)
+            var storage = new TestStorage(@"TestCasePlaySongSelect");
+
+            // this is by no means clean. should be replacing inside of OsuGameBase somehow.
+            var context = new OsuDbContext();
+
+            Func<OsuDbContext> contextFactory = () => context;
+
+            dependencies.Cache(rulesets = new RulesetStore(contextFactory));
+            dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null)
             {
-                var storage = new TestStorage(@"TestCasePlaySongSelect");
+                DefaultBeatmap = defaultBeatmap = baseManager.GetWorkingBeatmap(null)
+            });
 
-                // this is by no means clean. should be replacing inside of OsuGameBase somehow.
-                var context = new OsuDbContext();
+            void loadNewSongSelect(bool deleteMaps = false) => AddStep("reload song select", () =>
+            {
+                if (deleteMaps) manager.DeleteAll();
 
-                Func<OsuDbContext> contextFactory = () => context;
-
-                dependencies.Cache(rulesets = new RulesetStore(contextFactory));
-                dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null)
+                if (songSelect != null)
                 {
-                    DefaultBeatmap = baseManager.GetWorkingBeatmap(null)
-                });
+                    Remove(songSelect);
+                    songSelect.Dispose();
+                }
 
+                Add(songSelect = new TestSongSelect());
+            });
+
+            loadNewSongSelect(true);
+
+            AddWaitStep(3);
+
+            AddAssert("dummy selected", () => songSelect.CurrentBeatmap == defaultBeatmap);
+
+            AddStep("import test maps", () =>
+            {
                 for (int i = 0; i < 100; i += 10)
                     manager.Import(createTestBeatmapSet(i));
-            }
+            });
 
-            Add(songSelect = new PlaySongSelect());
+            AddWaitStep(3);
+            AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
+
+            loadNewSongSelect();
+            AddWaitStep(3);
+            AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
 
             AddStep(@"Sort by Artist", delegate { songSelect.FilterControl.Sort = SortMode.Artist; });
             AddStep(@"Sort by Title", delegate { songSelect.FilterControl.Sort = SortMode.Title; });

osu.Game.Tests/Visual/TestCasePopupDialog.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCasePopupDialog : OsuTestCase
+    {
+        public TestCasePopupDialog()
+        {
+            var popup = new PopupDialog
+            {
+                RelativeSizeAxes = Axes.Both,
+                State = Framework.Graphics.Containers.Visibility.Visible,
+                Icon = FontAwesome.fa_assistive_listening_systems,
+                HeaderText = @"This is a test popup",
+                BodyText = "I can say lots of stuff and even wrap my words!",
+                Buttons = new PopupDialogButton[]
+                {
+                    new PopupDialogCancelButton
+                    {
+                        Text = @"Yes. That you can.",
+                    },
+                    new PopupDialogOkButton
+                    {
+                        Text = @"You're a fake!",
+                    },
+                }
+            };
+
+            Add(popup);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseResults.cs

@@ -15,6 +15,15 @@ namespace osu.Game.Tests.Visual
     {
         private BeatmapManager beatmaps;
 
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Score),
+            typeof(Results),
+            typeof(ResultsPage),
+            typeof(ResultsPageScore),
+            typeof(ResultsPageRanking)
+        };
+
         [BackgroundDependencyLoader]
         private void load(BeatmapManager beatmaps)
         {
@@ -41,12 +50,12 @@ namespace osu.Game.Tests.Visual
                 MaxCombo = 123,
                 Rank = ScoreRank.A,
                 Date = DateTimeOffset.Now,
-                Statistics = new Dictionary<string, dynamic>
+                Statistics = new Dictionary<HitResult, dynamic>
                 {
-                    { "300", 50 },
-                    { "100", 20 },
-                    { "50", 50 },
-                    { "x", 1 }
+                    { HitResult.Great, 50 },
+                    { HitResult.Good, 20 },
+                    { HitResult.Meh, 50 },
+                    { HitResult.Miss, 1 }
                 },
                 User = new User
                 {

osu.Game.Tests/Visual/TestCaseToolbar.cs

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays.Toolbar;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseToolbar : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ToolbarButton),
+            typeof(ToolbarModeSelector),
+            typeof(ToolbarModeButton),
+            typeof(ToolbarNotificationButton),
+        };
+
+        public TestCaseToolbar()
+        {
+            var toolbar = new Toolbar { State = Visibility.Visible };
+
+            Add(toolbar);
+
+            var notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
+
+            void setNotifications(int count) => AddStep($"set notification count to {count}", () => notificationButton.NotificationCount.Value = count);
+
+            setNotifications(1);
+            setNotifications(2);
+            setNotifications(3);
+            setNotifications(0);
+            setNotifications(144);
+        }
+    }
+}