@Test
  public void testCreateSchema() throws Exception {
    File dir = File.createTempFile("foo", "shp", new File("target"));
    dir.delete();
    dir.mkdir();

    DataStore ds = new DirectoryDataStore(dir, getFileStoreFactory());
    assertEquals(0, ds.getTypeNames().length);

    SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
    tb.setName("foo");
    tb.add("geom", Polygon.class);
    tb.add("bar", Integer.class);
    ds.createSchema(tb.buildFeatureType());

    SimpleFeatureType ft = ds.getSchema("foo");
    assertNotNull(ft);

    // clean up
    ds.dispose();
    for (File f : dir.listFiles()) {
      f.delete();
    }
    dir.delete();
  }
Example #2
0
 protected DataStore createSourceDataStore(FileSystemEvent fileEvent)
     throws IOException, ActionException {
   updateTask("Connecting to source DataStore");
   String fileType = getFileType(fileEvent);
   FeatureConfiguration sourceFeature = configuration.getSourceFeature();
   if (fileType.equals("xml")) {
     InputStream inputXML = null;
     try {
       inputXML = new FileInputStream(fileEvent.getSource());
       sourceFeature = FeatureConfiguration.fromXML(inputXML);
     } catch (Exception e) {
       throw new IOException("Unable to load input XML", e);
     } finally {
       IOUtils.closeQuietly(inputXML);
     }
   } else if (fileType.equals("shp")) {
     sourceFeature.getDataStore().put("url", DataUtilities.fileToURL(fileEvent.getSource()));
   }
   DataStore source = createDataStore(sourceFeature.getDataStore());
   // if no typeName is configured, takes the first one registered in store
   if (sourceFeature.getTypeName() == null) {
     sourceFeature.setTypeName(source.getTypeNames()[0]);
   }
   // if no CRS is configured, takes if from the feature
   if (sourceFeature.getCrs() == null) {
     sourceFeature.setCoordinateReferenceSystem(
         source.getSchema(sourceFeature.getTypeName()).getCoordinateReferenceSystem());
   }
   configuration.setSourceFeature(sourceFeature);
   return source;
 }
