Write tests for class "NoteJudger"

Extract class from class "GameManager"
Separate class "Note", "Controller"

Assets/InitTestScene636540527754821606.unity.meta

+fileFormatVersion: 2
+guid: c58b960471464594ba79b7b4bb9d8456
+timeCreated: 1518423575
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/InitTestScene636540763273503500.unity.meta

+fileFormatVersion: 2
+guid: 2a5bdfec747c5554bb8e1836bbde9bfa
+timeCreated: 1518447127
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/JudgeModule/Judge.cs

@@ -67,23 +67,9 @@ namespace JudgeModule
     
         public static bool IsNoteEnd(Note note, float elapsedTime)
         {
-            return elapsedTime - note.EndTiming <= BadTime;
-        }
-    
-        public static bool IsNoteComboBroken(Judge judge)
-        {
-            return judge == BAD ||
-                   judge == MISS;
-        }
-
-        public static bool IsNoteBroken(Note note, float timing)
-        {
-            var isEnd = IsNoteEnd(note, timing);
-            var judge = TestJudge(note, timing, isEnd);
-
-            return note.IsLong &&
-                   !isEnd      &&
-                   IsNoteComboBroken(judge);
+            var timing = elapsedTime - note.EndTiming;
+            return timing <= BadTime &&
+                   timing >= 0;
         }
     }
 }
\ No newline at end of file

Assets/JudgeModule/NoteCondition.cs

@@ -71,8 +71,7 @@ namespace JudgeModule
 
         public bool IsLongNoteFinishIncorrectly(Note note, float timing)
         {
-            var stat = JudgeInput(note);
-            return stat["long"] == InputStatus.Stopped &&
+            return JudgeInput(note)["long"] == InputStatus.Stopped &&
                    (
                         !note.Activated ||
                         !Judge.IsNoteEnd(note, timing)

Assets/JudgeModule/NoteJudger.cs

@@ -6,14 +6,14 @@ namespace JudgeModule
 {
     public class NoteJudger
     {
-        private Transform offset;
+        private Transform deactives;
         private Action<int> EndGame;
         private GameObject judgeText;
 
         public NoteJudger(Action<int> endgame)
         {
-            offset = GameObject.Find("Offset").transform;
-            judgeText = GameObject.Find("JudgeText");
+            deactives = GameObject.Find("Deactives").    transform;
+            judgeText = GameObject.Find("Judge");
             EndGame = endgame;
         }
 
@@ -28,9 +28,11 @@ namespace JudgeModule
 
         public void EnteredNoteProc(Note note, float timing)
         {
-            SetJudge(Judge.TestJudge(note, timing));
+            var judge = Judge.TestJudge(note, timing);
 
-            if (note.IsLong)
+            SetJudge(judge);
+
+            if (note.IsLong && !judge.IsBreak)
                 note.Activated = true;
             else
                 DeactivateNote(note);
@@ -38,9 +40,13 @@ namespace JudgeModule
 
         public void ContinuingNoteProc(Note note, float timing)
         {
-            SetJudge(Judge.TestJudge(note, timing, Judge.IsNoteEnd(note, timing)));
+            var isEnd = Judge.IsNoteEnd(note, timing);
+            var judge = Judge.TestJudge(note, timing, isEnd);
+
+            SetJudge(judge);
 
-            if (Judge.IsNoteBroken(note, timing))
+            if (!isEnd && 
+                judge.IsBreak)
                 DeactivateNote(note);
         }
 
@@ -50,28 +56,23 @@ namespace JudgeModule
             DeactivateNote(note);
         }
 
-        public void IncorrectlyStoppedNoteProc(Note note, float timing)
+        public void IncorrectlyStoppedNoteProc(Note note, float timing = 0)
         {
-            var judge = Judge.TestJudge(note, timing, note.Activated);
-            SetJudge(Judge.IsNoteComboBroken(judge) ? judge : Judge.MISS);
+            SetJudge(Judge.MISS);
             DeactivateNote(note);
         }
 
         public void DeactivateNote(Note note)
         {
-            note.Activated = false;
-            note.Component.transform.SetParent(offset);
             note.Component.Deactivate();
+            note.Component.transform.SetParent(deactives);
         }
 
         public void SetJudge(Judge judge)
         {
-            if (!judge.IsBreak)
-                ++GameManager.Instance.Combo;
-            else
-                GameManager.Instance.Combo = 0;
-            GameManager.Instance.Score += judge.Score;
-            GameManager.Instance.JudgeCount[judge]++;
+            AllSceneManager.Combo = judge.IsBreak ? 0 : AllSceneManager.Combo + 1;
+            AllSceneManager.Score += judge.Score;
+            AllSceneManager.JudgeCount[judge]++;
 
             judgeText.SetActive(true);
             judgeText.GetComponent<Text>().text = judge.Name;

Assets/Scene/test.unity

@@ -141,6 +141,8 @@ RectTransform:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
   - {fileID: 1152155867}
+  - {fileID: 1593383018}
+  - {fileID: 2005579197}
   - {fileID: 2001722607}
   m_Father: {fileID: 1073141667}
   m_RootOrder: 0
@@ -182,6 +184,39 @@ CanvasRenderer:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 295245169}
+--- !u!1 &323877636
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 323877637}
+  m_Layer: 5
+  m_Name: Deactives
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &323877637
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 323877636}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2001722607}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 1.5, y: 0}
+  m_SizeDelta: {x: 3, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
 --- !u!1 &410373230
 GameObject:
   m_ObjectHideFlags: 0
@@ -851,6 +886,39 @@ Transform:
   m_Father: {fileID: 0}
   m_RootOrder: 4
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1593383017
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1593383018}
+  m_Layer: 5
+  m_Name: NoteAppear
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1593383018
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1593383017}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 295245170}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: 490, y: 0}
+  m_SizeDelta: {x: 3, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
 --- !u!1 &2001722606
 GameObject:
   m_ObjectHideFlags: 0
@@ -877,11 +945,45 @@ RectTransform:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
   - {fileID: 791052775}
+  - {fileID: 323877637}
   m_Father: {fileID: 295245170}
-  m_RootOrder: 1
+  m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
   m_AnchorMax: {x: 0, y: 1}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 3, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
+--- !u!1 &2005579196
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2005579197}
+  m_Layer: 5
+  m_Name: NoteDisappear
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &2005579197
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2005579196}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 295245170}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 1}
+  m_AnchoredPosition: {x: -485, y: 0}
+  m_SizeDelta: {x: 3, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}

