org.dashbuilder.dataset.DataSetLookupConstraints.newDataSetLookup java code examples

  public void callback(DataSetMetadata metadata) {
    dataSetLookup = lookupConstraints.newDataSetLookup(metadata);
    updateDataSetLookup();
    changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));
  }
});

  public void callback(DataSetMetadata metadata) {
    dataSetLookup = lookupConstraints.newDataSetLookup(metadata);
    updateDataSetLookup();
    changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));
  }
});

@Test
public void testEmptyConstraints() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(null)
      .setGroupRequired(false);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertThat(result.getColumns().size()).isEqualTo(6);
  assertThat(result.getRowCount()).isEqualTo(50);
}

dataSetLookup = lookupConstraints.newDataSetLookup(dataSetMetadata);
changeEvent.fire(new DataSetLookupChangedEvent(dataSetLookup));

  @Test
  public void testColumnChanged() {
    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    GroupFunction gf = new GroupFunction("population", "population", AggregateFunctionType.SUM);
    presenter.onColumnFunctionChanged(new GroupFunctionChangedEvent(gf));
    assertEquals(gf.getColumnId(), "population_2");
  }
}

  @Test
  public void testColumnChanged() {
    DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
    presenter.init(DATA_2D_MULTIPLE, lookup);

    GroupFunction gf = new GroupFunction("population", "population", AggregateFunctionType.SUM);
    presenter.onColumnFunctionChanged(new GroupFunctionChangedEvent(gf));
    assertEquals(gf.getColumnId(), "population_2");
  }
}

@Test
public void testGroupWithLabels() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, LABEL})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][]{
      {"Barcelona", "Engineering"},
      {"Madrid", "Services"},
      {"Brno", "Support"},
      {"Westford", "Engineering"},
      {"Raleigh", "Management"},
      {"London", "Engineering"}
  }, 0);
}

@Test
public void testGroupMultipleColumns() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER, NUMBER, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
       {"Barcelona", "21.00", "2,913.14", "21.00"},
       {"Madrid", "57.00", "2,453.36", "57.00"},
       {"Brno", "153.00", "4,659.24", "153.00"},
       {"Westford", "234.00", "3,594.97", "234.00"},
       {"Raleigh", "481.00", "4,970.78", "481.00"},
       {"London", "329.00", "4,139.77", "329.00"}
   }, 0);
}

@Test
public void testGroupWithOneCalculation() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
      {"Barcelona", "21.00"},
      {"Madrid", "57.00"},
      {"Brno", "153.00"},
      {"Westford", "234.00"},
      {"Raleigh", "481.00"},
      {"London", "329.00"}
  }, 0);
}

@Test
public void testAddColumns() {
  DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
  presenter.init(DATA_2D_MULTIPLE, lookup);
  verify(view).setAddColumnOptionEnabled(true);
  presenter.onAddColumn();
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
  reset(event);
  GroupFunction gf = new GroupFunction("population", "population_2", AggregateFunctionType.SUM);
  presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(gf));
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
}

@Test
public void testAddColumns() {
  DataSetLookup lookup = DATA_2D_MULTIPLE.newDataSetLookup(POPULATION_META);
  presenter.init(DATA_2D_MULTIPLE, lookup);
  verify(view).setAddColumnOptionEnabled(true);
  presenter.onAddColumn();
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
  reset(event);
  GroupFunction gf = new GroupFunction("population", "population_2", AggregateFunctionType.SUM);
  presenter.onColumnFunctionDeleted(new GroupFunctionDeletedEvent(gf));
  verify(event).fire(any(DataSetLookupChangedEvent.class));
  assertEquals(presenter.getFirstGroupFunctions().size(), 3);
  assertEquals(presenter.getFirstGroupFunctions().get(2).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getColumnId(), "population_3");
  assertEquals(presenter.getFirstGroupFunctions().get(2).getFunction(), AggregateFunctionType.SUM);
  presenter.onAddColumn();
  assertEquals(presenter.getFirstGroupFunctions().size(), 4);
  assertEquals(presenter.getFirstGroupFunctions().get(3).getSourceId(), "population");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getColumnId(), "population_2");
  assertEquals(presenter.getFirstGroupFunctions().get(3).getFunction(), AggregateFunctionType.SUM);
}

@Test
public void testEmptyConstraints() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(null)
      .setGroupRequired(false);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertThat(result.getColumns().size()).isEqualTo(6);
  assertThat(result.getRowCount()).isEqualTo(50);
}

@Test
public void testMultipleColumns() {
  DataSetLookup lookup = MULTIPLE_COLUMNS.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNull(cg);
  assertEquals(groupOp.getGroupFunctions().size(), MULTIPLE_COLUMNS.getMinColumns());
  for (int i = 0; i < MULTIPLE_COLUMNS.getMinColumns(); i++) {
    GroupFunction gf = groupOp.getGroupFunction(METADATA.getColumnId(i));
    assertNotNull(gf);
    assertEquals(gf.getSourceId(), METADATA.getColumnId(i));
    assertEquals(gf.getColumnId(), METADATA.getColumnId(i));
    assertNull(gf.getFunction());
  }
}