Example #3
0
  public static void main(String[] args) {
    System.out.println("WFS Demo");
    try {
      //            URL url = new
      // URL("http://www2.dmsolutions.ca/cgi-bin/mswfs_gmap?version=1.0.0&request=getcapabilities&service=wfs");
      URL url = new URL("http://www.refractions.net:8080/geoserver/wfs?REQUEST=GetCapabilities");

      Map m = new HashMap();
      m.put(WFSDataStoreFactory.URL.key, url);
      m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(10000));
      m.put(WFSDataStoreFactory.PROTOCOL.key, Boolean.FALSE);

      DataStore wfs = (new WFSDataStoreFactory()).createNewDataStore(m);
      Query query = new DefaultQuery(wfs.getTypeNames()[1]);
      FeatureReader<SimpleFeatureType, SimpleFeature> ft =
          wfs.getFeatureReader(query, Transaction.AUTO_COMMIT);
      int count = 0;
      while (ft.hasNext()) if (ft.next() != null) count++;
      System.out.println("Found " + count + " features");
    } catch (IOException e) {
      e.printStackTrace();
    } catch (NoSuchElementException e) {
      e.printStackTrace();
    } catch (IllegalAttributeException e) {
      e.printStackTrace();
    }
  }
 @Override
 public String getTypeName(URL url) throws IOException {
   DataStore ds = createDataStore(url);
   String[] names = ds.getTypeNames();
   assert names.length == 1 : "Invalid number of type names for csv file store";
   ds.dispose();
   return names[0];
 }
 @SuppressWarnings("unchecked")
 private SimpleFeatureSource getFeatureSource(final URL shpfile) throws IOException {
   Map params = new HashMap<String, String>();
   params.put(ShapefileDataStoreFactory.CREATE_SPATIAL_INDEX.key, "false");
   params.put(ShapefileDataStoreFactory.URLP.key, shpfile);
   DataStore ds = DataStoreFinder.getDataStore(params);
   return ds.getFeatureSource(ds.getTypeNames()[0]);
 }
  @Test
  public void testSchema() throws Exception {
    File file = copyShapefiles("shapes/archsites.shp");
    tempDir = file.getParentFile();

    DataStore dds = new DirectoryDataStore(tempDir, getFileStoreFactory());

    assertEquals(1, dds.getTypeNames().length);
    assertEquals("archsites", dds.getTypeNames()[0]);
    dds.dispose();
  }
  @Test
  public void testDataStoreFinderFindsIt() throws IOException {
    DataStore sdeDs = null;

    DataStoreFinder.scanForPlugins();
    sdeDs = DataStoreFinder.getDataStore(testData.getConProps());
    assertNotNull(sdeDs);
    String failMsg = sdeDs + " is not an ArcSDEDataStore";
    assertTrue(failMsg, (sdeDs instanceof ArcSDEDataStore));
    LOGGER.fine("testFinder OK :" + sdeDs.getClass().getName());
  }
 private SimpleFeatureSource getLatLonFeatureSource() {
   try {
     DataStore ds = LATLON == null ? null : LATLON.get();
     if (ds == null) {
       ds = createLatLonDataStore();
       LATLON = new WeakReference<DataStore>(ds);
     }
     return ds.getFeatureSource("latlon");
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
  @Test
  public void testTypeNames() throws Exception {
    copyShapefiles("shapes/archsites.shp");
    File f = copyShapefiles("shapes/bugsites.shp");
    tempDir = f.getParentFile();

    DataStore store = new DirectoryDataStore(tempDir, getFileStoreFactory());
    List<String> typeNames = Arrays.asList(store.getTypeNames());
    assertEquals(2, typeNames.size());
    assertTrue(typeNames.contains("archsites"));
    assertTrue(typeNames.contains("bugsites"));
    store.dispose();
  }
  @Test
  @Ignore
  // this test is skipped, it checks something that formally is what we should expect,
  // but for the moment this breaks big time the shapefile renderer optimizations
  // until we get rid of the latter let's be a little lax on this one...
  public void testFeatureSource() throws Exception {
    File file = copyShapefiles("shapes/archsites.shp");
    tempDir = file.getParentFile();

    DataStore dds = new DirectoryDataStore(tempDir, getFileStoreFactory());
    FeatureSource fs = dds.getFeatureSource("archsites");
    assertNotNull(fs);
    assertSame(dds, fs.getDataStore());
    dds.dispose();
  }
 public void testNamespace() throws Exception {
   OGRDataStoreFactory factory = new OGRDataStoreFactory();
   Map map = new HashMap();
   URI namespace = new URI("http://jesse.com");
   map.put(OGRDataStoreFactory.NAMESPACEP.key, namespace);
   map.put(OGRDataStoreFactory.OGR_NAME.key, getAbsolutePath(STATE_POP));
   DataStore store = factory.createDataStore(map);
   assertEquals(
       namespace.toString(),
       store
           .getSchema(
               STATE_POP.substring(STATE_POP.lastIndexOf('/') + 1, STATE_POP.lastIndexOf('.')))
           .getName()
           .getNamespaceURI());
 }
  public void update(Object updatedObject) {
    if (updatedObject instanceof List) {
      String text = null;
      List layers = (List) updatedObject;
      for (Object layer : layers) {
        if (layer instanceof JGrassMapGeoResource) {
          JGrassMapGeoResource rasterMapResource = (JGrassMapGeoResource) layer;
          try {
            text = rasterMapResource.getInfo(null).getName();

            JGrassRegion fileWindow = rasterMapResource.getFileWindow();
            if (fileWindow != null) {
              setWidgetsToWindow(fileWindow);
            }
          } catch (IOException e1) {
            return;
          }
        } else if (layer instanceof DataStore || layer instanceof UDIGFeatureStore) {
          try {
            DataStore store = ((DataStore) layer);
            FeatureSource featureStore = store.getFeatureSource(store.getTypeNames()[0]);
            Envelope envelope = featureStore.getBounds();

            ActiveRegionStyle style = getActiveRegionStyle();
            JGrassRegion activeWindow =
                new JGrassRegion(
                    style.west, style.east, style.south, style.north, style.rows, style.cols);
            JGrassRegion newWindow =
                JGrassRegion.adaptActiveRegionToEnvelope(envelope, activeWindow);
            northText.setText(String.valueOf(newWindow.getNorth()));
            southText.setText(String.valueOf(newWindow.getSouth()));
            eastText.setText(String.valueOf(newWindow.getEast()));
            westText.setText(String.valueOf(newWindow.getWest()));
            textModified(bound_type);
          } catch (IOException e1) {
            e1.printStackTrace();
            return;
          }

        } else {
          return;
        }
      }
      if (text == null) {
        return;
      }
    }
  }
Example #13
0
  @Test
  public void testFeatureReaderWithFilterBBoxPOST()
      throws NoSuchElementException, IllegalAttributeException, IOException, SAXException,
          IllegalFilterException {
    if (url == null) return;

    Map m = new HashMap();
    m.put(WFSDataStoreFactory.URL.key, url);
    m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(100000));
    DataStore post = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m);

    String typeName = post.getTypeNames()[0];
    Envelope bbox = post.getFeatureSource(typeName).getBounds();

    WFSDataStoreReadTest.doFeatureReaderWithBBox(url, true, false, 0, bbox);
  }