Assets/Script/AllSceneManager.cs

+using JudgeModule;
+using System.Collections.Generic;
+
+public static class AllSceneManager
+{
+    private static int                   combo;
+
+    public static int                    LongestCombo,
+                                         Score;
+
+    public static Dictionary<Judge, int> JudgeCount
+        = new Dictionary<Judge, int>
+    {
+        { Judge.JudgeList[0], 0 },
+        { Judge.JudgeList[1], 0 },
+        { Judge.JudgeList[2], 0 },
+        { Judge.JudgeList[3], 0 },
+    };
+
+    public static int Combo
+    {
+        get
+        {
+            return combo;
+        }
+        set
+        {
+            combo = value;
+
+            if (combo > LongestCombo)
+                LongestCombo = combo;
+        }
+    }
+
+    public static void InitJudgeResult()
+    {
+        combo = 0;
+        LongestCombo = 0;
+        Score = 0;
+        Judge.JudgeList.ForEach(x => JudgeCount[x] = 0);
+    }
+}
\ No newline at end of file

Assets/Script/AllSceneManager.cs.meta

+fileFormatVersion: 2
+guid: 88359e0a0320f3843b6ddf41ee34ef92
+timeCreated: 1518419152
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/Controller.cs

+using UnityEngine;
+using UnityEngine.UI;
+
+public class Controller : MonoBehaviour
+{
+    public Note Instance { get; set; }
+
+    private float time = 0f;
+
+    private readonly float minAlpha = 0.3f;
+    private readonly float maxAlpha = 0.7f;
+
+    public int id;
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (Instance.Activated)
+        {
+            time += Time.deltaTime * 3;
+
+            foreach (Image img in GetComponentsInChildren<Image>())
+            {
+                Color tmp = img.color;
+                tmp.a = 0f;
+                img.color = tmp + new Color(0, 0, 0,
+                    (maxAlpha + minAlpha) / 2
+                    + Mathf.Cos(time * 4) * (maxAlpha - minAlpha) / 2);
+            }
+        }
+    }
+
+    public void Deactivate()
+    {
+        Instance.Activated = false;
+
+        foreach (Image img in GetComponentsInChildren<Image>())
+        {
+            Color tmp = img.color;
+            tmp.a = 0f;
+            img.color = tmp + new Color(0, 0, 0, minAlpha);
+        }
+    }
+}
\ No newline at end of file

