Esempio n. 1
0
  @Test
  public void musicNoteReadTest3() throws Exception {

    assertAmbiguityFree(parser, "2Ebb"); // Nos garantiza que es válido y no hay ambigüedades
    MusicNote note = parser.parse("2Ebb");

    assertTrue(note instanceof AbsoluteMusicNote);
    AbsoluteMusicNote aNote = (AbsoluteMusicNote) note;

    assertEquals(2, aNote.getOctave().intValue());

    assertTrue(
        aNote.getMusicNoteName()
            instanceof AlteredNoteName); // Idem, tienes que implementar getNoteName()
    AlteredNoteName altNoteName = (AlteredNoteName) aNote.getMusicNoteName();

    BasicNoteName bNoteName = altNoteName.getBasicNoteName();
    assertEquals(
        "E",
        bNoteName
            .getValue()); // Implementa ese getValue también, así es independiente del toString (que
                          // da la traducción a lilypond y que podría cambiar en un futuro).

    Alteration alteration = altNoteName.getAlteration();
    assertTrue(alteration instanceof DoubleFlatAlteration);
    DoubleFlatAlteration dSharpAlteration = (DoubleFlatAlteration) alteration;
    assertEquals("bb", dSharpAlteration.getValue());
  }
Esempio n. 2
0
  @Test
  public void musicNoteReadTest7() throws Exception {

    assertAmbiguityFree(parser, "G"); // Nos garantiza que es válido y no hay ambigüedades
    MusicNote note = parser.parse("G");

    assertTrue(note instanceof RelativeMusicNote);
    RelativeMusicNote rNote = (RelativeMusicNote) note;

    // Check the alteration
    assertNull(rNote.getOctave());

    MusicNoteName mNoteName = rNote.getMusicNoteName();
    assertTrue(mNoteName instanceof BasicNoteName);
    BasicNoteName bNoteName = (BasicNoteName) mNoteName;

    assertEquals("G", bNoteName.getValue());
  }
Esempio n. 3
0
  // Comprobamos si la información leída de una nota es correcta:
  @Test
  public void musicNoteReadTest1() throws Exception {

    assertAmbiguityFree(parser, "-2D"); // Nos garantiza que es válido y no hay ambigüedades
    MusicNote note = parser.parse("-2D");

    assertTrue(note instanceof AbsoluteMusicNote);
    AbsoluteMusicNote aNote = (AbsoluteMusicNote) note;

    assertEquals(-2, aNote.getOctave().intValue());

    assertTrue(
        aNote.getMusicNoteName()
            instanceof BasicNoteName); // Idem, tienes que implementar getNoteName()
    BasicNoteName bNoteName = (BasicNoteName) aNote.getMusicNoteName();

    assertEquals(
        "D",
        bNoteName
            .getValue()); // Implementa ese getValue también, así es independiente del toString (que
                          // da la traducción a lilypond y que podría cambiar en un futuro).
  }
Esempio n. 4
0
  @Test
  public void musicNoteReadTest4() throws Exception {

    assertAmbiguityFree(parser, "A#"); // Nos garantiza que es válido y no hay ambigüedades
    MusicNote note = parser.parse("A#");

    assertTrue(note instanceof RelativeMusicNote);
    RelativeMusicNote rNote = (RelativeMusicNote) note;

    assertNull(rNote.getOctave());

    MusicNoteName mNoteName = rNote.getMusicNoteName();

    assertTrue(mNoteName instanceof AlteredNoteName);
    AlteredNoteName altNoteName = (AlteredNoteName) mNoteName;

    assertEquals("A", altNoteName.getBasicNoteName().getValue());

    Alteration alteration = altNoteName.getAlteration();
    assertTrue(alteration instanceof SharpAlteration);
    SharpAlteration sharpAlteration = (SharpAlteration) alteration;
    assertEquals("#", sharpAlteration.getValue());
  }
Esempio n. 5
0
 // Comprobamos que las siguientes notas son válidas y se leen sin ambigüedades.
 @Test
 public void musicNoteValidTest() {
   assertAmbiguityFree(parser, "-2D");
   assertAmbiguityFree(parser, "4C");
   assertAmbiguityFree(parser, "2Ebb");
   assertAmbiguityFree(parser, "Ebb");
   assertAmbiguityFree(parser, "3D#");
   assertAmbiguityFree(parser, "G");
   assertAmbiguityFree(parser, "3Dx");
   assertAmbiguityFree(parser, "4Gx");
   assertAmbiguityFree(parser, "-3Ab");
   assertAmbiguityFree(parser, "1Dx");
   assertAmbiguityFree(parser, "B");
   assertAmbiguityFree(parser, "D#");
   assertAmbiguityFree(parser, "Fbb");
   assertAmbiguityFree(parser, "-1C");
   assertAmbiguityFree(parser, "1Fx");
   assertAmbiguityFree(parser, "A#");
   assertAmbiguityFree(parser, "4Ax");
   assertAmbiguityFree(parser, "A''");
   assertAmbiguityFree(parser, "B");
   assertAmbiguityFree(parser, "R");
   assertAmbiguityFree(parser, "S");
   assertAmbiguityFree(parser, "R");
   assertAmbiguityFree(parser, "_");
 }