Example #14
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  private FeatureSource getFeatureSource(String typeName) {

    FeatureSource featureSource;
    try {
      featureSource = dataStore.getFeatureSource(typeName);
    } catch (Exception e) {
      throw new GeoToolsOpException(StatusCode.UNABLE_TO_GET_FEATURES);
    }

    return new ForwardingFeatureSource(featureSource) {

      @Override
      public FeatureCollection getFeatures(Query query) throws IOException {

        final FeatureCollection features = super.getFeatures(query);
        return new ForwardingFeatureCollection(features) {

          @Override
          public FeatureIterator features() {

            final FeatureType featureType = getSchema();
            final String fidPrefix = featureType.getName().getLocalPart() + ".";

            FeatureIterator iterator = delegate.features();
            return new FidPrefixRemovingIterator(iterator, fidPrefix);
          }
        };
      }
    };
  }
Example #15
0
  private void save() throws Exception {
    FeatureStore fs = (FeatureStore) ds.getFeatureSource("poly_county");
    FeatureType ft = fs.getSchema();

    MemoryDataStore memorystore = new MemoryDataStore();

    ArrayList polys = new ArrayList(resultPolygon);

    Geometry gfinal = null;
    if (polys.size() == 1) {
      gfinal = (Polygon) polys.get(0); // POLYGON
    } else {
      GeometryFactory gf = ((Polygon) polys.get(0)).getFactory();
      gfinal = new MultiPolygon((Polygon[]) polys.toArray(new Polygon[polys.size()]), gf);
    }

    gfinal = gfinal.buffer(0); // for topologic problems.

    Object[] values = new Object[5];
    values[ft.find("module")] = MODULE;
    values[ft.find("gen_full")] = gfinal;

    values[ft.find("gen_1")] = generalize(gfinal, tolerance1);
    ;
    values[ft.find("gen_2")] = generalize(gfinal, tolerance1);
    ;
    values[ft.find("gen_3")] = generalize(gfinal, tolerance1);
    ;

    Feature f = ft.create(values);
    memorystore.addFeature(f);

    fs.addFeatures(memorystore.getFeatureReader("poly_county"));
  }
  @Test
  public void testModifyIssue() throws Exception {
    String newDescription = "new modified description"; // $NON-NLS-1$

    list.clear();
    list.add(IssuesListTestHelper.createFeatureIssue("test")); // $NON-NLS-1$

    list.refresh();
    assertEquals(1, list.size());

    IIssue issue = list.get(0);
    issue.setDescription(newDescription);
    ((IRemoteIssuesList) list).save(issue);
    FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints());

    Expression expr2 = factory.literal(issue.getId());
    Expression expr1 = factory.property(IssuesListTestHelper.ISSUE_ID_ATTR);
    Filter filter = factory.equals(expr1, expr2);

    SimpleFeature next =
        store
            .getFeatureSource(featureType.getName().getLocalPart())
            .getFeatures(filter)
            .features()
            .next();
    assertEquals(newDescription, next.getAttribute(IssuesListTestHelper.DESCRIPTION_ATTR));
  }