Assets/Script/Controller.cs.meta

+fileFormatVersion: 2
+guid: b737f60639949aa49b2fb5398fd15d71
+timeCreated: 1518439111
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/GameManager.cs

@@ -30,37 +30,11 @@ public class GameManager : MonoBehaviour {
     
     public TrackInfo CurrentTrack { get; set; }
 
-    private int combo = 0;
-    public int Combo
-    {
-        get { return combo; }
-        set
-        {
-            if (value > LongestCombo)
-                LongestCombo = value;
-            combo = value;
-        }
-    }
-    public int LongestCombo { get; set; }
-    public int Score { get; set; }
-    public Dictionary<Judge, int> JudgeCount = new Dictionary<Judge, int>
-    {
-        { Judge.JudgeList[0], 0 },
-        { Judge.JudgeList[1], 0 },
-        { Judge.JudgeList[2], 0 },
-        { Judge.JudgeList[3], 0 },
-    };
-
     // Use this for initialization
     void Start()
     {
         DontDestroyOnLoad(Instance);
     }
-	
-    // Update is called once per frame
-    void Update()
-    {
-    }
 
     public void SceneTransition(string sceneName, bool additive = false)
     {

Assets/Script/InGameManager.cs

@@ -137,7 +137,7 @@ public class InGameManager : MonoBehaviour {
         while (noteobj.transform.childCount != 0)
         {
             var note = noteobj.transform.GetChild(0).gameObject
-                              .GetComponent<Note.Controller>().Instance;
+                              .GetComponent<Controller>().Instance;
             if (!Judge.IsPastNote(note, timing))
                 return note;
             judger.SetJudge(Judge.MISS);
@@ -182,7 +182,7 @@ public class InGameManager : MonoBehaviour {
                 noteobj.transform)
                 as GameObject;
 
-        obj.AddComponent<Note.Controller>().Instance = note;
+        obj.AddComponent<Controller>().Instance = note;
 
         if (note.Type == NoteType.MeasureLine || note.Type == NoteType.BeatLine)
             obj.transform.SetParent(offset.transform);

Assets/Script/JudgeManager.cs

@@ -137,7 +137,7 @@ public class JudgeManager : MonoBehaviour
         while (noteobj.transform.childCount != 0)
         {
             var note = noteobj.transform.GetChild(0).gameObject
-                              .GetComponent<Note.Controller>().Instance;
+                              .GetComponent<Controller>().Instance;
             if (!Judge.IsPastNote(note, timing))
                 return note;
             judger.SetJudge(Judge.MISS);
@@ -167,12 +167,12 @@ public class JudgeManager : MonoBehaviour
     {
         if      (condition.IsLongNoteStartCorrectly(note))
             judger.EnteredNoteProc(note, timing);
-        else if (condition.IsLongNoteHoldCorrectly(note))
-            judger.ContinuingNoteProc(note, timing);
         else if (condition.IsLongNoteFinishCorrectly(note, timing))
             judger.CorrectlyStoppedNoteProc(note, timing);
         else if (condition.IsLongNoteFinishIncorrectly(note, timing))
             judger.IncorrectlyStoppedNoteProc(note, timing);
+        else if (condition.IsLongNoteHoldCorrectly(note))
+            judger.ContinuingNoteProc(note, timing);
     }
 
     void LoadNote(Note note)
@@ -182,7 +182,9 @@ public class JudgeManager : MonoBehaviour
                 noteobj.transform)
                 as GameObject;
 
-        obj.AddComponent<Note.Controller>().Instance = note;
+        var controller = obj.AddComponent<Controller>();
+        controller.Instance = note;
+        note.Component = controller;
 
         if (note.Type == NoteType.MeasureLine || note.Type == NoteType.BeatLine)
             obj.transform.SetParent(offset.transform);

Assets/Script/Note.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.UI;
-
-public enum NoteType { SBT, LBT, SMO, LMO, BeatLine, MeasureLine }
-
-public class Note
+public class Note
 {
-    public class Controller : MonoBehaviour
-    {
-        public Note Instance { get; set; }
-
-        private float time = 0f;
-
-        private readonly float minAlpha = 0.3f;
-        private readonly float maxAlpha = 0.7f;
-
-        // Use this for initialization
-        void Start()
-        {
-            Instance.Component = this;
-        }
-
-        // Update is called once per frame
-        void Update()
-        {
-            if (Instance.Activated)
-            {
-                time += Time.deltaTime * 3;
-
-                foreach (Image img in GetComponentsInChildren<Image>())
-                {
-                    Color tmp = img.color;
-                    tmp.a = 0f;
-                    img.color = tmp + new Color(0, 0, 0,
-                        (maxAlpha + minAlpha) / 2
-                        + Mathf.Cos(time * 4) * (maxAlpha - minAlpha) / 2);
-                }
-            }
-        }
-
-        public void Deactivate()
-        {
-            foreach (Image img in GetComponentsInChildren<Image>())
-            {
-                Color tmp = img.color;
-                tmp.a = 0f;
-                img.color = tmp + new Color(0, 0, 0, minAlpha);
-            }
-        }
-    }
+    public Controller Component = null;
 
-    public Controller Component { get; private set; }
+    public int id;
 
     public float StartTiming { get; private set; }
     public float EndTiming { get; private set; }
@@ -119,4 +70,4 @@ public class Note
     {
         Key = key;
     }
-}
+}
\ No newline at end of file

Assets/Script/NoteType.cs

+public enum NoteType
+{
+    SBT,
+    LBT,
+    SMO,
+    LMO,
+    BeatLine,
+    MeasureLine
+}
\ No newline at end of file

Assets/Script/NoteType.cs.meta

+fileFormatVersion: 2
+guid: 314342437ec9cf142918af22900f9e49
+timeCreated: 1518439111
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/ScoreDisplayManager.cs

@@ -14,12 +14,12 @@ public class ScoreDisplayManager : MonoBehaviour
     // Use this for initialization
     void Start ()
     {
-        Score.text   = GameManager.Instance.Score.ToString();
-        Perfect.text = GameManager.Instance.JudgeCount[Judge.JudgeList[0]].ToString();
-        Good.text    = GameManager.Instance.JudgeCount[Judge.JudgeList[1]].ToString();
-        Bad.text     = GameManager.Instance.JudgeCount[Judge.JudgeList[2]].ToString();
-        Miss.text    = GameManager.Instance.JudgeCount[Judge.JudgeList[3]].ToString();
-        Combo.text   = GameManager.Instance.LongestCombo.ToString();
+        Score.text   = AllSceneManager.Score.ToString();
+        Perfect.text = AllSceneManager.JudgeCount[Judge.JudgeList[0]].ToString();
+        Good.text    = AllSceneManager.JudgeCount[Judge.JudgeList[1]].ToString();
+        Bad.text     = AllSceneManager.JudgeCount[Judge.JudgeList[2]].ToString();
+        Miss.text    = AllSceneManager.JudgeCount[Judge.JudgeList[3]].ToString();
+        Combo.text   = AllSceneManager.LongestCombo.ToString();
     }
 
     // Update is called once per frame
@@ -27,9 +27,7 @@ public class ScoreDisplayManager : MonoBehaviour
     {
         if (Input.anyKey)
         {
-            GameManager.Instance.Score = 0;
-            Judge.JudgeList.ForEach(x => GameManager.Instance.JudgeCount[x] = 0);
-            GameManager.Instance.LongestCombo = 0;
+            AllSceneManager.InitJudgeResult();
             Destroy(this);
 
             GameManager.Instance.SceneTransition("SetSelect");

Assets/Script/Tests/NoteJudgerTests.cs

+using UnityEngine.TestTools;
+using System.Collections;
+using TrackAnalysis;
+using UnityEngine;
+using JudgeModule;
+using NUnit.Framework;
+using UnityEngine.UI;
+
+public class NoteJudgerTests
+{
+    [UnityTest]
+    public IEnumerator DeactivedNote_Should_Change_Parent_Deactives()
+    {
+        var note = CreateNoteAndController("SBT", 0);
+
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.DeactivateNote(note);
+
+        var expected = "Deactives";
+        var actual = note.Component.transform.parent.name;
+
+        Assert.AreEqual(expected, actual, "Deactivednote should change parent of note to deactives");
+    }
+
+    [UnityTest]
+    public IEnumerator SetJudge_Should_Change_Judge_Text()
+    {
+        var text = CreateJudgeText();
+
+        CreateNoteAndController("SBT", 0);
+
+        var judger = new NoteJudger(x => { });
+
+        int cnt = 0;
+        foreach (var x in Judge.JudgeList)
+        {
+            yield return null;
+
+            judger.SetJudge(x);
+
+            if (text.text == x.Name &&
+                text.color == x.Color)
+                ++cnt;
+        }
+
+        var expected = Judge.JudgeList.Count;
+        var actual = cnt;
+
+        Assert.AreEqual(expected, actual, "SetJudge should change judge text's text and color");
+    }
+
+    [UnityTest]
+    public IEnumerator WrongNoteProc_Should_Execute_EndGame_When_Button_Note()
+    {
+        var note = CreateNoteAndController("SBT", 0);
+
+        CreateJudgeText();
+
+        bool isEnd = false;
+        var judger = new NoteJudger(x => isEnd = true);
+
+        yield return null;
+
+        judger.WrongNoteProc(note);
+
+        var expected = true;
+        var actual = isEnd;
+
+        Assert.AreEqual(expected, actual, "WrongNoteProc should execute endgmae when button note");
+    }
+
+    [UnityTest]
+    public IEnumerator WrongNoteProc_Should_Not_Execute_EndGame_When_Motion_Note()
+    {
+        var note = CreateNoteAndController("SMO", 0);
+
+        CreateJudgeText();
+
+        bool isEnd = false;
+        var judger = new NoteJudger(x => isEnd = true);
+
+        yield return null;
+
+        judger.WrongNoteProc(note);
+
+        var expected = false;
+        var actual = isEnd;
+
+        Assert.AreEqual(expected, actual, "WrongNoteProc should not execute endgmae when motion note");
+    }
+
+    [UnityTest]
+    public IEnumerator EnteredNoteProc_Should_Change_Activated_True_When_Long_Note()
+    {
+        var note = CreateNoteAndController("LBT", 0, Judge.MISS.ButtonTimingRange + 10);
+
+        CreateJudgeText();
+        
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.EnteredNoteProc(note, note.StartTiming);
+
+        var expected = true;
+        var actual = note.Activated;
+
+        Assert.AreEqual(expected, actual, "WrongNoteProc should change activated to true when long note");
+    }
+
+    [UnityTest]
+    public IEnumerator EnteredNoteProc_Should_Not_Change_Activated_True_When_Short_Note()
+    {
+        var note = CreateNoteAndController("SBT", 0);
+
+        CreateJudgeText();
+
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.EnteredNoteProc(note, note.StartTiming);
+
+        var expected = false;
+        var actual = note.Activated;
+
+        Assert.AreEqual(expected, actual, "WrongNoteProc should not change activated to true when short note");
+    }
+
+    [UnityTest]
+    public IEnumerator ContinuingNoteProc_Should_Deactive_When_Not_End_And_Break()
+    {
+        var note = CreateNoteAndController("LBT", 0, Judge.BAD.ButtonTimingRange + 1);
+
+        CreateJudgeText();
+
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.ContinuingNoteProc(note, -(Judge.BAD.ButtonTimingRange + 1));
+
+        var expected = "Deactives";
+        var actual = note.Component.transform.parent.name;
+
+        Assert.AreEqual(expected, actual, "ContinuingNoteProc should deactive when not end and break");
+    }
+
+    [UnityTest]
+    public IEnumerator ContinuingNoteProc_Should_Not_Deactive_When_End()
+    {
+        var note = CreateNoteAndController("LBT", 0, 1);
+
+        CreateJudgeText();
+
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.ContinuingNoteProc(note, note.EndTiming);
+
+        var expected = "NoteObj";
+        var actual = note.Component.transform.parent.name;
+
+        Assert.AreEqual(expected, actual, "ContinuingNoteProc should not deactive when end");
+    }
+
+    [UnityTest]
+    public IEnumerator ContinuingNoteProc_Should_Not_Deactive_When_Not_Break()
+    {
+        var note = CreateNoteAndController("LBT", 0, Judge.BAD.ButtonTimingRange + 1);
+
+        CreateJudgeText();
+
+        var judger = new NoteJudger(x => { });
+
+        yield return null;
+
+        judger.ContinuingNoteProc(note, note.StartTiming);
+
+        var expected = "NoteObj";
+        var actual = note.Component.transform.parent.name;
+
+        Assert.AreEqual(expected, actual, "ContinuingNoteProc should not deactive when not break");
+    }
+
+    private Note CreateNoteAndController(string type, float start, float end = 0)
+    {
+        var noteobj = new GameObject("NoteObj");
+        var deactives = new GameObject("Deactives");
+
+        var notemaker = new NoteMaker();
+
+        Note note;
+        switch (type)
+        {
+            case "LBT":
+                notemaker.Make("AA", "LBT", start);
+                note = notemaker.Make("AA", "LBT", end);
+                break;
+            case "SMO":
+                note = notemaker.Make("CP", "SMO", start);
+                break;
+            case "LMO":
+                notemaker.Make("JS", "LMO", start);
+                note = notemaker.Make("JS", "LMO", end);
+                break;
+            default:
+                note = notemaker.Make("AA", "SBT", start);
+                break;
+        }
+        
+        var obj = new GameObject();
+        obj.transform.SetParent(noteobj.transform);
+
+        var controller = obj.AddComponent<Controller>();
+
+        controller.Instance = note;
+        note.Component = controller;
+
+        return note;
+    }
+
+    private Text CreateJudgeText()
+    {
+        var judgeText = new GameObject("Judge", typeof(RectTransform));
+
+        return judgeText.AddComponent<Text>();
+    }
+}
\ No newline at end of file

Assets/Script/Tests/NoteJudgerTests.cs.meta

+fileFormatVersion: 2
+guid: 674b5d1d3491540478920066190a9bfa
+timeCreated: 1518415235
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/NoteSignGenerator.cs

@@ -59,16 +59,9 @@ namespace TrackAnalysis
                 Func<int, float> calcTiming,
                 Func<string, float, Note> concreteNote)
         {
-            var disrange = DiscreteRange(range, x => currentCode(x));
-            var disRange = disrange.ToList();
-            var notes = disrange
-            .Select(x => concreteNote(currentCode(x), calcTiming(x)));
-            var Notes = notes.ToList();
-            return notes.Where(x => x != null);
-
-            /*return disrange
-            .Select(x => concreteNote(currentCode(x), calcTiming(x)))
-            .Where(x => x != null);*/
+            return DiscreteRange(range, x => currentCode(x))
+                    .Select(x => concreteNote(currentCode(x), calcTiming(x)))
+                    .Where(x => x != null);
         }
 
         private static