@Test
  public void deleteFragebogen() {

    Fragebogen gb = new Fragebogen();
    gb.setId(81);
    Mockito.when(fragebogenDAO.findById(gb.getId())).thenReturn(gb);
    gb.setExportiertQuestorPro(null);

    model.deleteFragebogen(gb);

    gb.setExportiertQuestorPro(false);

    Bewertung b = new Bewertung();
    gb.setBewertungen(Arrays.asList(new Bewertung[] {b}));

    Item i = new Item();

    List<Fragebogen> fList = new ArrayList<>();
    fList.add(gb);

    i.setFrageboegen(fList);
    gb.setItems(Arrays.asList(new Item[] {i}));

    Frage_Fragebogen ff = new Frage_Fragebogen();
    gb.setFrageFragebogen(Arrays.asList(new Frage_Fragebogen[] {ff}));

    model.deleteFragebogen(gb);
  }
  public static DefaultCategoryDataset createDatasetForMultiperspektive(
      List<Fragebogen> fragebogenList) {

    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    ArrayList<Bereich> bereiche =
        EvaluationHelper.getBereicheFromEvaluationHelper(fragebogenList.get(0).getBewertungen());

    for (Fragebogen f : fragebogenList) {
      ObservableList<EvaluationHelper> ehList =
          EvaluationHelper.createEvaluationHelperList(f.getBewertungen(), null);
      for (EvaluationHelper eh : ehList) {
        double avValue[] = new double[bereiche.size()];
        int valCount = 0;
        for (Bereich bereich : bereiche) {
          valCount = 0;
          for (Item item : eh.getItems()) {

            if (bereich.equals(item.getBereich())) {
              if (!eh.getItemWertung().get(valCount).isEmpty()) {
                avValue[bereiche.indexOf(bereich)] +=
                    Double.parseDouble(eh.getItemWertung().get(valCount));
              }
              valCount++;
            }
          }
          if (valCount != 0) {
            avValue[bereiche.indexOf(bereich)] /= valCount;
          } else {

            avValue[bereiche.indexOf(bereich)] = 0;
          }
        }
        for (int j = 0; j < avValue.length; j++) {
          defaultcategorydataset.addValue(
              avValue[j],
              f.getPerspektive().getName() + " : " + eh.getRawId(),
              bereiche.get(j).getName());
        }
      }
    }

    return defaultcategorydataset;
  }
  public static DefaultCategoryDataset createDatasetForStudentBereich(
      EvaluationHelper eh,
      Fragebogen fragebogen,
      ArrayList<Bereich> bereiche,
      double[] avValueBereich) {

    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();

    for (int i = 0; i < bereiche.size(); i++) {
      defaultcategorydataset.addValue(
          avValueBereich[i],
          SeCatResourceBundle.getInstance().getString("scene.chart.all.averagevalues"),
          bereiche.get(i).getName());
    }

    double avValue[] = new double[bereiche.size()];
    int valCount = 0;
    for (Bereich bereich : bereiche) {
      valCount = 0;
      for (Item item : eh.getItems()) {

        if (bereich.equals(item.getBereich())) {
          if (!eh.getItemWertung().get(valCount).isEmpty()) {
            avValue[bereiche.indexOf(bereich)] +=
                Double.parseDouble(eh.getItemWertung().get(valCount));
          }
          valCount++;
        }
      }
      if (valCount != 0) {
        avValue[bereiche.indexOf(bereich)] /= valCount;
      }
    }
    for (int j = 0; j < avValue.length; j++) {
      defaultcategorydataset.addValue(avValue[j], eh.getRawId(), bereiche.get(j).getName());
    }

    return defaultcategorydataset;
  }
  public static DefaultBoxAndWhiskerCategoryDataset getDatasetForBoxAndWhiskers(
      ObservableList<EvaluationHelper> allEvaluationHelper, ArrayList<Bereich> bereiche) {

    int categoryCount = bereiche.size();
    int entityCount = allEvaluationHelper.size();

    final DefaultBoxAndWhiskerCategoryDataset dataset = new DefaultBoxAndWhiskerCategoryDataset();

    for (int j = 0; j < categoryCount; j++) {
      final List<Double> list = new ArrayList<Double>();
      for (int k = 0; k < entityCount; k++) {

        int valCount = 0;
        double avValue = 0;

        for (Item item : allEvaluationHelper.get(k).getItems()) {
          if (bereiche.get(j).equals(item.getBereich())) {
            if (!allEvaluationHelper.get(k).getItemWertung().get(valCount).isEmpty()) {
              avValue +=
                  Double.parseDouble(allEvaluationHelper.get(k).getItemWertung().get(valCount));
            }
            valCount++;
          }
        }
        if (valCount != 0) {
          avValue /= valCount;
        }

        list.add(new Double(avValue));
      }
      dataset.add(
          list,
          SeCatResourceBundle.getInstance().getString("scene.chart.all.averagevalues"),
          bereiche.get(j).getName());
    }
    return dataset;
  }
  public static DefaultCategoryDataset createDatasetForEvaluationItemCompare(
      List<Fragebogen> fragebogenList) {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    ObservableList<EvaluationHelper> ehListinit =
        EvaluationHelper.createEvaluationHelperList(fragebogenList.get(0).getBewertungen(), null);
    List<Item> items = ehListinit.get(0).getItems();

    for (Fragebogen f : fragebogenList) {
      ObservableList<EvaluationHelper> ehList =
          EvaluationHelper.createEvaluationHelperList(f.getBewertungen(), null);

      for (Item item : items) {
        double ret = 0;
        int i = 0;
        if (ehList.get(0).getItems().contains(item)) {
          for (EvaluationHelper eh : ehList) {

            String s = eh.getItemWertung().get(eh.getItems().indexOf(item));
            if (s.isEmpty()) {
              ret += 0;
            } else {
              ret += Double.parseDouble(eh.getItemWertung().get(eh.getItems().indexOf(item)));
              i++;
            }
          }
        }
        if (i > 0) {
          ret /= i;
        }

        defaultcategorydataset.addValue(ret, f.getPerspektive().getName(), item.getName());
      }
    }

    return defaultcategorydataset;
  }
  @BeforeClass
  public static void setup() throws Exception {
    fragebogenDAO = Mockito.mock(FragebogenDAO.class);
    frageDAO = Mockito.mock(FrageDAO.class);
    bewertungsDAO = Mockito.mock(BewertungDAO.class);
    itemDAO = Mockito.mock(ItemDAO.class);
    einstellungDAO = Mockito.mock(EinstellungDAO.class);
    frageFragebogenDAO = Mockito.mock(Frage_FragebogenDAO.class);

    fragebogen1 = new Fragebogen();

    Eigenschaft e = new Eigenschaft();
    e.setId(1);
    e.setName("testEigenschaft");

    Perspektive p = new Perspektive();
    p.setId(1);
    p.setName("testPerspektive");

    Fach f = new Fach();
    f.setId(1);
    f.setName("test>Fach");

    l = new Lehrveranstaltung();

    l.setId(1);
    l.setDozent("testDozent");
    l.setJahr(new Date());
    f.addLehrveranstaltung(l);
    f.addLehrveranstaltung(l);
    l.setSemester(SemesterType.SS);

    fragebogen1.setEigenschaft(e);
    fragebogen1.setPerspektive(p);
    fragebogen1.setLehrveranstaltung(l);

    Handlungsfeld h = new Handlungsfeld();
    h.setId(1);
    h.setName("testName");
    h.setNotiz("testNotiz");

    Bereich b = new Bereich();
    b.setId(1);
    b.setName("testBereich");

    h.addBereich(b);

    Item i1 = new Item();
    i1.setId(1);
    i1.setName("testItem1");
    i1.setNotiz("testNotiz1");
    b.addItem(i1);
    i1.addEigenschaft(e);
    i1.addPerspektive(p);
    i1.addFragebogen(fragebogen1);
    i1.setFrage("item1Frage");

    Item i2 = new Item();
    i2.setId(2);
    i2.setName("testItem1");
    i2.setNotiz("testNotiz1");
    b.addItem(i2);
    i2.addEigenschaft(e);
    i2.addPerspektive(p);
    i2.addFragebogen(fragebogen1);
    i2.setFrage("item2Frage");

    sDiscrete = new Skala();

    sDiscrete.setId(1);
    sDiscrete.setType(SkalaType.DISCRET);
    sDiscrete.setMaxText("testMax");
    sDiscrete.setMinText("testMin");
    sDiscrete.setOptimum(4);
    sDiscrete.setSchritte(4);
    sDiscrete.setSchrittWeite(1);

    fragebogen1.setSkala(sDiscrete);

    sFree = new Skala();

    sFree.setId(2);
    sFree.setType(SkalaType.FREE);
    sFree.setZeilen(4);

    sMQ = new Skala();

    sMQ.setId(3);
    sMQ.setType(SkalaType.MC);
    sMQ.setSchrittWeite(1);
    sMQ.setAndereAntwort("tetDefaultAnswer");
    sMQ.setVerweigerungsAntwort("testVerweigerungsAntwort");
    sMQ.setAuswahl(Arrays.asList(new String[] {"test1", "test2"}));

    f1 = new Frage();
    f1.setId(1);
    f1.setName("frage1");
    f1.setSkala(sFree);
    f1.setText("Was?");

    Frage f2 = new Frage();
    f2.setId(2);
    f2.setName("frage2");
    f2.setSkala(sMQ);
    f2.setText("Wo?");

    Frage_Fragebogen ff1 = new Frage_Fragebogen();
    ff1.setFrage(f1);
    ff1.setId(1);
    ff1.setPosition(FragePosition.BOTTOM);
    ff1.setFragebogen(fragebogen1);

    Frage_Fragebogen ff2 = new Frage_Fragebogen();
    ff2.setFrage(f2);
    ff2.setId(2);
    ff2.setPosition(FragePosition.TOP);
    ff2.setFragebogen(fragebogen1);
    fragebogen1.setId(1);

    fragebogen1.setFrageFragebogen(Arrays.asList(new Frage_Fragebogen[] {ff1, ff2}));

    Bewertung b1 = new Bewertung();
    b1.setId(1);
    b1.setFrage(f1);
    b1.setQuelle("quelle");
    b1.setWert("1");
    b1.setZeilenid("test");
    b1.setZeit("2014");
    b1.setFragebogen(fragebogen1);

    f1.setBewertungen(Arrays.asList(new Bewertung[] {b1}));

    Bewertung b2 = new Bewertung();
    b2.setId(2);
    b2.setFrage(f2);
    b2.setQuelle("quelle");
    b2.setWert("2");
    b2.setZeilenid("test");
    b2.setZeit("2014");
    b2.setFragebogen(fragebogen1);

    f2.setBewertungen(Arrays.asList(new Bewertung[] {b2}));

    Bewertung b3 = new Bewertung();
    b3.setId(3);
    b3.setItem(i1);
    b3.setQuelle("quelle");
    b3.setWert("3");
    b3.setZeilenid("test");
    b3.setZeit("2014");
    b3.setFragebogen(fragebogen1);

    i1.setBewertungen(Arrays.asList(new Bewertung[] {b3}));

    Bewertung b4 = new Bewertung();
    b4.setId(4);
    b4.setItem(i2);
    b4.setQuelle("quelle");
    b4.setWert("3");
    b4.setZeilenid("test");
    b4.setZeit("2014");
    b4.setFragebogen(fragebogen1);

    i2.setBewertungen(Arrays.asList(new Bewertung[] {b4}));

    Einstellung ei = new Einstellung();
    ei.setId(1);
    ei.setName(EinstellungenType.STANDORT);
    ei.setWert("HSC");

    Mockito.when(einstellungDAO.findByName(EinstellungenType.STANDORT)).thenReturn(ei);

    fragebogen1.setBewertungen(Arrays.asList(new Bewertung[] {b1, b2, b3, b4}));

    fragebogen1.setErstellungsDatum(new Date());

    List<Item> items = new ArrayList<Item>();
    items.add(i2);
    items.add(i1);

    fragebogen1.setItems(items);
    fragebogen1.setName("testFragebogen");

    Mockito.when(fragebogenDAO.findById(fragebogen1.getId())).thenReturn(fragebogen1);

    setValueToField(fragebogenDAO, "fragebogenDAO", model);
    setValueToField(frageDAO, "frageDAO", model);
    setValueToField(bewertungsDAO, "bewertungsDAO", model);
    setValueToField(itemDAO, "itemDAO", model);
    setValueToField(einstellungDAO, "einstellungDAO", model);
    setValueToField(frageFragebogenDAO, "frageFragebogenDAO", model);
  }