Example #17
0
 /**
  * Creates the source datastore reader.
  *
  * @param sourceDataStore
  * @param transaction
  * @param query
  * @return
  * @throws IOException
  */
 protected FeatureStore<SimpleFeatureType, SimpleFeature> createSourceReader(
     DataStore sourceDataStore, final Transaction transaction, Query query) throws IOException {
   FeatureStore<SimpleFeatureType, SimpleFeature> featureReader =
       (FeatureStore<SimpleFeatureType, SimpleFeature>)
           sourceDataStore.getFeatureSource(query.getTypeName());
   featureReader.setTransaction(transaction);
   return featureReader;
 }
 @Test
 public void testGet() {
   ServiceInfo info = store.getInfo();
   assertNotNull(info);
   assertNotNull(info.getTitle());
   assertNotNull(info.getDescription());
   assertNotNull(info.getSchema());
 }
  @Override
  protected void setUpInternal(SystemTestData data) throws Exception {
    // run all the tests against a store that can do native paging (h2) and one that
    // can't (property)
    Catalog cat = getCatalog();
    DataStoreInfo ds = cat.getFactory().createDataStore();
    ds.setName("foo");
    ds.setWorkspace(cat.getDefaultWorkspace());

    Map params = ds.getConnectionParameters();
    params.put("dbtype", "h2");
    params.put("database", getTestData().getDataDirectoryRoot().getAbsolutePath());
    cat.add(ds);

    FeatureSource fs1 = getFeatureSource(SystemTestData.FIFTEEN);
    FeatureSource fs2 = getFeatureSource(SystemTestData.SEVEN);

    DataStore store = (DataStore) ds.getDataStore(null);
    SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();

    tb.init((SimpleFeatureType) fs1.getSchema());
    tb.add("num", Integer.class);
    tb.remove("boundedBy");
    store.createSchema(tb.buildFeatureType());

    tb.init((SimpleFeatureType) fs2.getSchema());
    tb.add("num", Integer.class);
    tb.remove("boundedBy");
    store.createSchema(tb.buildFeatureType());

    CatalogBuilder cb = new CatalogBuilder(cat);
    cb.setStore(ds);

    FeatureStore fs = (FeatureStore) store.getFeatureSource("Fifteen");
    addFeatures(fs, fs1.getFeatures());

    FeatureTypeInfo ft = cb.buildFeatureType(fs);
    cat.add(ft);

    fs = (FeatureStore) store.getFeatureSource("Seven");
    addFeatures(fs, fs2.getFeatures());

    ft = cb.buildFeatureType(fs);
    cat.add(ft);
  }
  @Override
  public <T> T resolve(Class<T> adaptee, IProgressMonitor monitor) throws IOException {
    if (null == adaptee) {
      return null;
    }

    if (adaptee.isAssignableFrom(FeatureSource.class)) {
      DataStore ds = this.service.resolve(DataStore.class, monitor);
      String[] a = ds.getTypeNames();
      String featureName = a[0];

      FeatureSource<SimpleFeatureType, SimpleFeature> fs = ds.getFeatureSource(featureName);

      return adaptee.cast(fs);
    }

    return super.resolve(adaptee, monitor);
  }
 @Test
 public void testRemoveInt() throws Exception {
   list.remove(1);
   assertEquals(3, list.size());
   assertEquals("0", list.get(0).getId()); // $NON-NLS-1$
   assertEquals("2", list.get(1).getId()); // $NON-NLS-1$
   assertEquals("3", list.get(2).getId()); // $NON-NLS-1$
   assertEquals(
       3, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL));
 }
 @Test
 public void testInitialLoad() throws Exception {
   assertEquals(4, list.size());
   assertEquals("0", list.get(0).getId()); // $NON-NLS-1$
   assertEquals("1", list.get(1).getId()); // $NON-NLS-1$
   assertEquals("2", list.get(2).getId()); // $NON-NLS-1$
   assertEquals("3", list.get(3).getId()); // $NON-NLS-1$
   assertEquals(
       4, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL));
 }
