EDIT

import java.util.Iterator;

import eu.etaxonomy.cdm.api.service.UpdateResult;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.StateData;

        List<RowWrapperDTO<?>> result =  datasetService.getRowWrapper(dataSet.getUuid(), monitor);

        assertTrue(result.size() == 5);

        for (RowWrapperDTO<?> row: result){

            if (row instanceof SpecimenRowWrapperDTO){

                SpecimenRowWrapperDTO specimen = (SpecimenRowWrapperDTO)row;

                if (specimen.getSpecimenDto().getLabel().equals("alpina specimen1")){

                    Set<DescriptionElementDto> elements = specimen.getDataValueForFeature(uuidFeatureLeafColor);

                    if (elements != null && !elements.isEmpty() ){

                        Iterator<DescriptionElementDto> it = elements.iterator();

                        DescriptionElementDto dto = null;

                        if (it.hasNext()){

                            dto = it.next();

                        }else{

                            Assert.fail("There is no element for feature leaf color, but should.");

                        }

                        if (dto instanceof CategoricalDataDto){

                            assertTrue("The states should contain one element", ((CategoricalDataDto)dto).getStates().size() == 1);

                            StateDataDto stateData = ((CategoricalDataDto)dto).getStates().iterator().next();

                            assertEquals(uuidLeafColorBlue, stateData.getState().getUuid());

                        }else{

                            Assert.fail("The element is not of type categorical data");

                        }

                    }else{

                        Assert.fail();

                    }

                    elements = specimen.getDataValueForFeature(uuidFeatureLeafLength);

                    if (elements != null && !elements.isEmpty() ){

                        Iterator<DescriptionElementDto> it = elements.iterator();

                        DescriptionElementDto dto = null;

                        if (it.hasNext()){

                            dto = it.next();

                        }else{

                            Assert.fail("There is no element for feature leaf length, but should.");

                        }

                        if (dto instanceof QuantitativeDataDto){

                            assertTrue("The statistical values should contain one element", ((QuantitativeDataDto)dto).getValues().size() == 1);

                            StatisticalMeasurementValueDto statValue = ((QuantitativeDataDto)dto).getValues().iterator().next();

                            assertEquals(new BigDecimal("5.0"), statValue.getValue());

                        }else{

                            Assert.fail("The element is not of type quantitative data");

                        }

                    }else{

                        Assert.fail();

                    }

                    elements = specimen.getDataValueForFeature(uuidFeatureLeafPA);

//                    assertTrue("The element should be categorical data ", element instanceof CategoricalDataDto);

//                    assertTrue("The statistical values should contain one element", ((CategoricalDataDto)element).getStates().size() == 1);

//                    StateDataDto stateData2 = ((CategoricalDataDto)element).getStates().iterator().next();

//                    assertEquals(State.uuidPresent, stateData2.getState().getUuid());

                }

            }

//            if (row instanceof TaxonRowWrapperDTO){

//                TaxonRowWrapperDTO taxonRow = (TaxonRowWrapperDTO)row;

//                Set<DescriptionElementDto> element = taxonRow.getDataValueForFeature(uuidFeatureLeafLength);

//                assertTrue(element instanceof QuantitativeDataDto);

//                assertTrue(((QuantitativeDataDto)element).getValues().size() == 2);

//            }

        }

        commitAndStartNewTransaction();

    @Ignore

    @Test

    @DataSets({

        @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/ClearDB_with_Terms_DataSet.xml"),

        @DataSet(value="/eu/etaxonomy/cdm/database/TermsDataSet-with_auditing_info.xml"),

        @DataSet(value="StructuredDescriptionAggregationTest.xml"),

    })

    @Ignore

    public void incompleteCategoricalDataTest(){

        createDefaultFeatureTree();

        DescriptiveDataSet dataSet = DescriptiveDataSet.NewInstance();

        datasetService.save(dataSet);

        SpecimenDescription specDescAlpina1 = createSpecimenDescription(dataSet, T_LAPSANA_COMMUNIS_ALPINA_UUID, "alpina specimen1");

        addCategoricalData(specDescAlpina1, uuidFeatureLeafColor, null);

        TaxonNode tnLapsana = taxonNodeService.find(TN_LAPSANA_UUID);

        Assert.assertNotNull(tnLapsana);

        dataSet.addTaxonSubtree(tnLapsana);

        @SuppressWarnings("unchecked")

        TermTree<Feature> descriptiveSystem = termTreeService.find(uuidFeatureTree);

        dataSet.setDescriptiveSystem(descriptiveSystem);

        commitAndStartNewTransaction();

        Taxon taxLapsanaCommunisAlpina = (Taxon)taxonService.find(T_LAPSANA_COMMUNIS_ALPINA_UUID);

        TaxonDescription aggrDescLapsanaCommunisAlpina = testTaxonDescriptions(taxLapsanaCommunisAlpina, 1);

        List<StateData> sdAlpinaLeafColor = testCategoricalData(uuidFeatureLeafColor, 1, aggrDescLapsanaCommunisAlpina, false);

        testState(sdAlpinaLeafColor, uuidLeafColorBlue, 0);

        testState(sdAlpinaLeafColor, uuidLeafColorYellow, 0);

    }

    private void testStatusOk(UpdateResult result) {

        if (result.getStatus() != UpdateResult.Status.OK){

            Assert.fail("Aggregation should have status OK but was " + result.toString());

            for (Exception ex : result.getExceptions()){

                ex.printStackTrace();

            }

        }

    }

    private TaxonDescription testTaxonDescriptions(Taxon taxon, int elementSize){

        List<TaxonDescription> taxonDescriptions = taxon.getDescriptions().stream()

                .filter(desc->desc.getTypes().contains(DescriptionType.AGGREGATED_STRUC_DESC))

                .collect(Collectors.toList());

        Assert.assertEquals(1, taxonDescriptions.size());

        TaxonDescription aggrDesc = taxonDescriptions.iterator().next();

        Set<DescriptionElementBase> elements = aggrDesc.getElements();

        Assert.assertEquals(elementSize, elements.size());

        return aggrDesc;

    }

    private void testQuantitativeData(UUID featureUuid, BigDecimal sampleSize, BigDecimal min,

            BigDecimal max, BigDecimal avg, TaxonDescription aggrDesc) {

        List<QuantitativeData> quantitativeDatas = aggrDesc.getElements().stream()

                .filter(element->element.getFeature().getUuid().equals(featureUuid))

                .map(catData->CdmBase.deproxy(catData, QuantitativeData.class))

                .collect(Collectors.toList());

        Assert.assertEquals(1, quantitativeDatas.size());

        QuantitativeData leafLength = quantitativeDatas.iterator().next();

        Assert.assertEquals(sampleSize, leafLength.getSampleSize());

        Assert.assertEquals(min, leafLength.getMin());

        Assert.assertEquals(max, leafLength.getMax());

        Assert.assertEquals(avg, leafLength.getAverage());

    }

    private List<StateData> testCategoricalData(UUID featureUuid, int stateDataCount, TaxonDescription taxonDescription, boolean withAddedData) {

        List<CategoricalData> categoricalDatas = taxonDescription.getElements().stream()

                .filter(element->element.getFeature().getUuid().equals(featureUuid))

                .map(catData->CdmBase.deproxy(catData, CategoricalData.class))

                .collect(Collectors.toList());

        int nCD = withAddedData ? 2 : 1;

        Assert.assertEquals(nCD, categoricalDatas.size());

        CategoricalData categoricalData;

        if (withAddedData){

            categoricalData = categoricalDatas.stream().filter(cd->cd.getStateData().get(0).getCount() != null ).findFirst().get();

        }else{

            categoricalData = categoricalDatas.iterator().next(); // categoricalDatas.stream().filter(cd->cd.getStateData().size() != 1).collect(Collectors.toList());

        }

        List<StateData> stateDatas = categoricalData.getStateData();

        Assert.assertEquals(stateDataCount, stateDatas.size());

        return stateDatas;

    }

    private void testState(List<StateData> stateDatas, UUID stateUuid, Integer stateDataCount){

        List<StateData> filteredStateDatas = stateDatas.stream()

                .filter(stateData->stateData.getState()!=null && stateData.getState().getUuid().equals(stateUuid))

                .collect(Collectors.toList());

        if(stateDataCount==0){

            // non-existence test

            Assert.assertEquals(0, filteredStateDatas.size());

            return;

        }

        Assert.assertEquals(1, filteredStateDatas.size());

        StateData stateData = filteredStateDatas.iterator().next();

        Assert.assertEquals(stateDataCount, stateData.getCount());

        Assert.assertEquals(stateUuid, stateData.getState().getUuid());

    }