@Test
public void testMultipleColumns() {
  DataSetLookup lookup = MULTIPLE_COLUMNS.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNull(cg);
  assertEquals(groupOp.getGroupFunctions().size(), MULTIPLE_COLUMNS.getMinColumns());
  for (int i = 0; i < MULTIPLE_COLUMNS.getMinColumns(); i++) {
    GroupFunction gf = groupOp.getGroupFunction(METADATA.getColumnId(i));
    assertNotNull(gf);
    assertEquals(gf.getSourceId(), METADATA.getColumnId(i));
    assertEquals(gf.getColumnId(), METADATA.getColumnId(i));
    assertNull(gf.getFunction());
  }
}

@Test
public void testGroupWithLabels() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, LABEL})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][]{
      {"Barcelona", "Engineering"},
      {"Madrid", "Services"},
      {"Brno", "Support"},
      {"Westford", "Engineering"},
      {"Raleigh", "Management"},
      {"London", "Engineering"}
  }, 0);
}

@Test
public void testGroupWithOneCalculation() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
      {"Barcelona", "21.00"},
      {"Madrid", "57.00"},
      {"Brno", "153.00"},
      {"Westford", "234.00"},
      {"Raleigh", "481.00"},
      {"London", "329.00"}
  }, 0);
}

@Test
public void testGroupMultipleColumns() throws Exception {
  DataSetLookupConstraints constraints = new DataSetLookupConstraints()
      .setColumnTypes(new ColumnType[] {LABEL, NUMBER, NUMBER, NUMBER})
      .setGroupRequired(true);
  DataSetLookup lookup = constraints.newDataSetLookup(dataSet.getMetadata());
  assertThat(constraints.check(lookup)).isNull();
  DataSet result = dataSetManager.lookupDataSet(lookup);
  assertDataSetValues(result, dataSetFormatter, new String[][] {
       {"Barcelona", "21.00", "2,913.14", "21.00"},
       {"Madrid", "57.00", "2,453.36", "57.00"},
       {"Brno", "153.00", "4,659.24", "153.00"},
       {"Westford", "234.00", "3,594.97", "234.00"},
       {"Raleigh", "481.00", "4,970.78", "481.00"},
       {"London", "329.00", "4,139.77", "329.00"}
   }, 0);
}

@Test
public void testLabelOnlyMetadata() {
  DataSetLookup lookup = lookupConstraints.newDataSetLookup(METADATA2);
  assertEquals(lookup.getDataSetUUID(), "test");

@Test
public void testTwoColumns() {
  DataSetLookup lookup = TWO_COLUMNS_GROUPED.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  assertEquals(groupOp.getGroupFunctions().size(), 2);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNotNull(groupOp);
  assertEquals(cg.getSourceId(), OFFICE);
  assertEquals(cg.getColumnId(), OFFICE);
  assertEquals(cg.getStrategy(), GroupStrategy.DYNAMIC);
  GroupFunction gf1 = groupOp.getGroupFunction(OFFICE);
  assertNotNull(gf1);
  assertNull(gf1.getFunction());
  assertEquals(gf1.getSourceId(), OFFICE);
  assertEquals(gf1.getColumnId(), OFFICE);
  GroupFunction gf2 = groupOp.getGroupFunction(AMOUNT);
  assertNotNull(gf2);
  assertNotNull(gf2.getFunction());
  assertEquals(gf2.getSourceId(), AMOUNT);
  assertEquals(gf2.getColumnId(), AMOUNT);
}
@Test

@Test
public void testTwoColumns() {
  DataSetLookup lookup = TWO_COLUMNS_GROUPED.newDataSetLookup(METADATA);
  assertEquals(lookup.getDataSetUUID(), "test");
  List<DataSetOp> opList = lookup.getOperationList();
  assertEquals(opList.size(), 1);
  List<DataSetGroup> groupList = lookup.getOperationList(DataSetGroup.class);
  assertEquals(groupList.size(), 1);
  DataSetGroup groupOp = groupList.get(0);
  assertNotNull(groupOp);
  assertEquals(groupOp.getGroupFunctions().size(), 2);
  ColumnGroup cg = groupOp.getColumnGroup();
  assertNotNull(groupOp);
  assertEquals(cg.getSourceId(), OFFICE);
  assertEquals(cg.getColumnId(), OFFICE);
  assertEquals(cg.getStrategy(), GroupStrategy.DYNAMIC);
  GroupFunction gf1 = groupOp.getGroupFunction(OFFICE);
  assertNotNull(gf1);
  assertNull(gf1.getFunction());
  assertEquals(gf1.getSourceId(), OFFICE);
  assertEquals(gf1.getColumnId(), OFFICE);
  GroupFunction gf2 = groupOp.getGroupFunction(AMOUNT);
  assertNotNull(gf2);
  assertNotNull(gf2.getFunction());
  assertEquals(gf2.getSourceId(), AMOUNT);
  assertEquals(gf2.getColumnId(), AMOUNT);
}
@Test

Popular methods of DataSetLookupConstraints

Popular in Java

Making http post requests using okhttp
getSupportFragmentManager (FragmentActivity)
runOnUiThread (Activity)
setContentView (Activity)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
URLConnection (java.net)
A connection to a URL for reading or writing. For HTTP connections, see HttpURLConnection for docume
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
Top 17 Free Sublime Text Plugins

How to use newDataSetLookupmethodin org.dashbuilder.dataset.DataSetLookupConstraints

Best Java code snippets using org.dashbuilder.dataset.DataSetLookupConstraints.newDataSetLookup (Showing top 20 results out of 315)

How to use
newDataSetLookup
method
in
org.dashbuilder.dataset.DataSetLookupConstraints