Example #23
0
 protected void closeResource(DataStore dataStore) {
   if (dataStore != null) {
     try {
       dataStore.dispose();
     } catch (Throwable t) {
       if (LOGGER.isErrorEnabled()) {
         LOGGER.error("Error closing datastore connection");
       }
     }
   }
 }
  /**
   * test that a ArcSDEDataStore that connects to de configured test database contains the tables
   * defined by the parameters "point_table", "line_table" and "polygon_table", wether ot not
   * they're defined as single table names or as full qualified sde table names (i.e.
   * SDE.SDE.TEST_POINT)
   *
   * @throws IOException
   * @throws SeException
   */
  @Test
  public void testGetTypeNames() throws IOException, SeException {
    String[] featureTypes = store.getTypeNames();
    assertNotNull(featureTypes);

    // if (LOGGER.isLoggable(Level.FINE)) {
    // for (int i = 0; i < featureTypes.length; i++)
    // System.out.println(featureTypes[i]);
    // }
    testTypeExists(featureTypes, testData.getTempTableName());
  }
 @Override
 public void dispose(IProgressMonitor monitor) {
   super.dispose(monitor); // clean up members
   if (dataStore != null) {
     dataStore.dispose();
     dataStore = null;
   }
   if (resources != null) {
     resources = null;
   }
 }
 /**
  * Test that a filter query issued.
  *
  * @param filter filter to be passed in the query to determine the subset of features to be
  *     returned, or null for all features
  * @param expectedFeatureIds integer id for returned features, matching the expected row ids
  * @throws Exception
  */
 private void runFilterTest(Filter filter, int[] expectedFeatureIds) throws Exception {
   DataStore datastore = null;
   try {
     datastore = DataStoreFinder.getDataStore(getParams());
     assertNotNull(datastore);
     Query query = new DefaultQuery(TEST_TABLE_NAME, filter);
     FeatureReader<SimpleFeatureType, SimpleFeature> reader = null;
     try {
       /*
        * List of all the integer feature ids seen in the features returned for this query.
        */
       List<Integer> featureIds = new ArrayList<Integer>();
       reader = datastore.getFeatureReader(query, Transaction.AUTO_COMMIT);
       for (SimpleFeature feature = null; reader.hasNext(); ) {
         feature = reader.next();
         /*
          * Convert long feature id of the form test_table_name.1234 to the numeric id
          * used when creating the row. This relies on the behaviour of the postgis fid
          * mapper.
          */
         Integer id = Integer.valueOf(feature.getID().replace(TEST_TABLE_NAME + ".", ""));
         featureIds.add(id);
       }
       /*
        * The query succeeded as expected if and only if the sorted lists of returned and
        * expected ids are equal. The expected ids are converted to a List of Integers to
        * leverage Collections comparison.
        */
       assertEquals(sortedList(expectedFeatureIds), sorted(featureIds));
     } finally {
       if (reader != null) {
         reader.close();
       }
     }
   } finally {
     if (datastore != null) {
       datastore.dispose();
     }
   }
 }
  /**
   * This test is made with mock objects because the property data store does not generate fids in
   * the <type>.<id> form
   */
  @SuppressWarnings("unchecked")
  @Test
  public void testAppend() throws Exception {
    SimpleFeatureType type =
        DataUtilities.createType("trees", "the_geom:Point,FID:String,NAME:String");

    SimpleFeatureStore fs = createMock(SimpleFeatureStore.class);
    expect(fs.addFeatures(isA(FeatureCollection.class)))
        .andReturn(Collections.singletonList((FeatureId) (new FeatureIdImpl("trees.105"))));
    replay(fs);

    DataStore ds = createMock(DataStore.class);
    expect(ds.getTypeNames()).andReturn(new String[] {"trees"}).anyTimes();
    expect(ds.getSchema("trees")).andReturn(type).anyTimes();
    expect(ds.getFeatureSource("trees")).andReturn(fs);
    replay(ds);

    RetypingDataStore rts =
        new RetypingDataStore(ds) {
          @Override
          protected String transformFeatureTypeName(String originalName) {
            return "oaks";
          }
        };

    SimpleFeatureBuilder sfb = new SimpleFeatureBuilder(type);
    WKTReader reader = new WKTReader();
    sfb.set("the_geom", reader.read("POINT (0.002 0.0008)"));
    sfb.set("FID", "023");
    sfb.set("NAME", "Old oak");
    SimpleFeature feature = sfb.buildFeature(null);
    SimpleFeatureCollection fc = DataUtilities.collection(feature);

    SimpleFeatureStore store = (SimpleFeatureStore) rts.getFeatureSource("oaks");
    List<FeatureId> ids = store.addFeatures(fc);
    assertEquals(1, ids.size());
    String id = ((FeatureId) ids.iterator().next()).getID();
    assertTrue("Id does not start with " + "oaks" + " it's " + id, id.startsWith("oaks"));
  }
Example #28
0
  private String[] checkPreconditions() {
    if (dataStore == null) {
      throw new GeoToolsOpException(StatusCode.DATASTORE_NOT_DEFINED);
    }

    if ((table == null || table.isEmpty()) && !(all)) {
      throw new GeoToolsOpException(StatusCode.TABLE_NOT_DEFINED);
    }

    if (table != null && !table.isEmpty() && all) {
      throw new GeoToolsOpException(StatusCode.ALL_AND_TABLE_DEFINED);
    }
    String[] typeNames;
    if (all) {
      try {
        typeNames = dataStore.getTypeNames();
      } catch (Exception e) {
        throw new GeoToolsOpException(StatusCode.UNABLE_TO_GET_NAMES);
      }
      if (typeNames.length == 0) {
        throw new GeoToolsOpException(StatusCode.NO_FEATURES_FOUND);
      }
    } else {
      SimpleFeatureType schema;
      try {
        schema = dataStore.getSchema(table);
      } catch (IOException e) {
        throw new GeoToolsOpException(StatusCode.TABLE_NOT_FOUND);
      }
      Preconditions.checkNotNull(schema);
      typeNames = new String[] {table};
    }

    if (typeNames.length > 1 && alter && all) {
      throw new GeoToolsOpException(StatusCode.ALTER_AND_ALL_DEFINED);
    }
    return typeNames;
  }
Example #29
0
  /**
   * Executes the describe command using the provided options.
   *
   * @param cli
   * @see
   *     org.geogit.geotools.cli.porcelain.AbstractOracleCommand#runInternal(org.geogit.cli.GeogitCLI)
   */
  @Override
  protected void runInternal(GeogitCLI cli) throws IOException {
    DataStore dataStore = getDataStore();

    try {
      cli.getConsole().println("Fetching table...");

      Optional<Map<String, String>> propertyMap =
          cli.getGeogit().command(DescribeOp.class).setTable(table).setDataStore(dataStore).call();

      if (propertyMap.isPresent()) {
        cli.getConsole().println("Table : " + table);
        cli.getConsole().println("----------------------------------------");
        for (Entry<String, String> entry : propertyMap.get().entrySet()) {
          cli.getConsole().println("\tProperty  : " + entry.getKey());
          cli.getConsole().println("\tType      : " + entry.getValue());
          cli.getConsole().println("----------------------------------------");
        }
      } else {
        throw new CommandFailedException("Could not find the specified table.");
      }
    } catch (GeoToolsOpException e) {
      switch (e.statusCode) {
        case TABLE_NOT_DEFINED:
          throw new CommandFailedException("No table supplied.", e);
        case UNABLE_TO_GET_FEATURES:
          throw new CommandFailedException("Unable to read the feature source.", e);
        case UNABLE_TO_GET_NAMES:
          throw new CommandFailedException("Unable to read feature types.", e);
        default:
          throw new CommandFailedException("Exception: " + e.statusCode.name(), e);
      }

    } finally {
      dataStore.dispose();
      cli.getConsole().flush();
    }
  }
 @Test
 public void testAddIIssue() throws Exception {
   FeatureIssue issue = IssuesListTestHelper.createFeatureIssue("new"); // $NON-NLS-1$
   list.add(issue);
   assertEquals(5, list.size());
   assertEquals("new", list.get(4).getId()); // $NON-NLS-1$
   list.refresh();
   assertEquals(5, list.size());
   assertEquals("new", list.get(4).getId()); // $NON-NLS-1$
   assertEquals("groupID", list.get(4).getGroupId()); // $NON-NLS-1$
   assertEquals("test description", list.get(4).getDescription()); // $NON-NLS-1$
   assertEquals(
       5, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL));
 }